docs: def check_standard_name(self, ds):
          '''
          Check a variables's standard_name attribute to ensure that it meets CF
          compliance.
  
          CF §3.3 A standard name is associated with a variable via the attribute
          standard_name which takes a string value comprised of a standard name
          optionally followed by one or more blanks and a standard name modifier
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: list
          :return: List of results
          '''
          ret_val = []
  
          coord_vars = self._find_coord_vars(ds)
          aux_coord_vars = self._find_aux_coord_vars(ds)
          axis_vars = cfutil.get_axis_variables(ds)
          flag_vars = cfutil.get_flag_variables(ds)
          geophysical_vars = self._find_geophysical_vars(ds)
  
          variables_requiring_standard_names = coord_vars + aux_coord_vars + axis_vars + flag_vars + geophysical_vars
          for name in set(variables_requiring_standard_names):
              # Compression indices used in reduced horizontal grids or
              # compression schemes do not require attributes other than compress
              if cfutil.is_compression_coordinate(ds, name):
                  continue
  
              ncvar = ds.variables[name]
  
              # §9 doesn't explicitly allow instance variables as coordinates but
              # it's loosely implied. Just in case, skip it.
              if hasattr(ncvar, 'cf_role'):
                  continue
  
              # Unfortunately, §6.1 allows for string types to be listed as
              # coordinates.
              if ncvar.dtype.char == 'S':
                  continue
  
              standard_name = getattr(ncvar, 'standard_name', None)
              standard_name, standard_name_modifier = self._split_standard_name(standard_name)
              long_name = getattr(ncvar, 'long_name', None)
              long_or_std_name = TestCtx(BaseCheck.HIGH, self.section_titles['3.3'])
              if long_name is not None:
                  long_name_present = True
                  long_or_std_name.assert_true(isinstance(long_name, basestring),
                                               "Attribute long_name for variable {} must be a string".format(name))
              else:
                  long_name_present = False
              # §1.3 The long_name and standard_name attributes are used to
              # describe the content of each variable. For backwards
              # compatibility with COARDS neither is required, but use of at
              # least one of them is strongly recommended.
  
              # If standard_name is not defined but long_name is, don't continue
              # the check for this variable
              if standard_name is not None:
                  standard_name_present = True
                  valid_std_name = TestCtx(BaseCheck.HIGH, self.section_titles['3.3'])
                  valid_std_name.assert_true(isinstance(standard_name, basestring),
                                          "Attribute standard_name for variable {} must be a string".format(name))
                  if isinstance(standard_name, basestring):
                      valid_std_name.assert_true(standard_name in self._std_names,
                                              "standard_name {} is not defined in Standard Name Table v{}".format(
                                                  standard_name or 'undefined',
                                                  self._std_names._version))
  
                  ret_val.append(valid_std_name.to_result())
  
                  # 2) optional - if modifiers, should be in table
                  if standard_name_modifier is not None:
                      valid_modifier = TestCtx(BaseCheck.HIGH, self.section_titles["3.3"])
                      allowed = ['detection_minimum',
                              'number_of_observations',
                              'standard_error',
                              'status_flag']
                      valid_modifier.assert_true(standard_name_modifier in allowed,
                                              "standard_name modifier {} for variable {} is not a valid modifier "
                                              "according to appendix C".format(standard_name_modifier, name))
  
                      ret_val.append(valid_modifier.to_result())
              else:
                  standard_name_present = False
  
              long_or_std_name.assert_true(long_name_present or
                                              standard_name_present,
                                              "Attribute long_name or/and standard_name is highly recommended for variable {}".format(name))
              ret_val.append(long_or_std_name.to_result())
          return ret_val