docs: def _validate_resolution_output_length(path, entity_name, results, allow_mult=False, all_mult=False,
                                         ask_to_resolve=True):
      """
      :param path: Path to the object that required resolution; propagated from
                   command-line
      :type path: string
      :param entity_name: Name of the object
      :type entity_name: string
      :param results: Result of resolution; non-empty list of object
                      specifications (each specification is a dictionary with
                      keys "project" and "id")
      :type results: list of dictionaries
      :param allow_mult: If True, it is okay to choose from multiple results
                         of a single resolved object, or return all results
                         found; if False, raise an error if multiple results
                         are found
      :type allow_mult: boolean
      :param all_mult: If True, return all results if multiple results are
                       found for a single resolved object; if False, user needs
                       to choose a single result if multiple are found; the value
                       of all_mult only has an effect if allow_mult is True)
      :type all_mult: boolean
      :param ask_to_resolve: Whether picking may be necessary (if True, a
                             list is returned; if False, only one result
                             is returned); if specified as True, then all
                             results will be returned, regardless of the
                             values of allow_mult and all_mult
      :type ask_to_resolve: boolean
      :returns: The results of resolving entity_name, expected to be of the
                following form:
                <resolved_object>  # If only one result is present or the user
                                   # is able to select from multiple
                OR
                [<resolved_object>, ...]  # If multiple results are present and
                                          # it is allowed
                where <resolved_object> is of the following form:
                {"project": <project_id>, "id": <object_id>}
      :rtype: dict or list of dicts
      :raises: ValueError if results is empty
      :raises: ResolutionError if too many results are found and the user is
               not in interactive mode and cannot select one
  
      Precondition: results must be a nonempty list
  
      Validates length of results.
  
      If there are multiple results found and the user is in interactive mode,
      then the user will be prompted to select a single result to be returned.
      """
      if len(results) == 0:
          raise ValueError("'results' must be nonempty.")
  
      # Caller wants ALL results, so return the entire results list
      # At this point, do not care about the values of allow_mult or all_mult
      if not ask_to_resolve:
          return results
  
      if len(results) > 1:
          # The other way the caller can specify it wants all results is by setting
          # allow_mult to be True and allowing all_mult to be True (or if the object name is a glob pattern)
          if allow_mult and (all_mult or is_glob_pattern(entity_name)):
              return results
          if INTERACTIVE_CLI:
              print('The given path "' + path + '" resolves to the following data objects:')
              if any(['describe' not in result for result in results]):
                  # findDataObject API call must be made to get 'describe' mappings
                  project, folderpath, entity_name = resolve_path(path, expected='entity')
                  results = _resolve_global_entity(project, folderpath, entity_name)
              choice = pick([get_ls_l_desc(result['describe']) for result in results],
                            allow_mult=allow_mult)
              if allow_mult and choice == '*':
                  return results
              else:
                  return [results[choice]] if allow_mult else results[choice]
          else:
              raise ResolutionError('The given path "' + path + '" resolves to ' +
                                    str(len(results)) + ' data objects')
      else:
          return [results[0]] if allow_mult else results[0]