docs: def check_cell_methods(self, ds):
          """
          7.3 To describe the characteristic of a field that is represented by cell values, we define the cell_methods attribute
          of the variable. This is a string attribute comprising a list of blank-separated words of the form "name: method". Each
          "name: method" pair indicates that for an axis identified by name, the cell values representing the field have been
          determined or derived by the specified method.
  
          name can be a dimension of the variable, a scalar coordinate variable, a valid standard name, or the word "area"
  
          values of method should be selected from the list in Appendix E, Cell Methods, which includes point, sum, mean, maximum,
          minimum, mid_range, standard_deviation, variance, mode, and median. Case is not significant in the method name. Some
          methods (e.g., variance) imply a change of units of the variable, as is indicated in Appendix E, Cell Methods.
  
          Because the default interpretation for an intensive quantity differs from that of an extensive quantity and because this
          distinction may not be understood by some users of the data, it is recommended that every data variable include for each
          of its dimensions and each of its scalar coordinate variables the cell_methods information of interest (unless this
          information would not be meaningful). It is especially recommended that cell_methods be explicitly specified for each
          spatio-temporal dimension and each spatio-temporal scalar coordinate variable.
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: list
          :return: List of results
          """
  
          methods = {
              "point",
              "sum",
              "mean",
              "maximum",
              "minimum",
              "mid_range",
              "standard_deviation",
              "variance",
              "mode",
              "median"
          }
  
          ret_val = []
          psep = regex.compile(r'(?P<vars>\w+: )+(?P<method>\w+) ?(?P<where>where (?P<wtypevar>\w+) '
                               r'?(?P<over>over (?P<otypevar>\w+))?| ?)(?:\((?P<paren_contents>[^)]*)\))?')
  
          for var in ds.get_variables_by_attributes(cell_methods=lambda x: x is not None):
              if not getattr(var, 'cell_methods', ''):
                  continue
  
              method = getattr(var, 'cell_methods', '')
  
              valid_attribute = TestCtx(BaseCheck.HIGH,
                                        self.section_titles['7.1'])
              valid_attribute.assert_true(regex.match(psep, method) is not None,
                                          '"{}" is not a valid format for cell_methods attribute of "{}"'
                                          ''.format(method, var.name))
              ret_val.append(valid_attribute.to_result())
  
              valid_cell_names = TestCtx(BaseCheck.MEDIUM,
                                         self.section_titles['7.3'])
  
              # check that the name is valid
              for match in regex.finditer(psep, method):
                  # it is possible to have "var1: var2: ... varn: ...", so handle
                  # that case
                  for var_raw_str in match.captures('vars'):
                      # strip off the ' :' at the end of each match
                      var_str = var_raw_str[:-2]
                      if (var_str in var.dimensions or
                          var_str == 'area' or
                          var_str in getattr(var, "coordinates", "")):
  
                          valid = True
                      else:
                          valid = False
  
                      valid_cell_names.assert_true(valid,
                                                  '{}\'s cell_methods name component {} does not match a dimension, '
                                                  'area or auxiliary coordinate'.format(var.name, var_str))
  
              ret_val.append(valid_cell_names.to_result())
  
              # Checks if the method value of the 'name: method' pair is acceptable
              valid_cell_methods = TestCtx(BaseCheck.MEDIUM,
                                           self.section_titles['7.3'])
  
              for match in regex.finditer(psep, method):
                  # CF section 7.3 - "Case is not significant in the method name."
                  valid_cell_methods.assert_true(match.group('method').lower() in methods,
                                                 '{}:cell_methods contains an invalid method: {}'
                                                 ''.format(var.name, match.group('method')))
  
              ret_val.append(valid_cell_methods.to_result())
  
              for match in regex.finditer(psep, method):
                  if match.group('paren_contents') is not None:
                      # split along spaces followed by words with a colon
                      # not sure what to do if a comment contains a colon!
                      ret_val.append(self._check_cell_methods_paren_info(match.group('paren_contents'), var).to_result())
  
          return ret_val