docs: def check_grid_mapping(self, ds):
          """
          5.6 When the coordinate variables for a horizontal grid are not
          longitude and latitude, it is required that the true latitude and
          longitude coordinates be supplied via the coordinates attribute. If in
          addition it is desired to describe the mapping between the given
          coordinate variables and the true latitude and longitude coordinates,
          the attribute grid_mapping may be used to supply this description.
  
          This attribute is attached to data variables so that variables with
          different mappings may be present in a single file. The attribute takes
          a string value which is the name of another variable in the file that
          provides the description of the mapping via a collection of attached
          attributes. This variable is called a grid mapping variable and is of
          arbitrary type since it contains no data. Its purpose is to act as a
          container for the attributes that define the mapping.
  
          The one attribute that all grid mapping variables must have is
          grid_mapping_name which takes a string value that contains the mapping's
          name. The other attributes that define a specific mapping depend on the
          value of grid_mapping_name. The valid values of grid_mapping_name along
          with the attributes that provide specific map parameter values are
          described in Appendix F, Grid Mappings.
  
          When the coordinate variables for a horizontal grid are longitude and
          latitude, a grid mapping variable with grid_mapping_name of
          latitude_longitude may be used to specify the ellipsoid and prime
          meridian.
  
  
          In order to make use of a grid mapping to directly calculate latitude
          and longitude values it is necessary to associate the coordinate
          variables with the independent variables of the mapping. This is done by
          assigning a standard_name to the coordinate variable. The appropriate
          values of the standard_name depend on the grid mapping and are given in
          Appendix F, Grid Mappings.
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: list
          :return: List of results
          """
  
          ret_val = []
          grid_mapping_variables = cfutil.get_grid_mapping_variables(ds)
  
          # Check the grid_mapping attribute to be a non-empty string and that its reference exists
          for variable in ds.get_variables_by_attributes(grid_mapping=lambda x: x is not None):
              grid_mapping = getattr(variable, 'grid_mapping', None)
              defines_grid_mapping = TestCtx(BaseCheck.HIGH,
                                             self.section_titles["5.6"])
              defines_grid_mapping.assert_true((isinstance(grid_mapping, basestring) and grid_mapping),
                                               "{}'s grid_mapping attribute must be a "+\
                                               "space-separated non-empty string".format(variable.name))
  
              if isinstance(grid_mapping, basestring):
                  for grid_var_name in grid_mapping.split():
                      defines_grid_mapping.assert_true(grid_var_name in ds.variables,
                                                    "grid mapping variable {} must exist in this dataset".format(variable.name))
              ret_val.append(defines_grid_mapping.to_result())
  
          # Check the grid mapping variables themselves
          for grid_var_name in grid_mapping_variables:
              valid_grid_mapping = TestCtx(BaseCheck.HIGH, self.section_titles["5.6"])
              grid_var = ds.variables[grid_var_name]
  
              grid_mapping_name = getattr(grid_var, 'grid_mapping_name', None)
  
              # Grid mapping name must be in appendix F
              valid_grid_mapping.assert_true(grid_mapping_name in grid_mapping_dict,
                                             "{} is not a valid grid_mapping_name.".format(grid_mapping_name)+\
                                             " See Appendix F for valid grid mappings")
  
              # The grid_mapping_dict has a values of:
              # - required attributes
              # - optional attributes (can't check)
              # - required standard_names defined
              # - at least one of these attributes must be defined
  
              # We can't do any of the other grid mapping checks if it's not a valid grid mapping name
              if grid_mapping_name not in grid_mapping_dict:
                  ret_val.append(valid_grid_mapping.to_result())
                  continue
  
              grid_mapping = grid_mapping_dict[grid_mapping_name]
              required_attrs = grid_mapping[0]
              # Make sure all the required attributes are defined
              for req in required_attrs:
                  valid_grid_mapping.assert_true(hasattr(grid_var, req),
                                                 "{} is a required attribute for grid mapping {}".format(req, grid_mapping_name))
  
              # Make sure that exactly one of the exclusive attributes exist
              if len(grid_mapping_dict) == 4:
                  at_least_attr = grid_mapping_dict[3]
                  number_found = 0
                  for attr in at_least_attr:
                      if hasattr(grid_var, attr):
                          number_found += 1
                  valid_grid_mapping.assert_true(number_found == 1,
                                                 "grid mapping {}".format(grid_mapping_name) +\
                                                 "must define exactly one of these attributes: "+\
                                                 "{}".format(' or '.join(at_least_attr)))
  
              # Make sure that exactly one variable is defined for each of the required standard_names
              expected_std_names = grid_mapping[2]
              for expected_std_name in expected_std_names:
                  found_vars = ds.get_variables_by_attributes(standard_name=expected_std_name)
                  valid_grid_mapping.assert_true(len(found_vars) == 1,
                                                 "grid mapping {} requires exactly".format(grid_mapping_name)+\
                                                 "one variable with standard_name "+\
                                                 "{} to be defined".format(expected_std_name))
  
              ret_val.append(valid_grid_mapping.to_result())
  
          return ret_val