docs: def check_cell_boundaries(self, ds):
          """
          Checks the dimensions of cell boundary variables to ensure they are CF compliant.
  
          7.1 To represent cells we add the attribute bounds to the appropriate coordinate variable(s). The value of bounds
          is the name of the variable that contains the vertices of the cell boundaries. We refer to this type of variable as
          a "boundary variable." A boundary variable will have one more dimension than its associated coordinate or auxiliary
          coordinate variable. The additional dimension should be the most rapidly varying one, and its size is the maximum
          number of cell vertices.
  
          Applications that process cell boundary data often times need to determine whether or not adjacent cells share an
          edge. In order to facilitate this type of processing the following restrictions are placed on the data in boundary
          variables:
  
          Bounds for 1-D coordinate variables
  
              For a coordinate variable such as lat(lat) with associated boundary variable latbnd(x,2), the interval endpoints
              must be ordered consistently with the associated coordinate, e.g., for an increasing coordinate, lat(1) > lat(0)
              implies latbnd(i,1) >= latbnd(i,0) for all i
  
              If adjacent intervals are contiguous, the shared endpoint must be represented indentically in each instance where
              it occurs in the boundary variable. For example, if the intervals that contain grid points lat(i) and lat(i+1) are
              contiguous, then latbnd(i+1,0) = latbnd(i,1).
  
          Bounds for 2-D coordinate variables with 4-sided cells
  
              In the case where the horizontal grid is described by two-dimensional auxiliary coordinate variables in latitude
              lat(n,m) and longitude lon(n,m), and the associated cells are four-sided, then the boundary variables are given
              in the form latbnd(n,m,4) and lonbnd(n,m,4), where the trailing index runs over the four vertices of the cells.
  
          Bounds for multi-dimensional coordinate variables with p-sided cells
  
              In all other cases, the bounds should be dimensioned (...,n,p), where (...,n) are the dimensions of the auxiliary
              coordinate variables, and p the number of vertices of the cells. The vertices must be traversed anticlockwise in the
              lon-lat plane as viewed from above. The starting vertex is not specified.
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: list
          :return: List of results
          """
  
          # Note that test does not check monotonicity
          ret_val = []
          reasoning = []
          for variable_name, boundary_variable_name in cfutil.get_cell_boundary_map(ds).items():
              variable = ds.variables[variable_name]
              valid = True
              reasoning = []
              if boundary_variable_name not in ds.variables:
                  valid = False
                  reasoning.append("Boundary variable {} referenced by {} not ".format(
                                      boundary_variable_name, variable.name
                                      )+\
                                   "found in dataset variables")
              else:
                  boundary_variable = ds.variables[boundary_variable_name]
              # The number of dimensions in the bounds variable should always be
              # the number of dimensions in the referring variable + 1
              if (boundary_variable.ndim < 2):
                  valid = False
                  reasoning.append('Boundary variable {} specified by {}'.format(boundary_variable.name, variable.name)+\
                                   ' should have at least two dimensions to enclose the base '+\
                                   'case of a one dimensionsal variable')
              if (boundary_variable.ndim != variable.ndim + 1):
                  valid = False
                  reasoning.append('The number of dimensions of the variable %s is %s, but the '
                                   'number of dimensions of the boundary variable %s is %s. The boundary variable '
                                   'should have %s dimensions' %
                                   (variable.name, variable.ndim,
                                    boundary_variable.name,
                                    boundary_variable.ndim,
                                    variable.ndim + 1))
              if (variable.dimensions[:] != boundary_variable.dimensions[:variable.ndim]):
                  valid = False
                  reasoning.append(
                      u"Boundary variable coordinates (for {}) are in improper order: {}. Bounds-specific dimensions should be last"
                      "".format(variable.name, boundary_variable.dimensions))
  
              # ensure p vertices form a valid simplex given previous a...n
              # previous auxiliary coordinates
              if (ds.dimensions[boundary_variable.dimensions[-1]].size < len(boundary_variable.dimensions[:-1]) + 1):
                  valid = False
                  reasoning.append("Dimension {} of boundary variable (for {}) must have at least {} elements to form a simplex/closed cell with previous dimensions {}.".format(
                      boundary_variable.name,
                      variable.name,
                      len(variable.dimensions) + 1,
                      boundary_variable.dimensions[:-1])
                  )
              result = Result(BaseCheck.MEDIUM, valid, self.section_titles["7.1"], reasoning)
              ret_val.append(result)
          return ret_val