a Sicv@sdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZddlmZz ddlZWneydZYn0ddlmZddlmZddlm Z dd l!m"Z"dd l!m#Z#z\ddl$Z$dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6WneyYn$0e$j7re$8d Z9ddl:Zej;jZ>ej?Z?ej@Z@ejAZAejBZBejCZCeDeEfZFd ZGddZHGdddejIZJddZKddZLddZMddZNejOdeLdd dZPejOdeMdd dZQejRdeKd d dejOd!d"d#d deOd$d"d%d&d'ZSeSeTfd(d)ZUGd*d+d+eVZWGd,d-d-eVZXGd.d/d/eVZYGd0d1d1ejZZZd2d3Z[d4d5Z\d6d7Z]d8d9Z^d:d;Z_dd?Zaddd@dAZbdBdCZcdDdEZddFdGZedHdIZfdJdKZgdLdMZhdNdOZidPdQZjGdRdSdSejkZkdTdUZldVdWZmdXdYZndedZd[Zod\d]Zpd^d_Zqd`daZrdbdcZsdS)fzBase functionality for Abseil Python tests. This module contains base classes and high-level functions for Abseil-style tests. )abcN)mock)parse)app)flags)logging)_pretty_print_reporter) xml_reporter)AnyAnyStrBinaryIOCallableContextManagerIOIteratorListMappingMutableMappingMutableSequenceOptionalSequenceTextTextIOTupleTypeUnion_TTcCs~|r tjSddSdS)aPExpects the test to fail if the run condition is True. Example usage:: @expectedFailureIf(sys.version.major == 2, "Not yet working in py2") def test_foo(self): ... Args: condition: bool, whether to expect failure or not. reason: Text, the reason to expect failure. Returns: Decorator function cSs|SNfrrQ/var/www/html/django/DPS/env/lib/python3.9/site-packages/absl/testing/absltest.pyzz#expectedFailureIf..N)unittestexpectedFailure) conditionreasonrrr!expectedFailureIfgsr(c@seZdZdZdZdZdS)TempFileCleanupalwayssuccessneverN)__name__ __module__ __qualname__ALWAYSSUCCESSOFFrrrr!r)}sr)cCs6d}tjdd}z t|}Wnty0Yn0|S)Ni-ZTEST_RANDOM_SEED)osenvirongetint ValueError) random_seedvaluerrr!_get_default_test_random_seeds  r;cCstjddS)z Returns default test source dir. TEST_SRCDIRr3r4r5r6rrrr!get_default_test_srcdirsr>cCs(tjdd}|s$tjtd}|S)zReturns default test temp dir. TEST_TMPDIRr3Z absl_testing)r4r5r6pathjointempfile gettempdir)tmpdirrrr!get_default_test_tmpdirsrEcCstdjrtj}ndtjvr(tjd}nd}|s4dS|dkrLtddS|dkrXdSzt|}|dkrp|WSWnt yYn0t d |d S) aReturns default seed to use for randomizing test order. This function first checks the --test_randomize_ordering_seed flag, and then the TEST_RANDOMIZE_ORDERING_SEED environment variable. If the first value we find is: * (not set): disable test randomization * 0: disable test randomization * 'random': choose a random seed in [1, 4294967295] for test order randomization * positive integer: use this seed for test order randomization (The values used are patterned after https://docs.python.org/3/using/cmdline.html#envvar-PYTHONHASHSEED). In principle, it would be simpler to return None if no override is provided; however, the python random module has no `get_seed()`, only `getstate()`, which returns far more data than we want to pass via an environment variable or flag. Returns: A default value for test case randomization (int). 0 means do not randomize. Raises: ValueError: Raised when the flag or env value is not one of the options above. test_randomize_ordering_seedZTEST_RANDOMIZE_ORDERING_SEEDr3rrandoml0z)Unknown test randomization seed value: {}N) FLAGSpresentrFr4r5rGRandomrandintr7r8format)Z randomizeseedrrr!$_get_default_randomize_ordering_seeds(     rPZ test_srcdirz.Root of directory tree where source files live)allow_override_cppZ test_tmpdirz%Directory for temporary testing filesZtest_random_seedzRandom seed for testing. Some test frameworks may change the default value of this flag between runs, so it is not appropriate for seeding probabilistic tests.rFr3aIf positive, use this as a seed to randomize the execution order for test cases. If "random", pick a random seed to use. If 0 or not set, do not randomize test case execution order. This flag also overrides the TEST_RANDOMIZE_ORDERING_SEED environment variable.xml_output_filezFile to store XML test resultscCsLdd}t}|tdd|rH|tj_|rHtjddS)z3Workaround for .cSs4t|jt|jko.t|jko.dkSS)zTells whether or not this result was a success. Any unexpected pass is to be counted as a non-success. Args: self: The TestResult instance. Returns: Whether or not this result was a success. r)lenfailureserrorsunexpectedSuccessesselfrrr! wasSuccessfuls zF_monkey_patch_test_result_for_unexpected_passes..wasSuccessfulcSsdSrrrrrr!r"r#zA_monkey_patch_test_result_for_unexpected_passes..z^unittest.result.TestResult monkey patch to report unexpected passes as failures did not work. N)r$ TestResultaddUnexpectedSuccessFunctionTestCaserYsysstderrwrite)rY test_resultrrr!/_monkey_patch_test_result_for_unexpected_passessracCs|||ddS)zOpens a file. Like open(), but ensure that we can open real files even if tests stub out open(). Args: filepath: A filepath. mode: A mode. _open_func: A built-in open() function. Returns: The opened file object. utf-8)encodingr)filepathmodeZ _open_funcrrr!_opensrfc@s@eZdZdZddZeddZddZdd d ZdddZ dS)_TempDiraRepresents a temporary directory for tests. Creation of this class is internal. Using its public methods is OK. This class implements the `os.PathLike` interface (specifically, `os.PathLike[str]`). This means, in Python 3, it can be directly passed to e.g. `os.path.join()`. cCs ||_dS)z2Module-private: do not instantiate outside module.N_pathrXr@rrr!__init__7sz_TempDir.__init__cCs|jS)zReturns the path, as a string, for the directory. TIP: Instead of e.g. `os.path.join(temp_dir.full_path)`, you can simply do `os.path.join(temp_dir)` because `__fspath__()` is implemented. rhrWrrr! full_path<sz_TempDir.full_pathcCs|jSzSee os.PathLike.rlrWrrr! __fspath__Fsz_TempDir.__fspath__Nwutf8strictcCst|j|||||\}}|S)aCreate a file in the directory. NOTE: If the file already exists, it will be made writable and overwritten. Args: file_path: Optional file path for the temp file. If not given, a unique file name will be generated and used. Slashes are allowed in the name; any missing intermediate directories will be created. NOTE: This path is the path that will be cleaned up, including any directories in the path, e.g., 'foo/bar/baz.txt' will `rm -r foo` content: Optional string or bytes to initially write to the file. If not specified, then an empty file is created. mode: Mode string to use when writing content. Only used if `content` is non-empty. encoding: Encoding to use when writing string content. Only used if `content` is text. errors: How to handle text to bytes encoding errors. Only used if `content` is text. Returns: A _TempFile representing the created file. ) _TempFile_createri)rX file_pathcontentrercrUtf_rrr! create_fileKsz_TempDir.create_filecCs:|rtj|j|}ntj|jd}tj|ddt|S)zCreate a directory in the directory. Args: dir_path: Optional path to the directory to create. If not given, a unique name will be generated and used. Returns: A _TempDir representing the created directory. dirTexist_ok)r4r@rArirBmkdtempmakedirsrg)rXZdir_pathr@rrr!mkdirhs z_TempDir.mkdir)NNrprqrr)N) r-r.r/__doc__rkpropertyrlroryrrrrr!rg-s   rgc@seZdZdZddZeddZeddZdd Z d d d Z ddZ d!ddZ d"ddZ d#ddZd$ddZejd%eeeeedddZdS)&rsaRepresents a tempfile for tests. Creation of this class is internal. Using its public methods is OK. This class implements the `os.PathLike` interface (specifically, `os.PathLike[str]`). This means, in Python 3, it can be directly passed to e.g. `os.path.join()`. cCs ||_dS)zPrivate: use _create instead.Nrhrjrrr!rksz_TempFile.__init__c Cs|rttj|t|}tj||}tjtj|ddtj|rt|tjst |} t || j t j Bn0tj|ddt jt|d\} }t| |}||} |rt|tr| j||||dq| ||n | d| |fS)z+Module-private: create a tempfile instance.Tr|rzrercrUr#)r4r@rA_get_first_partrdirnameexistsaccessW_OKstatchmodst_modeS_IWUSRrBmkstempstrclose isinstance write_text write_bytes) cls base_pathrurvrercrU cleanup_pathr@ stat_infofdrwrrr!rts$    z_TempFile._createcCs|jS)zReturns the path, as a string, for the file. TIP: Instead of e.g. `os.path.join(temp_file.full_path)`, you can simply do `os.path.join(temp_file)` because `__fspath__()` is implemented. rhrWrrr!rlsz_TempFile.full_pathcCs|jSrmrnrWrrr!rosz_TempFile.__fspath__rqrrcCs:|j||d}|WdS1s,0YdS)z(Return the contents of the file as text.rcrUN) open_textread)rXrcrUfprrr! read_textsz_TempFile.read_textcCs4|}|WdS1s&0YdS)z(Return the content of the file as bytes.N) open_bytesr)rXrrrr! read_bytess z_TempFile.read_bytesrpcCs>|j|||d}||Wdn1s00YdS)aWrite text to the file. Args: text: Text to write. In Python 2, it can be bytes, which will be decoded using the `encoding` arg (this is as an aid for code that is 2 and 3 compatible). mode: The mode to open the file for writing. encoding: The encoding to use when writing the text to the file. errors: The error handling strategy to use when converting text to bytes. rN)rr_)rXtextrercrUrrrr!rs z_TempFile.write_textwbcCs8||}||Wdn1s*0YdS)zWrite bytes to the file. Args: data: bytes to write. mode: Mode to open the file for writing. The "b" flag is implicit if not already present. It must not have the "t" flag. N)rr_)rXdatarerrrr!rs z_TempFile.write_bytesrtcCs8d|vrtd|d|vr&|d7}||||}|S)aReturn a context manager for opening the file in text mode. Args: mode: The mode to open the file in. The "t" flag is implicit if not already present. It must not have the "b" flag. encoding: The encoding to use when opening the file. errors: How to handle decoding errors. Returns: Context manager that yields an open file. Raises: ValueError: if invalid inputs are provided. bzFInvalid mode {!r}: "b" flag not allowed when opening file in text modetr8rNrf)rXrercrUcmrrr!rsz_TempFile.open_textrbcCs:d|vrtd|d|vr&|d7}|j|ddd}|S)aLReturn a context manager for opening the file in binary mode. Args: mode: The mode to open the file in. The "b" mode is implicit if not already present. It must not have the "t" flag. Returns: Context manager that yields an open file. Raises: ValueError: if invalid inputs are provided. rzHInvalid mode {!r}: "t" flag not allowed when opening file in binary moderNrr)rXrerrrr!rsz_TempFile.open_bytes)rercrUreturnccs>tj|j|||d}|VWdn1s00YdS)Nr)ioopenrl)rXrercrUrrrr!rfs  z_TempFile._openN)rqrr)rprqrr)r)rrqrr)r)rqrr)r-r.r/rrk classmethodrtrrlrorrrrrr contextlibcontextmanagerrrr rfrrrr!rs~s&       rsc@s0eZdZdZddZddZddZdd Zd S) _methodaoA decorator that supports both instance and classmethod invocations. Using similar semantics to the @property builtin, this decorator can augment an instance method to support conditional logic when invoked on a class object. This breaks support for invoking an instance method via the class (e.g. Cls.method(self, ...)) but is still situationally useful. cCs||_d|_dSr)_finstancemethod _fclassmethod)rXZfinstancemethodrrr!rk(sz_method.__init__cCst||_|Sr)rr)rXZ fclassmethodrrr!r-s z_method.classmethodcCs,t|jdr|jjSt|jdr(|jjSdS)Nrr3)getattrrrrrWrrr!r2s   z_method.__doc__cCs |dur|jn|j}|||Sr)rr__get__)rXobjtype_funcrrr!r:sz_method.__get__N)r-r.r/rrkrrrrrr!rs rcseZdZdZejZdZdZdZ dZ fddZ fddZ e fd d Zdmd d ZdnddZeddZej ddZe ddZddZddZddZedefeedddd Zeed!d"d#Zfd$d%Zdod&d'Zdpd(d)Zdqd*d+Z drd,d-Z!dsd.d/Z"dtd0d1Z#dud2d3Z$dvd4d5Z%dwd6d7Z&dxd8d9Z'dyd:d;Z(dzfdd?Z*d|d@dAZ+d}dBdCZ,d~dDdEZ-ddGdHZ.ddIdJZ/GdKdLdLe0Z1e2j3e1dMdNdOZ4e2j3edefddPdQdOZ4ddRdOZ4e2j3e1dMdSdTZ5e2j3edefddPdUdTZ5ddVdTZ5ddWdXZ6ddYdZZ7dd[d\Z8d]d^Z9dd_d`Z:ddadbZ;ddedfZdfdkdl Z?Z@S)TestCasez4Extension of unittest.TestCase providing more power.i@TNcs&tt|j|i|t|d|_dS)N_outcome)superrrkrr)rXargskwargs __class__rr!rkTszTestCase.__init__cs4tt|ttdr0t|_||jjdS)N ExitStack) rrsetUphasattrrr _exit_stack addCleanuprrWrrr!rYs  zTestCase.setUpcs>tt|ttdr:t|dr:t|_||jjdS)NraddClassCleanup) rr setUpClassrrr_cls_exit_stackrrrrrr!r`s zTestCase.setUpClasscCsv|}|r.tj||}tj|t|}ntj|ddtj|d}|}t|tj|dd| ||t |S)aCreate a temporary directory specific to the test. NOTE: The directory and its contents will be recursively cleared before creation. This ensures that there is no pre-existing state. This creates a named directory on disk that is isolated to this test, and will be properly cleaned up by the test. This avoids several pitfalls of creating temporary directories for test purposes, as well as makes it easier to setup directories and verify their contents. For example:: def test_foo(self): out_dir = self.create_tempdir() out_log = out_dir.create_file('output.log') expected_outputs = [ os.path.join(out_dir, 'data-0.txt'), os.path.join(out_dir, 'data-1.txt'), ] code_under_test(out_dir) self.assertTrue(os.path.exists(expected_paths[0])) self.assertTrue(os.path.exists(expected_paths[1])) self.assertEqual('foo', out_log.read_text()) See also: :meth:`create_tempdir` for creating temporary files. Args: name: Optional name of the directory. If not given, a unique name will be generated and used. cleanup: Optional cleanup policy on when/if to remove the directory (and all its contents) at the end of the test. If None, then uses :attr:`tempfile_cleanup`. Returns: A _TempDir representing the created directory; see _TempDir class docs for usage. Tr|rz) _get_tempdir_path_testr4r@rArrrBr~_rmtree_ignore_errors_maybe_add_temp_path_cleanuprg)rXnamecleanup test_pathr@rrrr!create_tempdiris%  zTestCase.create_tempdirrprqrrc Cs2|}tj||||||d\}} || ||S)aCreate a temporary file specific to the test. This creates a named file on disk that is isolated to this test, and will be properly cleaned up by the test. This avoids several pitfalls of creating temporary files for test purposes, as well as makes it easier to setup files, their data, read them back, and inspect them when a test fails. For example:: def test_foo(self): output = self.create_tempfile() code_under_test(output) self.assertGreater(os.path.getsize(output), 0) self.assertEqual('foo', output.read_text()) NOTE: This will zero-out the file. This ensures there is no pre-existing state. NOTE: If the file already exists, it will be made writable and overwritten. See also: :meth:`create_tempdir` for creating temporary directories, and ``_TempDir.create_file`` for creating files within a temporary directory. Args: file_path: Optional file path for the temp file. If not given, a unique file name will be generated and used. Slashes are allowed in the name; any missing intermediate directories will be created. NOTE: This path is the path that will be cleaned up, including any directories in the path, e.g., ``'foo/bar/baz.txt'`` will ``rm -r foo``. content: Optional string or bytes to initially write to the file. If not specified, then an empty file is created. mode: Mode string to use when writing content. Only used if `content` is non-empty. encoding: Encoding to use when writing string content. Only used if `content` is text. errors: How to handle text to bytes encoding errors. Only used if `content` is text. cleanup: Optional cleanup policy on when/if to remove the directory (and all its contents) at the end of the test. If None, then uses :attr:`tempfile_cleanup`. Returns: A _TempFile representing the created file; see _TempFile class docs for usage. )rvrercrU)rrsrtr) rXrurvrercrUrrrwrrrr!create_tempfiles0   zTestCase.create_tempfilecCs|jstd|j|S)aReturns the CM's value after registering it with the exit stack. Entering a context pushes it onto a stack of contexts. When `enter_context` is called on the test instance (e.g. `self.enter_context`), the context is exited after the test case's tearDown call. When called on the test class (e.g. `TestCase.enter_context`), the context is exited after the test class's tearDownClass call. Contexts are exited in the reverse order of entering. They will always be exited, regardless of test failure/success. This is useful to eliminate per-test boilerplate when context managers are used. For example, instead of decorating every test with `@mock.patch`, simply do `self.foo = self.enter_context(mock.patch(...))' in `setUp()`. NOTE: The context managers will always be exited without any error information. This is an unfortunate implementation detail due to some internals of how unittest runs tests. Args: manager: The context manager to enter. zgself._exit_stack is not set: enter_context is Py3-only; also make sure that AbslTest.setUp() is called.)rAssertionError enter_context)rXmanagerrrr!rs zTestCase.enter_contextcCs|jstd|j|S)Nz|cls._cls_exit_stack is not set: cls.enter_context requires Python 3.8+; also make sure that AbslTest.setUpClass() is called.)rrr)rrrrr!rs cCstjtj|jddS)N __main__.r3)r4r@rAr?r:r/replacerrrr!_get_tempdir_path_clss  zTestCase._get_tempdir_path_clscCstj||jSr)r4r@rAr_testMethodNamerWrrr!rszTestCase._get_tempdir_path_testcCs|dur |S|jSr)tempfile_cleanup)rXoverriderrr!_get_tempfile_cleanup szTestCase._get_tempfile_cleanupcCsZ||}|tjkrdS|tjkr0|t|n&|tjkrH|t|ntd |dS)NzUnexpected cleanup value: {}) rr)r2r0rrr1 _internal_add_cleanup_on_successrrN)rXr@rrrr!rs    z%TestCase._maybe_add_temp_path_cleanup.)functionrrrcsVj}t|jjt|jjt|jjfdd}j|g|Ri|dS)z7Adds `function` as cleanup when the test case succeeds.cs sdS|i|dSr)3_internal_ran_and_passed_when_called_during_cleanuprrrprevious_failure_countrXrr!_call_cleaner_on_success(s zKTestCase._internal_add_cleanup_on_success.._call_cleaner_on_successN)rrSresultrTrUrVr)rXrrroutcomerrrr!rs   z)TestCase._internal_add_cleanup_on_success)rrcCsf|j}tjdddkrDt|jjt|jjt|jj}||kS|}| ||j| SdS)zEReturns whether test is passed. Expected to be called during cleanup.N) ) rr] version_inforSrrTrUrVdefaultTestResult_feedErrorsToResultrY)rXrrZcurrent_failure_countrrrr!r/s   zFor whole: len(%s) is not supported, it appears to be type: %sz4Prefix length (%d) is longer than whole length (%d).z-Prefix length is 0 but whole length is %d: %sNz+prefix: %s not found at start of whole: %s.)rS TypeErrorNotImplementedErrorrtype_formatMessageassertSequenceEqualr)rXprefixZwholer prefix_lenZ whole_lenrrr!assertSequenceStartsWithsB       z!TestCase.assertSequenceStartsWithcCsHt|tjs$|dt|j|t|rD|d|t||dS)zAsserts that an object has zero length. Args: container: Anything that implements the collections.abc.Sized interface. msg: Optional message to report on failure. "Expected a Sized object, got: {!r}z{!r} has length of {}.NrrSizedrrNrr-rSrX containerrrrr! assertEmptys zTestCase.assertEmptycCsBt|tjs$|dt|j|t|s>|d||dS)zAsserts that an object has non-zero length. Args: container: Anything that implements the collections.abc.Sized interface. msg: Optional message to report on failure. rz{!r} has length of 0.Nrrrrr!assertNotEmptys zTestCase.assertNotEmptycCsZt|tjs$|dt|j|t||krVtj |}|d|t|||dS)zAsserts that an object has the expected length. Args: container: Anything that implements the collections.abc.Sized interface. expected_len: The expected length of the container. msg: Optional message to report on failure. rz!{} has length of {}, expected {}.N) rrrrrNrr-rSr$util safe_repr)rXr expected_lenrZcontainer_reprrrr! assertLens    zTestCase.assertLenc Cst|t|kr,|dt|t||g}tt||D]^\}\}} z|j|| |||dWq>|jy} z|d|| WYd} ~ q>d} ~ 00q>|rt|dkr|dddg}||d |}||dS)akAn approximate equality assertion for ordered sequences. Fail if the two sequences are unequal as determined by their value differences rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between each value in the two sequences is more than the given delta. Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit). If the two sequences compare equal then they will automatically compare almost equal. Args: expected_seq: A sequence containing elements we are expecting. actual_seq: The sequence that we are testing. places: The number of decimal places to compare. msg: The message to be printed if the test fails. delta: The OK difference between compared values. z Sequence size mismatch: {} vs {})placesrdeltazAt index {}: {}N...r) rSrrN enumeratezipassertAlmostEqualfailureExceptionappendrrA) rX expected_seq actual_seqr rr Zerr_listidxZexp_elemZact_elemerrrrr!assertSequenceAlmostEquals&   * z"TestCase.assertSequenceAlmostEqualcCs2t|t|}|sdS|d|||f|dS)zBChecks whether actual iterable is a superset of expected iterable.Nz+Missing elements %s Expected: %s Actual: %ssetr)rXZexpected_subsetZ actual_setrmissingrrr!assertContainsSubsetszTestCase.assertContainsSubsetcCs2t|t|@}|sdS|d|||f|dS)zBChecks whether actual iterable and expected iterable are disjoint.Nz*Common elements %s Expected: %s Actual: %sr)rXrrrcommonrrr!assertNoCommonElementsszTestCase.assertNoCommonElementscst|||dS)aDeprecated, please use assertCountEqual instead. This is equivalent to assertCountEqual. Args: expected_seq: A sequence containing elements we are expecting. actual_seq: The sequence that we are testing. msg: The message to be printed if the test fails. N)rassertCountEqual)rXrrrrrr!assertItemsEqual's zTestCase.assertItemsEqualcst|tst|tr&|d||fz\tdd|Dtdd|DfddD}fddD}||Wn@tyt|t|t\}}Yn0g}|r||df|r| d||r| d ||s |r|d |d S) a1Asserts that two sequences have the same elements (in any order). This method, unlike assertCountEqual, doesn't care about any duplicates in the expected and actual sequences:: # Doesn't raise an AssertionError assertSameElements([1, 1, 1, 0, 0, 0], [0, 1]) If possible, you should use assertCountEqual instead of assertSameElements. Args: expected_seq: A sequence containing elements we are expecting. actual_seq: The sequence that we are testing. msg: The message to be printed if the test fails. zuPassing string/bytes to assertSameElements is usually a bug. Did you mean to use assertEqual? Expected: %s Actual: %scSsg|] }|dfqSrr.0elementrrr! Qr#z/TestCase.assertSameElements..cSsg|] }|dfqSrrr!rrr!r$Rr#csg|]}|vr|qSrrr!)rrr!r$Sr#csg|]}|vr|qSrrr!)expectedrr!r$Tr#: zExpected, but missing: %r zUnexpected, but present: %r r3N) r_TEXT_OR_BINARY_TYPESrdictsortrlist_sorted_list_differenceextendrrA)rXrrrr unexpectedrUr)rr%r!assertSameElements3s8    zTestCase.assertSameElementsc Ks t|tsJd|ft|ts0Jd|f|dd}|rRtdt|||kr^dS|rn|dg}ndg}|r|t|7}t| d | d D]"}| || ds| dq|rt||krt||}|d|}| d || d |dS) z.Asserts that two multi-line strings are equal.z"First argument is not a string: %rz#Second argument is not a string: %r line_limitrzUnexpected keyword args {}Nr&rTz3(... and {} more delta lines omitted for brevity.) r3)rrpoprrNtuplerSdifflibndiff splitlinesrrrrA) rXfirstsecondrrr/failure_messagelineZ n_omittedrrr!assertMultiLineEqualksB        zTestCase.assertMultiLineEqualcCs:||d|||f}|||k||||k|dS)z8Asserts that value is between minv and maxv (inclusive).z+"%r" unexpectedly not between "%r" and "%r"N)r assertTrue)rXr:ZminvZmaxvrrrr! assertBetweenszTestCase.assertBetweencCst|tr|d||s&|d|t|d}|ddD]}t||ur>|d|q>|turt|trdd|D}t}n$|turt|trd d|D}t}|turd d |}n(|turd d |d}n |d|t||tj s |d||f|dS)aAsserts that at least one regex in regexes matches str. If possible you should use `assertRegex`, which is a simpler version of this method. `assertRegex` takes a single regular expression (a string or re compiled object) instead of a list. Notes: 1. This function uses substring matching, i.e. the matching succeeds if *any* substring of the error message matches *any* regex in the list. This is more convenient for the user than full-string matching. 2. If regexes is the empty list, the matching will always fail. 3. Use regexes=[''] for a regex that will always pass. 4. '.' matches any single character *except* the newline. To match any character, use '(.|\n)'. 5. '^' matches the beginning of each line, not just the beginning of the string. Similarly, '$' matches the end of each line. 6. An exception will be thrown if regexes contains an invalid regex. Args: actual_str: The string we try to match with the items in regexes. regexes: The regular expressions we want to match against str. See "Notes" above for detailed notes on how this is interpreted. message: The message to be printed if the test fails. z4regexes is string or bytes; use assertRegex instead.zNo regexes specified.rrHNz'regexes list must all be the same type.cSsg|]}|dqSrb)decoder"regexrrr!r$r#z-TestCase.assertRegexMatch..cSsg|]}|dqSr<encoder>rrr!r$r#z(?:%s)z)|(?:s(?:s)|(?:)z8Only know how to deal with unicode str or bytes regexes.z/"%s" does not contain any of these regexes: %s.) rr'rrbytesrrAresearch MULTILINE)rXZ actual_strregexesmessageZ regex_typer?rrr!assertRegexMatchs:!    zTestCase.assertRegexMatchr#c Cst|||\}}t|dtr,dd|D}t|}||d||dt||t|f|j||||dt||t||fddS)anAsserts that a shell command succeeds (i.e. exits with code 0). Args: command: List or string representing the command to run. regexes: List of regular expression byte strings that match success. env: Dictionary of environment variable settings. If None, no environment variables will be set for the child process. This is to make tests more hermetic. NOTE: this behavior is different than the standard subprocess module. close_fds: Whether or not to close all open fd's in the child after forking. msg: Optional message to report on failure. rcSsg|]}|dqSr<r@r>rrr!r$r#z2TestCase.assertCommandSucceeds..z;Running command %s failed with error code %s and message %sXRunning command %s failed with error code %s and message %s which matches no regex in %srHN)get_command_stderrrrget_command_string assertEqualr_quote_long_stringrI rXcommandrGenv close_fdsrZret_codercommand_stringrrr!assertCommandSucceedss: zTestCase.assertCommandSucceedsc Cst|||\}}t|dtr,dd|D}t|}||d||dt||j||||dt||t||fddS)aaAsserts a shell command fails and the error matches a regex in a list. Args: command: List or string representing the command to run. regexes: the list of regular expression strings. env: Dictionary of environment variable settings. If None, no environment variables will be set for the child process. This is to make tests more hermetic. NOTE: this behavior is different than the standard subprocess module. close_fds: Whether or not to close all open fd's in the child after forking. msg: Optional message to report on failure. rcSsg|]}|dqSr<r@r>rrr!r$r#z/TestCase.assertCommandFails..z:The following command succeeded while expected to fail: %srKrLN)rMrrrNassertNotEqualrrPrIrQrrr!assertCommandFailss0zTestCase.assertCommandFailsc@s&eZdZdddZddZddZdS) zTestCase._AssertRaisesContextNcCs||_||_||_||_dSr)expected_exception test_case test_funcr)rXrYrZr[rrrr!rk+sz&TestCase._AssertRaisesContext.__init__cCs|SrrrWrrr! __enter__1sz'TestCase._AssertRaisesContext.__enter__cCsN|dur |j|jjd|jt||js0dS|||rJ|d|_dS)Nz not raisedFT) rZrrYr-r issubclassr[with_traceback exception)rXexc_type exc_valuetbrrr!__exit__4s   z&TestCase._AssertRaisesContext.__exit__)N)r-r.r/rkr\rcrrrr!_AssertRaisesContext)s rd)rcCs|dddSrrd)rXrY predicaterrr!assertRaisesWithPredicateMatch?sz'TestCase.assertRaisesWithPredicateMatch) callable_objrcOs|dddSrre)rXrYrfrhrrrrr!rgFscs^fdd}||}|dur(|S|||i|Wdn1sP0YdS)a?Asserts that exception is thrown and predicate(exception) is true. Args: expected_exception: Exception class expected to be raised. predicate: Function of one argument that inspects the passed-in exception and returns True (success) or False (please fail the test). callable_obj: Function to be called. *args: Extra args. **kwargs: Extra keyword args. Returns: A context manager if callable_obj is None. Otherwise, None. Raises: self.failureException if callable_obj does not raise a matching exception. cs|d|fdS)Nz%r does not match predicate %r)r:)rrfrXrr!Check`s  z6TestCase.assertRaisesWithPredicateMatch..CheckNre)rXrYrfrhrrrjcontextrrir!rgNs cCs|dddSrre)rXrYexpected_exception_messagerrr!assertRaisesWithLiteralMatchjsz%TestCase.assertRaisesWithLiteralMatchcOs|dddSrre)rXrYrlrhrrrrr!rmrscs^fdd}||}|dur(|S|||i|Wdn1sP0YdS)a)Asserts that the message in a raised exception equals the given string. Unlike assertRaisesRegex, this method takes a literal string, not a regular expression. with self.assertRaisesWithLiteralMatch(ExType, 'message'): DoSomething() Args: expected_exception: Exception class expected to be raised. expected_exception_message: String message expected in the raised exception. For a raise exception e, expected_exception_message must equal str(e). callable_obj: Function to be called, or None to return a context. *args: Extra args. **kwargs: Extra kwargs. Returns: A context manager if callable_obj is None. Otherwise, None. Raises: self.failureException if callable_obj does not raise a matching exception. cs$t|}|kd|fdS)Nz9Exception message does not match. Expected: %r Actual: %r)rr:)rZactual_exception_messagerlrXrr!rjs z4TestCase.assertRaisesWithLiteralMatch..CheckNre)rXrYrlrhrrrjrkrrnr!rmzs cCst|ttturtntfr |f}d}d}|D]`}|t||}|dkrf|dkrf|d||f|n|dkr|d|||f||}|}q,dS)atAsserts that the strings provided are found in the target in order. This may be useful for checking HTML output. Args: strings: A list of strings, such as [ 'fox', 'dog' ] target: A target string in which to look for the strings, such as 'The quick brown fox jumped over the lazy dog'. msg: Optional message to report on failure. rNzDid not find '%s' in '%s'z$Did not find '%s' after '%s' in '%s')rrCrunicodefindr)rXstringstargetr current_indexZ last_stringstringindexrrr!assertContainsInOrders( zTestCase.assertContainsInOrdercCsbd}tt|}t|}|D]"}||vr0|}q@||krq0q|dur^|d|||f|dS)aAsserts that "container" contains "subsequence" as a subsequence. Asserts that "container" contains all the elements of "subsequence", in order, but possibly with other elements interspersed. For example, [1, 2, 3] is a subsequence of [0, 0, 1, 2, 0, 3, 0] but not of [0, 0, 1, 3, 0, 2, 0]. Args: container: the list we're testing for subsequence inclusion. subsequence: the list we hope will be a subsequence of container. msg: Optional message to report on failure. Nz:%s not a subsequence of %s. First non-matching element: %s)r*reversedr0r)rXr subsequencerZfirst_nonmatchingZreversed_containererrr!assertContainsSubsequences   z"TestCase.assertContainsSubsequencecCst|}t|}d}tdt|t|D]L}|t|kr@qzd}|t|krn|||||krn|d7}qDt||}q,|t|kr|d|||d|f|dS)aAsserts that "container" contains "subsequence" as an exact subsequence. Asserts that "container" contains all the elements of "subsequence", in order, and without other elements interspersed. For example, [1, 2, 3] is an exact subsequence of [0, 0, 1, 2, 3, 0] but not of [0, 0, 1, 2, 0, 3, 0]. Args: container: the list we're testing for subsequence inclusion. subsequence: the list we hope will be an exact subsequence of container. msg: Optional message to report on failure. rrHz>%s not an exact subsequence of %s. Longest matching prefix: %sN)r*rangerSmaxr)rXrryrZ longest_matchstartrvrrr!assertContainsExactSubsequences$      z'TestCase.assertContainsExactSubsequencec sfdd}fdd}|dtj|D]F}t|}t|ddD](\}}||ddD]}|||qdqLq0|D]8} | D]} || | qt| | D]\} } || | qq|dS) aSAsserts that total ordering has been implemented correctly. For example, say you have a class A that compares only on its attribute x. Comparators other than ``__lt__`` are omitted for brevity:: class A(object): def __init__(self, x, y): self.x = x self.y = y def __hash__(self): return hash(self.x) def __lt__(self, other): try: return self.x < other.x except AttributeError: return NotImplemented assertTotallyOrdered will check that instances can be ordered correctly. For example:: self.assertTotallyOrdered( [None], # None should come before everything else. [1], # Integers sort earlier. [A(1, 'a')], [A(2, 'b')], # 2 is after 1. [A(3, 'c'), A(3, 'd')], # The second argument is irrelevant. [A(4, 'z')], ['foo']) # Strings sort last. Args: *groups: A list of groups of elements. Each group of elements is a list of objects that are equal. The elements in each group must be less than the elements in the group after it. For example, these groups are totally ordered: ``[None]``, ``[1]``, ``[2, 2]``, ``[3]``. **kwargs: optional msg keyword argument can be passed. c s||kd||f||kd||f||||kd||f||||kd||f||||kd||f||||kd||fdS)z$Ensures small is ordered before big.z%r unexpectedly equals %r%r unexpectedly less than %rz(%r unexpectedly less than or equal to %r%r unexpectedly greater than %rz+%r unexpectedly greater than or equal to %rN) assertFalserr: assertLessassertLessEqual assertGreaterassertGreaterEqual)smallbigrrXrr! CheckOrdersF       z1TestCase.assertTotallyOrdered..CheckOrderc s4||||kd||ft|tjrxt|tjrxt|t|dt||t||f||kd||f||kd||f||||||kd||f||kd||f||||dS)zEnsures that a and b are equal.z%r unexpectedly unequals %rz5hash %d of %r unexpectedly not equal to hash %d of %rrrN) rOrrrrHashablehashrrarrrr! CheckEqual9sb        z1TestCase.assertTotallyOrdered..CheckEqualrNrorH)r6 itertoolsproductr*r) rXgroupsrrrelementsrvrrgrouprrrrr!assertTotallyOrdereds(&  zTestCase.assertTotallyOrderedcs||t||d||t||ddd}||kr@dS|t|}|t|}g}g}g} tjjfdd} d| || ||rd |nd fg} |D]@\} } | |vr|| | fq| || kr| | | || fq|D]\}}||vr|||fq|r6| d d fd d |D| r^| dd fdd | D|r| dd fdd |D| d | dS)aRaises AssertionError if a and b are not equal dictionaries. Args: a: A dict, the expected value. b: A dict, the actual value. msg: An optional str, the associated message. Raises: AssertionError: if the dictionaries are not equal. z"First argument is not a dictionaryz#Second argument is not a dictionarycSs&z t|WSty |YS0dSr)sortedr)Z list_of_itemsrrr!Sorteds  z(TestCase.assertDictEqual..SortedNcs2tfdd|D}dddd|DS)zDeterministic repr for dict.c3s"|]\}}||fVqdSrrr"kvrrr! r#z9TestCase.assertDictEqual..Repr..z{%s}z, css|]}d|VqdS)z%s: %sNr)r"pairrrr!rr#)ritemsrA)Zdiktentriesrrr!Reprsz&TestCase.assertDictEqual..Reprz %s != %s%sz (%s)r3z#Unexpected, but present entries: %sc3s&|]\}}d||fVqdSz%s: %s Nrrrrr!rsz+TestCase.assertDictEqual..zrepr() of differing entries: %sc3s.|]&\}}}d|||fVqdS)z %s: %s != %s Nr)r"ra_valueb_valuerrr!rszMissing entries: %sc3s&|]\}}d||fVqdSrrrrrr!rr#r) assertIsInstancer(rr*rr$rrrrAr)rXrrrrZa_itemsZb_itemsr-rZ differentrrHZa_keyrZb_keyrrrr!assertDictEqualps\   $   zTestCase.assertDictEqualcCst|}t|}||j|j|||j|j|||j|j|||j|j||t|j dt|j d|| tj |j ddtj |j dd|dS)z?Asserts that urls are equal, ignoring ordering of query params.;T)keep_blank_valuesN) rurlparserOschemenetlocr@fragmentrparamssplitrparse_qsquery)rXrrrZparsed_aZparsed_brrr!assertUrlEquals  zTestCase.assertUrlEqualrrcCsdg}t||||||jdurJ|jd}t||krJ|d|ddg}|r`|d||dS)aAsserts that two values contain the same structural content. The two arguments should be data trees consisting of trees of dicts and lists. They will be deeply compared by walking into the contents of dicts and lists; other items will be compared using the == operator. If the two structures differ in content, the failure message will indicate the location within the structures where the first difference is found. This may be helpful when comparing large structures. Mixed Sequence and Set types are supported. Mixed Mapping types are supported, but the order of the keys will not be considered in the comparison. Args: a: The first structure to compare. b: The second structure to compare. aname: Variable name to use for the first structure in assertion messages. bname: Variable name to use for the second structure. msg: Additional text to include in the failure message. NPrrHrz; )_walk_structure_for_problemsmaxDiffrSrrA)rXrranamebnamerproblemsZmax_problems_to_showrrr!assertSameStructures   zTestCase.assertSameStructurec Cszt|}Wn<tyJ}z$t||d||fWYd}~n d}~00zt|}Wn<ty}z$t||d||fWYd}~n d}~00|j||dd|ddS)aAsserts that the JSON objects defined in two strings are equal. A summary of the differences will be included in the failure message using assertSameStructure. Args: first: A string containing JSON to decode and compare to second. second: A string containing JSON to decode and compare to first. msg: Additional text to include in the failure message. z(could not decode first JSON value %s: %sNz)could not decode second JSON value %s: %sr5r6)rrr)jsonloadsr8rr)rXr5r6rZfirst_structuredrzZsecond_structuredrrr!assertJsonEquals"   zTestCase.assertJsonEqualcsVztt|||WStyBt|dd}tt||Yn0tt|||S)Nrr:)rr_getAssertEqualityFuncAttributeErrorrrk)rXr5r6 test_methodrrr!r s   zTestCase._getAssertEqualityFunccstt||||S)z=Fail immediately with the given message, optionally prefixed.)rrrr)rXrrrrr!rsz TestCase.fail)NN)NNrprqrrN)N)N)N)N)N)N)N)N)NNN)N)N)N)N)N)N)N)rJNTN)NTN)N)N)N)N)N)N)N)rrN)N)NN)Ar-r.r/rr)r0rr longMessagerrrkrrrrrrrrrrrr r rr7boolrrrrrrrrrr rrrr r.r9r;rIrVrXobjectrdtypingoverloadrgrmrwr{rrrrrrrr __classcell__rrrr!r@s    7 7        *    -  8   ? . *    (   z M  %  rcCs4d}}g}g}z||}||}||krT|||d7}|||kr|d7}q           r+cCst|tot|tSr)rr7rrrr!_are_both_of_integer_typeQsrcCs0t|tjo.t|tjo.t|t o.t|t Sr)rrrr'rrrr!_are_both_of_sequence_typeVs rcCst|tjot|tjSr)rrSetrrrr!_are_both_of_set_type]srcCst|tjot|tjSr)rrrrrrr!_are_both_of_mapping_typebsrc Cs6t|t|krZt||sZt||sZt||sZt||sZ|d|t||t|fdSt|tjr|D] }||vrj|d|||fqj|D] }||vr|d|||fqn|t|tj rL|D]P}||vrt ||||d||fd||f|q|d|||||fq|D]*}||vr|d|||||fqnt|tj rt|t st t|t|}t|D].}t ||||d||fd||f|qt|t|D] }|d |||||fqt|t|D] }|d |||||fqn ||kr2|d ||||fdS) z4The recursive comparison behind assertSameStructure.z%s is a %r but %s is a %rNz%s has %r but %s does notz%s lacks %r but %s has itz%s[%r]z0%s has [%r] with value %r but it's missing in %sz)%s lacks [%r] but %s has it with value %rz%s[%d]z)%s has [%i] with value %r but %s does notz)%s lacks [%i] but %s has it with value %rz%s is %r but %s is %r)rrrrrrrrrrrrr'minrSr|)rrrrZ problem_listrZminlenrrrr!rhsx          rcCsXt|tr|Stjdkr"d|Sd}|D]}|d|ddd7}q*|ddSdS) zReturns an escaped string that can be used as a shell command. Args: command: List or string representing the command to run. Returns: A string suitable for use as a shell command. nt r3'z'"'"'z' Nro)rrr4rrAr)rRrUwordrrr!rNs   rNcCsZ|dur i}tjdkrd}t|t}tj||||tjtjd}|d}| }||fS)afRuns the given shell command and returns a tuple. Args: command: List or string representing the command to run. env: Dictionary of environment variable settings. If None, no environment variables will be set for the child process. This is to make tests more hermetic. NOTE: this behavior is different than the standard subprocess module. close_fds: Whether or not to close all open fd's in the child after forking. On Windows, this is ignored and close_fds is always False. Returns: Tuple of (exit status, text printed to stdout and stderr by the command). NrF)rTrSshellr^stdoutr) r4rrr subprocessPopenSTDOUTPIPE communicatewait)rRrSrTZ use_shellprocessoutputZ exit_statusrrr!rMs    rMcCsHt|ttfr8z|d}Wnty6t|}Yn0d|ddS)zQuotes a potentially multi-line string to make the start and end obvious. Args: s: A string. Returns: The quoted string. rbz8<----------- rz----------->8 )rrC bytearrayr=UnicodeDecodeErrorr)srrr!rPs  rPcCs&tjdtjtjrtjnddS)Nz5Running tests under Python {0[0]}.{0[1]}.{0[2]}: {1} z embedded.)r]r^r_rNr executablerrrr!print_python_versions rcOsttt||dS)aExecutes a set of Python unit tests. Usually this function is called without arguments, so the unittest.TestProgram instance will get created with the default settings, so it will run all test methods of all TestCase classes in the ``__main__`` module. Args: *args: Positional arguments passed through to ``unittest.TestProgram.__init__``. **kwargs: Keyword arguments passed through to ``unittest.TestProgram.__init__``. N)r _run_in_app run_testsrrrr!mainsrcCs,tj}|r(|jtjjkr dS|j}q dS)z#Returns True iff app.run is active.TF)r] _getframef_backf_coderrun__code__rrrr!_is_in_app_main s  rc Cs^trZttddrZztjtjddWn4tyX}ztjd|WYd}~n d}~00dS)zGHave faulthandler dump stacks on SIGTERM. Useful to diagnose timeouts.registerNT)chainz4faulthandler.register(SIGTERM) failed %r; ignoring. ) faulthandlerrrsignalSIGTERM Exceptionr]r^r_)rzrrr!#_register_sigterm_with_faulthandlersrc strttddi}dd}tD]}t|j||<q(tD]}|t|_q@z0ttj}WtD]}||t|_qbtjn$tD]}||t|_qtj0|n(tddfdd}t j |ddS) aExecutes a set of Python unit tests, ensuring app.run. This is a private function, users should call absltest.main(). _run_in_app calculates argv to be the command-line arguments of this program (without the flags), sets the default of FLAGS.alsologtostderr to True, then it calls function(argv, args, kwargs), making sure that `function' will get called within app.run(). _run_in_app does this by checking whether it is called by app.run(), or by calling app.run() explicitly. The reason why app.run has to be ensured is to make sure that flags are parsed and stripped properly, and other initializations done by the app module are also carried out, no matter if absltest.run() is called from within or outside app.run(). If _run_in_app is called from within app.run(), then it will reparse sys.argv and pass the result without command-line flags into the argv argument of `function'. The reason why this parsing is needed is that __main__.main() calls absltest.main() without passing its argv. So the only way _run_in_app could get to know the argv without the flags is that it reparses sys.argv. _run_in_app changes the default of FLAGS.alsologtostderr to True so that the test program's stderr will contain all the log messages unless otherwise specified on the command-line. This overrides any explicit assignment to FLAGS.alsologtostderr by the test program prior to the call to _run_in_app() (e.g. in __main__.main). Please note that _run_in_app (and the function it calls) is allowed to make changes to kwargs. Args: function: absltest.run_tests or a similar function. It will be called as function(argv, args, kwargs) where argv is a list containing the elements of sys.argv without the command-line flags. args: Positional arguments passed through to unittest.TestProgram.__init__. kwargs: Keyword arguments passed through to unittest.TestProgram.__init__. alsologtostderrTcSsdSrr)rxrrr!r"Yr#z_run_in_app..cst|dSr)rargvrrrrr! main_functionnsz"_run_in_app..main_function)rN) rrrJ set_defaultrr]rrflushrr)rrrZstored_parse_methodsZ noop_parserrrrrr!r$s*(      rcCs|drt|dkr|drt||}t|s@t|rt|}t|jdko|jddko|j duo|j duo|j SdS)zBReturns True if an attribute is a method named like a test method.ZTestrHrrXNF) rrSisupperrinspect isfunctionismethodgetfullargspecrvarargsvarkw kwonlyargs) testCaseClassrattrrrrr!_is_suspicious_attributeus"  rcs(ttrtdfdd}|S)aSkip tests in the decorated TestCase, but not any of its subclasses. This decorator indicates that this class should skip all its tests, but not any of its subclasses. Useful for if you want to share testMethod or setUp implementations between a number of concrete testcase classes. Example usage, showing how you can share some common test methods between subclasses. In this example, only ``BaseTest`` will be marked as skipped, and not RealTest or SecondRealTest:: @absltest.skipThisClass("Shared functionality") class BaseTest(absltest.TestCase): def test_simple_functionality(self): self.assertEqual(self.system_under_test.method(), 1) class RealTest(BaseTest): def setUp(self): super().setUp() self.system_under_test = MakeSystem(argument) def test_specific_behavior(self): ... class SecondRealTest(BaseTest): def setUp(self): super().setUp() self.system_under_test = MakeSystem(other_arguments) def test_other_behavior(self): ... Args: reason: The reason we have a skip in place. For instance: 'shared test methods' or 'shared assertion methods'. Returns: Decorator function that will cause a class to be skipped. z#Got {!r}, expected reason as stringcsFttjstdjddtfdd}|_S)Nz+Decorating {!r}, expected TestCase subclassrcsF|urtr,j|g|Ri|St|j|i|SdSr)SkipTest__func__rr)rrr)r'shadowed_setupclasstest_case_classrr!replacement_setupclasss zBskipThisClass.._skip_class..replacement_setupclass) r]r$rrrN__dict__r6rr)rrr')rrr! _skip_classs z"skipThisClass.._skip_class)rrrrN)r'r rr r! skipThisClasss(  r cs6eZdZdZedZfddZfddZZ S) TestLoaderaA test loader which supports common test features. Supported features include: * Banning untested methods with test-like names: methods attached to this testCase with names starting with `Test` are ignored by the test runner, and often represent mistakenly-omitted test cases. This loader will raise a TypeError when attempting to load a TestCase with such methods. * Randomization of test case execution order (optional). zMethod '%s' is named like a test case but is not one. This is often a bug. If you want it to be a test method, name it with 'test' in lowercase. If not, rename the method to not begin with 'Test'.csFtt|j|i|t}|r6||_t|j|_n d|_d|_dSr)rr rkrP_randomize_ordering_seedrGrL_random)rXrkwdsrOrrr!rkszTestLoader.__init__cslt|D]}t||rttj|qtt||}|jdurht d|jt d|j|j ||S)zFValidates and returns a (possibly randomized) list of test case names.Nz$Randomizing test order with seed: %dzFTo reproduce this order, re-run with --test_randomize_ordering_seed=%d) r{rrr  _ERROR_MSGrgetTestCaseNamesr rinforshuffle)rXrrnamesrrr!rs    zTestLoader.getTestCaseNames) r-r.r/rtextwrapdedentrrkrrrrrr!r s  r c Cs|tjdrtjdStjdr:tjtjtjdStjdrxtjtjdtjtj t j dddSdS)NZXML_OUTPUT_FILEZRUNNING_UNDER_TEST_DAEMONztest_detail.xmlZTEST_XMLOUTPUTDIRrz.xml) r4r5r6r@rArr?r:splitextbasenamer]rrrrr!get_default_xml_output_filenames     rcCsVtjd}|dus|sdSt|}tjdddkrFdd|D}||dd<dS)aoImplements the bazel test filtering protocol. The following environment variable is used in this method: TESTBRIDGE_TEST_ONLY: string, if set, is forwarded to the unittest framework to use as a test filter. Its value is split with shlex, then: 1. On Python 3.6 and before, split values are passed as positional arguments on argv. 2. On Python 3.7+, split values are passed to unittest's `-k` flag. Tests are matched by glob patterns or substring. See https://docs.python.org/3/library/unittest.html#cmdoption-unittest-k Args: argv: the argv to mutate in-place. ZTESTBRIDGE_TEST_ONLYNr)rcSsg|] }d|qS)z-k=r)r" test_filterrrr!r$ r#z$_setup_filtering..rH)r4r5r6shlexrr]r)rrfiltersrrr!_setup_filtering s   rcCs2|dur dStjddkr dSdg|dd<dS)a)Implements the bazel test fail fast protocol. The following environment variable is used in this method: TESTBRIDGE_TEST_RUNNER_FAIL_FAST=<1|0> If set to 1, --failfast is passed to the unittest framework to return upon first failure. Args: argv: the argv to mutate in-place. NZ TESTBRIDGE_TEST_RUNNER_FAIL_FAST1z --failfastrHr=rrrr!_setup_test_runner_fail_fast s r cs dtjvr|z>ttjdd}|dWdn1s<0YWn2tyztjdtjdtdYn0|pt}dtjvr|St tjd}t tjdd ks|krtjd |ftd|j t t |fd d }||_ |S) aImplements the bazel sharding protocol. The following environment variables are used in this method: TEST_SHARD_STATUS_FILE: string, if set, points to a file. We write a blank file to tell the test runner that this test implements the test sharding protocol. TEST_TOTAL_SHARDS: int, if set, sharding is requested. TEST_SHARD_INDEX: int, must be set if TEST_TOTAL_SHARDS is set. Specifies the shard index for this instance of the test process. Must satisfy: 0 <= TEST_SHARD_INDEX < TEST_TOTAL_SHARDS. Args: custom_loader: A TestLoader to be made sharded. Returns: The test loader for shard-filtering or the standard test loader, depending on the sharding environment variables. ZTEST_SHARD_STATUS_FILErpr3Nz3Error opening TEST_SHARD_STATUS_FILE (%s). Exiting.rHZTEST_TOTAL_SHARDSZTEST_SHARD_INDEXrz/ERROR: Bad sharding values. index=%d, total=%d csFg|}t|D]}t}|kr|qfdd|DS)Ncsg|]}|vr|qSrr)r"xZfiltered_namesrr!r$x r#zD_setup_sharding..getShardedTestCaseNames..)rnextr)rZ ordered_namestestcasebucketZbucket_iteratorZdelegate_get_names shard_indexr"r!getShardedTestCaseNamesn s  z0_setup_sharding..getShardedTestCaseNames)r4r5rr_IOErrorr]r^exitr r7rrcycler|)Z custom_loaderr Z base_loaderZ total_shardsr(rr&r!_setup_sharding7 s0 ,     r,c CsT|d|}t|t|t|dd|d<tjs>tt_tj}d}|rxtj |}|rtj |szt |Wn2t y}z|jtjkrWYd}~n d}~00t|dWdn1s0Y|ddurt|ddstjd|d||d<|ddur*||d<t}|d|t|ddd}t|dd d} |r| r| d |n|ddurtj|d<tjr|d} t| trt| tjst| tjrd | _tj t j!s(zt t j!Wn6t y&}z|jtjkrWYd}~n d}~00||d<zt"j#|i|} | j$W|rzFt|d} | |%Wdn1s0YW|&S|&0SzFt|d} | |%Wdn1s0YW|&n |&0nZ|rNzFt|d} | |%Wdn1s.0YW|&n |&00dS) zCSame as run_tests, except it returns the result instead of exiting.r testLoaderNrp testRunnerset_default_xml_streamzkWARNING: XML_OUTPUT_FILE or --xml_output_file setting overrides testRunner=%r setting (possibly from --pdb)r Zset_testsuites_propertyrFT)'r0rr r,r6rJrRrr4r@risdirrOSErrorerrnoEEXISTrfrr]r^r_rStringIOr/rrTextTestRunnerpdb_post_mortemrrr]Zrun_for_debuggingr?r:r$ TestProgramrgetvaluer) rrrZxml_test_runner_classrRZ xml_bufferZxml_output_dirrzZrandomize_ordering_seedsetterrunnerZ test_programr rrr!_run_and_get_tests_result s             0 0 0r;cCs$t|||tj}t| dS)aExecutes a set of Python unit tests. Most users should call absltest.main() instead of run_tests. Please note that run_tests should be called from app.run. Calling absltest.main() would ensure that. Please note that run_tests is allowed to make changes to kwargs. Args: argv: sys.argv with the command-line flags removed from the front, i.e. the argv with which :func:`app.run()` has called ``__main__.main``. It is passed to ``unittest.TestProgram.__init__(argv=)``, which does its own flag parsing. It is ignored if kwargs contains an argv entry. args: Positional arguments passed through to ``unittest.TestProgram.__init__``. kwargs: Keyword arguments passed through to ``unittest.TestProgram.__init__``. N)r;r ZTextAndXMLTestRunnerr]r*rY)rrrrrrr!r s rcCsBtj|r0zt|Wq>ty,Yq>0ntj|dddS)NT) ignore_errors)r4r@isfileunlinkr1shutilrmtree)r@rrr!r s   rcCs|tjd}|dS)NrHr)rr4sep)r@partsrrr!r sr)NT)N)tr collectionsrrr2enumr2getpassrrrrr4rGrDrr?rrrr]rBrr$rurllibrr ImportErrorabslrrr absl.testingrr rr r r r rrrrrrrrrrrrrr TYPE_CHECKINGTypeVarrZ unittest.casecase_OutcomeZ _OutcomeTypeskipskipIf skipUnlessrr%rJrrCr' __unittestr(Enumr)r;r>rErP DEFINE_stringr<r?DEFINE_integerrarrfrrgrsrrr+rrrrrrNrMrPrrrrrrr r rrr r,r;rrrrrrr!s           T   2  Q"!h2; "   Q K*  Hh