class_docstr: This class is responsible for loading tests according to various criteria
  and returning them wrapped in a TestSuite
docstr: Return a suite of all test cases contained in the given module
docstr_tok: ["Return","a","suite","of","all","test","cases","contained","in","the","given","module"]
code: def loadTestsFromModule(self, module, *args, pattern=None, **kws):
      """Return a suite of all test cases contained in the given module"""
      # This method used to take an undocumented and unofficial
      # use_load_tests argument.  For backward compatibility, we still
      # accept the argument (which can also be the first position) but we
      # ignore it and issue a deprecation warning if it's present.
      if len(args) > 0 or "use_load_tests" in kws:
          warnings.warn(
              "use_load_tests is deprecated and ignored",
              DeprecationWarning,
          )
          kws.pop("use_load_tests", None)
      if len(args) > 1:
          # Complain about the number of arguments, but don't forget the
          # required `module` argument.
          complaint = len(args) + 1
          raise TypeError(
              "loadTestsFromModule() takes 1 positional argument but {} were given".format(
                  complaint
              )
          )
      if len(kws) != 0:
          # Since the keyword arguments are unsorted (see PEP 468), just
          # pick the alphabetically sorted first argument to complain about,
          # if multiple were given.  At least the error message will be
          # predictable.
          complaint = sorted(kws)[0]
          raise TypeError(
              "loadTestsFromModule() got an unexpected keyword argument '{}'".format(
                  complaint
              )
          )
      tests = []
      for name in dir(module):
          obj = getattr(module, name)
          if (
              isinstance(obj, type)
              and issubclass(obj, case.TestCase)
              and obj not in (case.TestCase, case.FunctionTestCase)
          ):
              tests.append(self.loadTestsFromTestCase(obj))
  
      load_tests = getattr(module, "load_tests", None)
      tests = self.suiteClass(tests)
      if load_tests is not None:
          try:
              return load_tests(self, tests, pattern)
          except Exception as e:
              error_case, error_message = _make_failed_load_tests(
                  module.__name__, e, self.suiteClass
              )
              self.errors.append(error_message)
              return error_case
      return tests
  
imports: import os
  import re
  import sys
  import traceback
  import types
  import functools
  import warnings
  from fnmatch import fnmatch, fnmatchcase
  from .None import case, suite, util
label_desc: Use image node_id 3 for calling the TestLoader obj's underlying member method code with example usage: obj.loadTestsFromModule(module) and returns: tests, load_tests, error_case