proxygen: gtest_filter_unittest.GTestFilterUnitTest Class Reference

def gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests	(	self,
		tests_to_run
	)

Adjust tests_to_run in case value parameterized tests are disabled.

Definition at line 251 of file gtest_filter_unittest.py.

References bm.list.

Referenced by gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

   def AdjustForParameterizedTests(self, tests_to_run):
     """Adjust tests_to_run in case value parameterized tests are disabled."""
 
     global param_tests_present
     if not param_tests_present:
       return list(set(tests_to_run) - set(PARAM_TESTS))
     else:
       return tests_to_run
 

def gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests	(	self,
		tests_to_run
	)

Adjust tests_to_run in case value parameterized tests are disabled.

Definition at line 251 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), and bm.list.

   def AdjustForParameterizedTests(self, tests_to_run):
     """Adjust tests_to_run in case value parameterized tests are disabled."""
 
     global param_tests_present
     if not param_tests_present:
       return list(set(tests_to_run) - set(PARAM_TESTS))
     else:
       return tests_to_run
 

def gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests	(	self,
		tests_to_run
	)

Adjust tests_to_run in case value parameterized tests are disabled.

Definition at line 251 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), and bm.list.

   def AdjustForParameterizedTests(self, tests_to_run):
     """Adjust tests_to_run in case value parameterized tests are disabled."""
 
     global param_tests_present
     if not param_tests_present:
       return list(set(tests_to_run) - set(PARAM_TESTS))
     else:
       return tests_to_run
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid	(	self,
		set_var,
		list_of_sets
	)

Asserts that list_of_sets is a valid partition of set_var.

Definition at line 242 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid().

   def AssertPartitionIsValid(self, set_var, list_of_sets):
     """Asserts that list_of_sets is a valid partition of set_var."""
 
     full_partition = []
     for slice_var in list_of_sets:
       full_partition.extend(slice_var)
     self.assertEqual(len(set_var), len(full_partition))
     self.assertEqual(set(set_var), set(full_partition))
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid	(	self,
		set_var,
		list_of_sets
	)

Asserts that list_of_sets is a valid partition of set_var.

Definition at line 242 of file gtest_filter_unittest.py.

Referenced by gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

   def AssertPartitionIsValid(self, set_var, list_of_sets):
     """Asserts that list_of_sets is a valid partition of set_var."""
 
     full_partition = []
     for slice_var in list_of_sets:
       full_partition.extend(slice_var)
     self.assertEqual(len(set_var), len(full_partition))
     self.assertEqual(set(set_var), set(full_partition))
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid	(	self,
		set_var,
		list_of_sets
	)

Asserts that list_of_sets is a valid partition of set_var.

Definition at line 242 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid().

   def AssertPartitionIsValid(self, set_var, list_of_sets):
     """Asserts that list_of_sets is a valid partition of set_var."""
 
     full_partition = []
     for slice_var in list_of_sets:
       full_partition.extend(slice_var)
     self.assertEqual(len(set_var), len(full_partition))
     self.assertEqual(set(set_var), set(full_partition))
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual	(	self,
		lhs,
		rhs
	)

Asserts that two sets are equal.

Definition at line 233 of file gtest_filter_unittest.py.

Referenced by gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar().

   def AssertSetEqual(self, lhs, rhs):
     """Asserts that two sets are equal."""
 
     for elem in lhs:
       self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
 
     for elem in rhs:
       self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual	(	self,
		lhs,
		rhs
	)

Asserts that two sets are equal.

Definition at line 233 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual().

   def AssertSetEqual(self, lhs, rhs):
     """Asserts that two sets are equal."""
 
     for elem in lhs:
       self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
 
     for elem in rhs:
       self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
 

def gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual	(	self,
		lhs,
		rhs
	)

Asserts that two sets are equal.

Definition at line 233 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual().

   def AssertSetEqual(self, lhs, rhs):
     """Asserts that two sets are equal."""
 
     for elem in lhs:
       self.assert_(elem in rhs, '%s in %s' % (elem, rhs))
 
     for elem in rhs:
       self.assert_(elem in lhs, '%s in %s' % (elem, lhs))
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for a given filter.

Definition at line 260 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.SetEnvVar().

   def RunAndVerify(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for a given filter."""
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # First, tests using the environment variable.
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       tests_run = RunAndExtractTestList()[0]
       SetEnvVar(FILTER_ENV_VAR, None)
       self.AssertSetEqual(tests_run, tests_to_run)
     # pylint: enable-msg=C6403
 
     # Next, tests using the command line flag.
 
     if gtest_filter is None:
       args = []
     else:
       args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for a given filter.

Definition at line 260 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.SetEnvVar().

   def RunAndVerify(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for a given filter."""
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # First, tests using the environment variable.
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       tests_run = RunAndExtractTestList()[0]
       SetEnvVar(FILTER_ENV_VAR, None)
       self.AssertSetEqual(tests_run, tests_to_run)
     # pylint: enable-msg=C6403
 
     # Next, tests using the command line flag.
 
     if gtest_filter is None:
       args = []
     else:
       args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for a given filter.

Definition at line 260 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.SetEnvVar().

   def RunAndVerify(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for a given filter."""
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # First, tests using the environment variable.
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       tests_run = RunAndExtractTestList()[0]
       SetEnvVar(FILTER_ENV_VAR, None)
       self.AssertSetEqual(tests_run, tests_to_run)
     # pylint: enable-msg=C6403
 
     # Next, tests using the command line flag.
 
     if gtest_filter is None:
       args = []
     else:
       args = ['--%s=%s' % (FILTER_FLAG, gtest_filter)]
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for the given filter.

Runs gtest_filter_unittest_ with the given filter, and enables
disabled tests. Verifies that the right set of tests were run.

Args:
  gtest_filter: A filter to apply to the tests.
  tests_to_run: A set of tests expected to run.

Definition at line 328 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled().

   def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for the given filter.
 
     Runs gtest_filter_unittest_ with the given filter, and enables
     disabled tests. Verifies that the right set of tests were run.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       tests_to_run: A set of tests expected to run.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Construct the command line.
     args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
     if gtest_filter is not None:
       args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for the given filter.

Runs gtest_filter_unittest_ with the given filter, and enables
disabled tests. Verifies that the right set of tests were run.

Args:
  gtest_filter: A filter to apply to the tests.
  tests_to_run: A set of tests expected to run.

Definition at line 328 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), and gtest_filter_unittest.RunAndExtractTestList().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), gtest_filter_unittest.GTestFilterUnitTest.testBadFilter(), gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase(), gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests(), gtest_filter_unittest.GTestFilterUnitTest.testFullName(), and gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters().

   def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for the given filter.
 
     Runs gtest_filter_unittest_ with the given filter, and enables
     disabled tests. Verifies that the right set of tests were run.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       tests_to_run: A set of tests expected to run.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Construct the command line.
     args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
     if gtest_filter is not None:
       args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled	(	self,
		gtest_filter,
		tests_to_run
	)

Checks that the binary runs correct set of tests for the given filter.

Runs gtest_filter_unittest_ with the given filter, and enables
disabled tests. Verifies that the right set of tests were run.

Args:
  gtest_filter: A filter to apply to the tests.
  tests_to_run: A set of tests expected to run.

Definition at line 328 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled().

   def RunAndVerifyAllowingDisabled(self, gtest_filter, tests_to_run):
     """Checks that the binary runs correct set of tests for the given filter.
 
     Runs gtest_filter_unittest_ with the given filter, and enables
     disabled tests. Verifies that the right set of tests were run.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       tests_to_run: A set of tests expected to run.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Construct the command line.
     args = ['--%s' % ALSO_RUN_DISABED_TESTS_FLAG]
     if gtest_filter is not None:
       args.append('--%s=%s' % (FILTER_FLAG, gtest_filter))
 
     tests_run = RunAndExtractTestList(args)[0]
     self.AssertSetEqual(tests_run, tests_to_run)
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding	(	self,
		gtest_filter,
		total_shards,
		tests_to_run,
		args = `None`,
		check_exit_0 = `False`
	)

Checks that binary runs correct tests for the given filter and shard.

Runs all shards of gtest_filter_unittest_ with the given filter, and
verifies that the right set of tests were run. The union of tests run
on each shard should be identical to tests_to_run, without duplicates.

Args:
  gtest_filter: A filter to apply to the tests.
  total_shards: A total number of shards to split test run into.
  tests_to_run: A set of tests expected to run.
  args   :      Arguments to pass to the to the test binary.
  check_exit_0: When set to a true value, make sure that all shards
            return 0.

Definition at line 291 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid(), folly::gen.range(), gtest_filter_unittest.RunWithSharding(), and gtest_filter_unittest.SetEnvVar().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards(), gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter(), gtest_filter_unittest.GTestFilterUnitTest.testFullName(), gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests(), and gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters().

                                args=None, check_exit_0=False):
     """Checks that binary runs correct tests for the given filter and shard.
 
     Runs all shards of gtest_filter_unittest_ with the given filter, and
     verifies that the right set of tests were run. The union of tests run
     on each shard should be identical to tests_to_run, without duplicates.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       total_shards: A total number of shards to split test run into.
       tests_to_run: A set of tests expected to run.
       args   :      Arguments to pass to the to the test binary.
       check_exit_0: When set to a true value, make sure that all shards
                     return 0.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       partition = []
       for i in range(0, total_shards):
         (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
         if check_exit_0:
           self.assertEqual(0, exit_code)
         partition.append(tests_run)
 
       self.AssertPartitionIsValid(tests_to_run, partition)
       SetEnvVar(FILTER_ENV_VAR, None)
     # pylint: enable-msg=C6403
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding	(	self,
		gtest_filter,
		total_shards,
		tests_to_run,
		args = `None`,
		check_exit_0 = `False`
	)

Checks that binary runs correct tests for the given filter and shard.

Runs all shards of gtest_filter_unittest_ with the given filter, and
verifies that the right set of tests were run. The union of tests run
on each shard should be identical to tests_to_run, without duplicates.

Args:
  gtest_filter: A filter to apply to the tests.
  total_shards: A total number of shards to split test run into.
  tests_to_run: A set of tests expected to run.
  args   :      Arguments to pass to the to the test binary.
  check_exit_0: When set to a true value, make sure that all shards
            return 0.

Definition at line 291 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid(), folly::gen.range(), gtest_filter_unittest.RunWithSharding(), and gtest_filter_unittest.SetEnvVar().

                                args=None, check_exit_0=False):
     """Checks that binary runs correct tests for the given filter and shard.
 
     Runs all shards of gtest_filter_unittest_ with the given filter, and
     verifies that the right set of tests were run. The union of tests run
     on each shard should be identical to tests_to_run, without duplicates.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       total_shards: A total number of shards to split test run into.
       tests_to_run: A set of tests expected to run.
       args   :      Arguments to pass to the to the test binary.
       check_exit_0: When set to a true value, make sure that all shards
                     return 0.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       partition = []
       for i in range(0, total_shards):
         (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
         if check_exit_0:
           self.assertEqual(0, exit_code)
         partition.append(tests_run)
 
       self.AssertPartitionIsValid(tests_to_run, partition)
       SetEnvVar(FILTER_ENV_VAR, None)
     # pylint: enable-msg=C6403
 

def gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding	(	self,
		gtest_filter,
		total_shards,
		tests_to_run,
		args = `None`,
		check_exit_0 = `False`
	)

Checks that binary runs correct tests for the given filter and shard.

Runs all shards of gtest_filter_unittest_ with the given filter, and
verifies that the right set of tests were run. The union of tests run
on each shard should be identical to tests_to_run, without duplicates.

Args:
  gtest_filter: A filter to apply to the tests.
  total_shards: A total number of shards to split test run into.
  tests_to_run: A set of tests expected to run.
  args   :      Arguments to pass to the to the test binary.
  check_exit_0: When set to a true value, make sure that all shards
            return 0.

Definition at line 291 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AdjustForParameterizedTests(), gtest_filter_unittest.GTestFilterUnitTest.AssertPartitionIsValid(), folly::gen.range(), gtest_filter_unittest.RunWithSharding(), and gtest_filter_unittest.SetEnvVar().

                                args=None, check_exit_0=False):
     """Checks that binary runs correct tests for the given filter and shard.
 
     Runs all shards of gtest_filter_unittest_ with the given filter, and
     verifies that the right set of tests were run. The union of tests run
     on each shard should be identical to tests_to_run, without duplicates.
 
     Args:
       gtest_filter: A filter to apply to the tests.
       total_shards: A total number of shards to split test run into.
       tests_to_run: A set of tests expected to run.
       args   :      Arguments to pass to the to the test binary.
       check_exit_0: When set to a true value, make sure that all shards
                     return 0.
     """
 
     tests_to_run = self.AdjustForParameterizedTests(tests_to_run)
 
     # Windows removes empty variables from the environment when passing it
     # to a new process.  This means it is impossible to pass an empty filter
     # into a process using the environment variable.  However, we can still
     # test the case when the variable is not supplied (i.e., gtest_filter is
     # None).
     # pylint: disable-msg=C6403
     if CAN_TEST_EMPTY_FILTER or gtest_filter != '':
       SetEnvVar(FILTER_ENV_VAR, gtest_filter)
       partition = []
       for i in range(0, total_shards):
         (tests_run, exit_code) = RunWithSharding(total_shards, i, args)
         if check_exit_0:
           self.assertEqual(0, exit_code)
         partition.append(tests_run)
 
       self.AssertPartitionIsValid(tests_to_run, partition)
       SetEnvVar(FILTER_ENV_VAR, None)
     # pylint: enable-msg=C6403
 

def gtest_filter_unittest.GTestFilterUnitTest.setUp ( self )

Sets up test case.

Determines whether value-parameterized tests are enabled in the binary and
sets the flags accordingly.

Definition at line 349 of file gtest_filter_unittest.py.

References gtest_filter_unittest.RunAndReturnOutput(), and gtest_filter_unittest.GTestFilterUnitTest.setUp().

   def setUp(self):
     """Sets up test case.
 
     Determines whether value-parameterized tests are enabled in the binary and
     sets the flags accordingly.
     """
 
     global param_tests_present
     if param_tests_present is None:
       param_tests_present = PARAM_TEST_REGEX.search(
           RunAndReturnOutput()) is not None
 

def gtest_filter_unittest.GTestFilterUnitTest.setUp ( self )

Sets up test case.

Determines whether value-parameterized tests are enabled in the binary and
sets the flags accordingly.

Definition at line 349 of file gtest_filter_unittest.py.

References gtest_filter_unittest.RunAndReturnOutput().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.setUp().

   def setUp(self):
     """Sets up test case.
 
     Determines whether value-parameterized tests are enabled in the binary and
     sets the flags accordingly.
     """
 
     global param_tests_present
     if param_tests_present is None:
       param_tests_present = PARAM_TEST_REGEX.search(
           RunAndReturnOutput()) is not None
 

def gtest_filter_unittest.GTestFilterUnitTest.setUp ( self )

Sets up test case.

Determines whether value-parameterized tests are enabled in the binary and
sets the flags accordingly.

Definition at line 349 of file gtest_filter_unittest.py.

References gtest_filter_unittest.RunAndReturnOutput(), and gtest_filter_unittest.GTestFilterUnitTest.setUp().

   def setUp(self):
     """Sets up test case.
 
     Determines whether value-parameterized tests are enabled in the binary and
     sets the flags accordingly.
     """
 
     global param_tests_present
     if param_tests_present is None:
       param_tests_present = PARAM_TEST_REGEX.search(
           RunAndReturnOutput()) is not None
 

def gtest_filter_unittest.GTestFilterUnitTest.testBadFilter ( self )

Tests a filter that matches nothing.

Definition at line 382 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testBadFilter().

   def testBadFilter(self):
     """Tests a filter that matches nothing."""
 
     self.RunAndVerify('BadFilter', [])
     self.RunAndVerifyAllowingDisabled('BadFilter', [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testBadFilter ( self )

Tests a filter that matches nothing.

Definition at line 382 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testBadFilter().

   def testBadFilter(self):
     """Tests a filter that matches nothing."""
 
     self.RunAndVerify('BadFilter', [])
     self.RunAndVerifyAllowingDisabled('BadFilter', [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testBadFilter ( self )

Tests a filter that matches nothing.

Definition at line 382 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testBadFilter().

   def testBadFilter(self):
     """Tests a filter that matches nothing."""
 
     self.RunAndVerify('BadFilter', [])
     self.RunAndVerifyAllowingDisabled('BadFilter', [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior ( self )

Tests the behavior of not specifying the filter.

Definition at line 361 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior().

   def testDefaultBehavior(self):
     """Tests the behavior of not specifying the filter."""
 
     self.RunAndVerify(None, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior ( self )

Tests the behavior of not specifying the filter.

Definition at line 361 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior().

   def testDefaultBehavior(self):
     """Tests the behavior of not specifying the filter."""
 
     self.RunAndVerify(None, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior ( self )

Tests the behavior of not specifying the filter.

Definition at line 361 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehavior().

   def testDefaultBehavior(self):
     """Tests the behavior of not specifying the filter."""
 
     self.RunAndVerify(None, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards ( self )

Tests the behavior without the filter, with sharding enabled.

Definition at line 366 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards().

   def testDefaultBehaviorWithShards(self):
     """Tests the behavior without the filter, with sharding enabled."""
 
     self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards ( self )

Tests the behavior without the filter, with sharding enabled.

Definition at line 366 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards().

   def testDefaultBehaviorWithShards(self):
     """Tests the behavior without the filter, with sharding enabled."""
 
     self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards ( self )

Tests the behavior without the filter, with sharding enabled.

Definition at line 366 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testDefaultBehaviorWithShards().

   def testDefaultBehaviorWithShards(self):
     """Tests the behavior without the filter, with sharding enabled."""
 
     self.RunAndVerifyWithSharding(None, 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, 2, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) - 1, ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS), ACTIVE_TESTS)
     self.RunAndVerifyWithSharding(None, len(ACTIVE_TESTS) + 1, ACTIVE_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter ( self )

Tests an empty filter.

Definition at line 375 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter().

   def testEmptyFilter(self):
     """Tests an empty filter."""
 
     self.RunAndVerify('', [])
     self.RunAndVerifyWithSharding('', 1, [])
     self.RunAndVerifyWithSharding('', 2, [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter ( self )

Tests an empty filter.

Definition at line 375 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter().

   def testEmptyFilter(self):
     """Tests an empty filter."""
 
     self.RunAndVerify('', [])
     self.RunAndVerifyWithSharding('', 1, [])
     self.RunAndVerifyWithSharding('', 2, [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter ( self )

Tests an empty filter.

Definition at line 375 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testEmptyFilter().

   def testEmptyFilter(self):
     """Tests an empty filter."""
 
     self.RunAndVerify('', [])
     self.RunAndVerifyWithSharding('', 1, [])
     self.RunAndVerifyWithSharding('', 2, [])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest ( self )

Tests filtering by test name.

Definition at line 414 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest().

   def testFilterByTest(self):
     """Tests filtering by test name."""
 
     self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest ( self )

Tests filtering by test name.

Definition at line 414 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest().

   def testFilterByTest(self):
     """Tests filtering by test name."""
 
     self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest ( self )

Tests filtering by test name.

Definition at line 414 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFilterByTest().

   def testFilterByTest(self):
     """Tests filtering by test name."""
 
     self.RunAndVerify('*.TestOne', ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase ( self )

Tests filtering by test case name.

Definition at line 404 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase().

   def testFilterByTestCase(self):
     """Tests filtering by test case name."""
 
     self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
 
     BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
     self.RunAndVerify('BazTest.*', BAZ_TESTS)
     self.RunAndVerifyAllowingDisabled('BazTest.*',
                                       BAZ_TESTS + ['BazTest.DISABLED_TestC'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase ( self )

Tests filtering by test case name.

Definition at line 404 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase().

   def testFilterByTestCase(self):
     """Tests filtering by test case name."""
 
     self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
 
     BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
     self.RunAndVerify('BazTest.*', BAZ_TESTS)
     self.RunAndVerifyAllowingDisabled('BazTest.*',
                                       BAZ_TESTS + ['BazTest.DISABLED_TestC'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase ( self )

Tests filtering by test case name.

Definition at line 404 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFilterByTestCase().

   def testFilterByTestCase(self):
     """Tests filtering by test case name."""
 
     self.RunAndVerify('FooTest.*', ['FooTest.Abc', 'FooTest.Xyz'])
 
     BAZ_TESTS = ['BazTest.TestOne', 'BazTest.TestA', 'BazTest.TestB']
     self.RunAndVerify('BazTest.*', BAZ_TESTS)
     self.RunAndVerifyAllowingDisabled('BazTest.*',
                                       BAZ_TESTS + ['BazTest.DISABLED_TestC'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests ( self )

Select only the disabled tests to run.

Definition at line 419 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests().

   def testFilterDisabledTests(self):
     """Select only the disabled tests to run."""
 
     self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
                                       ['DISABLED_FoobarTest.Test1'])
 
     self.RunAndVerify('*DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
 
     self.RunAndVerify('*.DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
         'BarTest.DISABLED_TestFour',
         'BarTest.DISABLED_TestFive',
         'BazTest.DISABLED_TestC',
         'DISABLED_FoobarTest.DISABLED_Test2',
         ])
 
     self.RunAndVerify('DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_*', [
         'DISABLED_FoobarTest.Test1',
         'DISABLED_FoobarTest.DISABLED_Test2',
         'DISABLED_FoobarbazTest.TestA',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests ( self )

Select only the disabled tests to run.

Definition at line 419 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests().

   def testFilterDisabledTests(self):
     """Select only the disabled tests to run."""
 
     self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
                                       ['DISABLED_FoobarTest.Test1'])
 
     self.RunAndVerify('*DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
 
     self.RunAndVerify('*.DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
         'BarTest.DISABLED_TestFour',
         'BarTest.DISABLED_TestFive',
         'BazTest.DISABLED_TestC',
         'DISABLED_FoobarTest.DISABLED_Test2',
         ])
 
     self.RunAndVerify('DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_*', [
         'DISABLED_FoobarTest.Test1',
         'DISABLED_FoobarTest.DISABLED_Test2',
         'DISABLED_FoobarbazTest.TestA',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests ( self )

Select only the disabled tests to run.

Definition at line 419 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterDisabledTests().

   def testFilterDisabledTests(self):
     """Select only the disabled tests to run."""
 
     self.RunAndVerify('DISABLED_FoobarTest.Test1', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_FoobarTest.Test1',
                                       ['DISABLED_FoobarTest.Test1'])
 
     self.RunAndVerify('*DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*DISABLED_*', DISABLED_TESTS)
 
     self.RunAndVerify('*.DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('*.DISABLED_*', [
         'BarTest.DISABLED_TestFour',
         'BarTest.DISABLED_TestFive',
         'BazTest.DISABLED_TestC',
         'DISABLED_FoobarTest.DISABLED_Test2',
         ])
 
     self.RunAndVerify('DISABLED_*', [])
     self.RunAndVerifyAllowingDisabled('DISABLED_*', [
         'DISABLED_FoobarTest.Test1',
         'DISABLED_FoobarTest.DISABLED_Test2',
         'DISABLED_FoobarbazTest.TestA',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot ( self )

Tests a filter that has no '.' in it.

Definition at line 461 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot().

   def testFilterWithoutDot(self):
     """Tests a filter that has no '.' in it."""
 
     self.RunAndVerify('*z*', [
         'FooTest.Xyz',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot ( self )

Tests a filter that has no '.' in it.

Definition at line 461 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot().

   def testFilterWithoutDot(self):
     """Tests a filter that has no '.' in it."""
 
     self.RunAndVerify('*z*', [
         'FooTest.Xyz',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot ( self )

Tests a filter that has no '.' in it.

Definition at line 461 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testFilterWithoutDot().

   def testFilterWithoutDot(self):
     """Tests a filter that has no '.' in it."""
 
     self.RunAndVerify('*z*', [
         'FooTest.Xyz',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar ( self )

Tests that the filter flag overrides the filtering env. variable.

Definition at line 566 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), gtest_filter_unittest.SetEnvVar(), and gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar().

   def testFlagOverridesEnvVar(self):
     """Tests that the filter flag overrides the filtering env. variable."""
 
     SetEnvVar(FILTER_ENV_VAR, 'Foo*')
     args = ['--%s=%s' % (FILTER_FLAG, '*One')]
     tests_run = RunAndExtractTestList(args)[0]
     SetEnvVar(FILTER_ENV_VAR, None)
 
     self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar ( self )

Tests that the filter flag overrides the filtering env. variable.

Definition at line 566 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), and gtest_filter_unittest.SetEnvVar().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar().

   def testFlagOverridesEnvVar(self):
     """Tests that the filter flag overrides the filtering env. variable."""
 
     SetEnvVar(FILTER_ENV_VAR, 'Foo*')
     args = ['--%s=%s' % (FILTER_FLAG, '*One')]
     tests_run = RunAndExtractTestList(args)[0]
     SetEnvVar(FILTER_ENV_VAR, None)
 
     self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar ( self )

Tests that the filter flag overrides the filtering env. variable.

Definition at line 566 of file gtest_filter_unittest.py.

References gtest_filter_unittest.GTestFilterUnitTest.AssertSetEqual(), gtest_filter_unittest.RunAndExtractTestList(), gtest_filter_unittest.SetEnvVar(), and gtest_filter_unittest.GTestFilterUnitTest.testFlagOverridesEnvVar().

   def testFlagOverridesEnvVar(self):
     """Tests that the filter flag overrides the filtering env. variable."""
 
     SetEnvVar(FILTER_ENV_VAR, 'Foo*')
     args = ['--%s=%s' % (FILTER_FLAG, '*One')]
     tests_run = RunAndExtractTestList(args)[0]
     SetEnvVar(FILTER_ENV_VAR, None)
 
     self.AssertSetEqual(tests_run, ['BarTest.TestOne', 'BazTest.TestOne'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFullName ( self )

Tests filtering by full name.

Definition at line 388 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testFullName().

   def testFullName(self):
     """Tests filtering by full name."""
 
     self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFullName ( self )

Tests filtering by full name.

Definition at line 388 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testFullName().

   def testFullName(self):
     """Tests filtering by full name."""
 
     self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testFullName ( self )

Tests filtering by full name.

Definition at line 388 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testFullName().

   def testFullName(self):
     """Tests filtering by full name."""
 
     self.RunAndVerify('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyAllowingDisabled('FooTest.Xyz', ['FooTest.Xyz'])
     self.RunAndVerifyWithSharding('FooTest.Xyz', 5, ['FooTest.Xyz'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters ( self )

Definition at line 514 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters().

   def testNegativeFilters(self):
     self.RunAndVerify('*-BazTest.TestOne', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestA',
         'BazTest.TestB',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('BarTest.*-BarTest.TestOne', [
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ])
 
     # Tests without leading '*'.
     self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     # Value parameterized tests.
     self.RunAndVerify('*/*', PARAM_TESTS)
 
     # Value parameterized tests filtering by the sequence name.
     self.RunAndVerify('SeqP/*', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestX/1',
         'SeqP/ParamTest.TestY/0',
         'SeqP/ParamTest.TestY/1',
         ])
 
     # Value parameterized tests filtering by the test name.
     self.RunAndVerify('*/0', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestY/0',
         'SeqQ/ParamTest.TestX/0',
         'SeqQ/ParamTest.TestY/0',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters ( self )

Definition at line 514 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters().

   def testNegativeFilters(self):
     self.RunAndVerify('*-BazTest.TestOne', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestA',
         'BazTest.TestB',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('BarTest.*-BarTest.TestOne', [
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ])
 
     # Tests without leading '*'.
     self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     # Value parameterized tests.
     self.RunAndVerify('*/*', PARAM_TESTS)
 
     # Value parameterized tests filtering by the sequence name.
     self.RunAndVerify('SeqP/*', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestX/1',
         'SeqP/ParamTest.TestY/0',
         'SeqP/ParamTest.TestY/1',
         ])
 
     # Value parameterized tests filtering by the test name.
     self.RunAndVerify('*/0', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestY/0',
         'SeqQ/ParamTest.TestX/0',
         'SeqQ/ParamTest.TestY/0',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters ( self )

Definition at line 514 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testNegativeFilters().

   def testNegativeFilters(self):
     self.RunAndVerify('*-BazTest.TestOne', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestA',
         'BazTest.TestB',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('*-FooTest.Abc:BazTest.*', [
         'FooTest.Xyz',
 
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     self.RunAndVerify('BarTest.*-BarTest.TestOne', [
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ])
 
     # Tests without leading '*'.
     self.RunAndVerify('-FooTest.Abc:FooTest.Xyz:BazTest.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
         ] + DEATH_TESTS + PARAM_TESTS)
 
     # Value parameterized tests.
     self.RunAndVerify('*/*', PARAM_TESTS)
 
     # Value parameterized tests filtering by the sequence name.
     self.RunAndVerify('SeqP/*', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestX/1',
         'SeqP/ParamTest.TestY/0',
         'SeqP/ParamTest.TestY/1',
         ])
 
     # Value parameterized tests filtering by the test name.
     self.RunAndVerify('*/0', [
         'SeqP/ParamTest.TestX/0',
         'SeqP/ParamTest.TestY/0',
         'SeqQ/ParamTest.TestX/0',
         'SeqQ/ParamTest.TestY/0',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests ( self )

Tests integration with death tests and sharding.

Definition at line 614 of file gtest_filter_unittest.py.

References gtest_test_utils.Main(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests().

     def testShardingWorksWithDeathTests(self):
       """Tests integration with death tests and sharding."""
 
       gtest_filter = 'HasDeathTest.*:SeqP/*'
       expected_tests = [
           'HasDeathTest.Test1',
           'HasDeathTest.Test2',
 
           'SeqP/ParamTest.TestX/0',
           'SeqP/ParamTest.TestX/1',
           'SeqP/ParamTest.TestY/0',
           'SeqP/ParamTest.TestY/1',
           ]
 
       for flag in ['--gtest_death_test_style=threadsafe',
                    '--gtest_death_test_style=fast']:
         self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
                                       check_exit_0=True, args=[flag])
         self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
                                       check_exit_0=True, args=[flag])
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests ( self )

Tests integration with death tests and sharding.

Definition at line 614 of file gtest_filter_unittest.py.

References gtest_test_utils.Main(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests().

     def testShardingWorksWithDeathTests(self):
       """Tests integration with death tests and sharding."""
 
       gtest_filter = 'HasDeathTest.*:SeqP/*'
       expected_tests = [
           'HasDeathTest.Test1',
           'HasDeathTest.Test2',
 
           'SeqP/ParamTest.TestX/0',
           'SeqP/ParamTest.TestX/1',
           'SeqP/ParamTest.TestY/0',
           'SeqP/ParamTest.TestY/1',
           ]
 
       for flag in ['--gtest_death_test_style=threadsafe',
                    '--gtest_death_test_style=fast']:
         self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
                                       check_exit_0=True, args=[flag])
         self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
                                       check_exit_0=True, args=[flag])
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests ( self )

Tests integration with death tests and sharding.

Definition at line 614 of file gtest_filter_unittest.py.

References gtest_test_utils.Main(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testShardingWorksWithDeathTests().

     def testShardingWorksWithDeathTests(self):
       """Tests integration with death tests and sharding."""
 
       gtest_filter = 'HasDeathTest.*:SeqP/*'
       expected_tests = [
           'HasDeathTest.Test1',
           'HasDeathTest.Test2',
 
           'SeqP/ParamTest.TestX/0',
           'SeqP/ParamTest.TestX/1',
           'SeqP/ParamTest.TestY/0',
           'SeqP/ParamTest.TestY/1',
           ]
 
       for flag in ['--gtest_death_test_style=threadsafe',
                    '--gtest_death_test_style=fast']:
         self.RunAndVerifyWithSharding(gtest_filter, 3, expected_tests,
                                       check_exit_0=True, args=[flag])
         self.RunAndVerifyWithSharding(gtest_filter, 5, expected_tests,
                                       check_exit_0=True, args=[flag])
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated ( self )

Tests that the shard file is created if specified in the environment.

Definition at line 576 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), and gtest_filter_unittest.InvokeWithModifiedEnv().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated().

   def testShardStatusFileIsCreated(self):
     """Tests that the shard file is created if specified in the environment."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
     finally:
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated ( self )

Tests that the shard file is created if specified in the environment.

Definition at line 576 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), gtest_filter_unittest.InvokeWithModifiedEnv(), and gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated().

   def testShardStatusFileIsCreated(self):
     """Tests that the shard file is created if specified in the environment."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
     finally:
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated ( self )

Tests that the shard file is created if specified in the environment.

Definition at line 576 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), gtest_filter_unittest.InvokeWithModifiedEnv(), and gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreated().

   def testShardStatusFileIsCreated(self):
     """Tests that the shard file is created if specified in the environment."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       InvokeWithModifiedEnv(extra_env, RunAndReturnOutput)
     finally:
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests ( self )

Tests that the shard file is created with the "list_tests" flag.

Definition at line 590 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), and gtest_filter_unittest.InvokeWithModifiedEnv().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests().

   def testShardStatusFileIsCreatedWithListTests(self):
     """Tests that the shard file is created with the "list_tests" flag."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file2')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       output = InvokeWithModifiedEnv(extra_env,
                                      RunAndReturnOutput,
                                      [LIST_TESTS_FLAG])
     finally:
       # This assertion ensures that Google Test enumerated the tests as
       # opposed to running them.
       self.assert_('[==========]' not in output,
                    'Unexpected output during test enumeration.\n'
                    'Please ensure that LIST_TESTS_FLAG is assigned the\n'
                    'correct flag value for listing Google Test tests.')
 
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests ( self )

Tests that the shard file is created with the "list_tests" flag.

Definition at line 590 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), gtest_filter_unittest.InvokeWithModifiedEnv(), and gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests().

   def testShardStatusFileIsCreatedWithListTests(self):
     """Tests that the shard file is created with the "list_tests" flag."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file2')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       output = InvokeWithModifiedEnv(extra_env,
                                      RunAndReturnOutput,
                                      [LIST_TESTS_FLAG])
     finally:
       # This assertion ensures that Google Test enumerated the tests as
       # opposed to running them.
       self.assert_('[==========]' not in output,
                    'Unexpected output during test enumeration.\n'
                    'Please ensure that LIST_TESTS_FLAG is assigned the\n'
                    'correct flag value for listing Google Test tests.')
 
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests ( self )

Tests that the shard file is created with the "list_tests" flag.

Definition at line 590 of file gtest_filter_unittest.py.

References gtest_test_utils.GetTempDir(), gtest_filter_unittest.InvokeWithModifiedEnv(), and gtest_filter_unittest.GTestFilterUnitTest.testShardStatusFileIsCreatedWithListTests().

   def testShardStatusFileIsCreatedWithListTests(self):
     """Tests that the shard file is created with the "list_tests" flag."""
 
     shard_status_file = os.path.join(gtest_test_utils.GetTempDir(),
                                      'shard_status_file2')
     self.assert_(not os.path.exists(shard_status_file))
 
     extra_env = {SHARD_STATUS_FILE_ENV_VAR: shard_status_file}
     try:
       output = InvokeWithModifiedEnv(extra_env,
                                      RunAndReturnOutput,
                                      [LIST_TESTS_FLAG])
     finally:
       # This assertion ensures that Google Test enumerated the tests as
       # opposed to running them.
       self.assert_('[==========]' not in output,
                    'Unexpected output during test enumeration.\n'
                    'Please ensure that LIST_TESTS_FLAG is assigned the\n'
                    'correct flag value for listing Google Test tests.')
 
       self.assert_(os.path.exists(shard_status_file))
       os.remove(shard_status_file)
 

def gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns ( self )

Tests filters that consist of three patterns.

Definition at line 485 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns().

   def testThreePatterns(self):
     """Tests filters that consist of three patterns."""
 
     self.RunAndVerify('*oo*:*A*:*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         ])
 
     # The 2nd pattern is empty.
     self.RunAndVerify('*oo*::*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         ])
 
     # The last 2 patterns are empty.
     self.RunAndVerify('*oo*::', [
         'FooTest.Abc',
         'FooTest.Xyz',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns ( self )

Tests filters that consist of three patterns.

Definition at line 485 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns().

   def testThreePatterns(self):
     """Tests filters that consist of three patterns."""
 
     self.RunAndVerify('*oo*:*A*:*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         ])
 
     # The 2nd pattern is empty.
     self.RunAndVerify('*oo*::*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         ])
 
     # The last 2 patterns are empty.
     self.RunAndVerify('*oo*::', [
         'FooTest.Abc',
         'FooTest.Xyz',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns ( self )

Tests filters that consist of three patterns.

Definition at line 485 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testThreePatterns().

   def testThreePatterns(self):
     """Tests filters that consist of three patterns."""
 
     self.RunAndVerify('*oo*:*A*:*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         ])
 
     # The 2nd pattern is empty.
     self.RunAndVerify('*oo*::*One', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BarTest.TestOne',
 
         'BazTest.TestOne',
         ])
 
     # The last 2 patterns are empty.
     self.RunAndVerify('*oo*::', [
         'FooTest.Abc',
         'FooTest.Xyz',
         ])
 

def gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns ( self )

Tests filters that consist of two patterns.

Definition at line 472 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns().

   def testTwoPatterns(self):
     """Tests filters that consist of two patterns."""
 
     self.RunAndVerify('Foo*.*:*A*', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BazTest.TestA',
         ])
 
     # An empty pattern + a non-empty one
     self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns ( self )

Tests filters that consist of two patterns.

Definition at line 472 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns().

   def testTwoPatterns(self):
     """Tests filters that consist of two patterns."""
 
     self.RunAndVerify('Foo*.*:*A*', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BazTest.TestA',
         ])
 
     # An empty pattern + a non-empty one
     self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns ( self )

Tests filters that consist of two patterns.

Definition at line 472 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testTwoPatterns().

   def testTwoPatterns(self):
     """Tests filters that consist of two patterns."""
 
     self.RunAndVerify('Foo*.*:*A*', [
         'FooTest.Abc',
         'FooTest.Xyz',
 
         'BazTest.TestA',
         ])
 
     # An empty pattern + a non-empty one
     self.RunAndVerify(':*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters ( self )

Tests filters that match everything.

Definition at line 395 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters().

   def testUniversalFilters(self):
     """Tests filters that match everything."""
 
     self.RunAndVerify('*', ACTIVE_TESTS)
     self.RunAndVerify('*.*', ACTIVE_TESTS)
     self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
     self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
     self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters ( self )

Tests filters that match everything.

Definition at line 395 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding(), and gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters().

   def testUniversalFilters(self):
     """Tests filters that match everything."""
 
     self.RunAndVerify('*', ACTIVE_TESTS)
     self.RunAndVerify('*.*', ACTIVE_TESTS)
     self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
     self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
     self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters ( self )

Tests filters that match everything.

Definition at line 395 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyAllowingDisabled(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerifyWithSharding().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testUniversalFilters().

   def testUniversalFilters(self):
     """Tests filters that match everything."""
 
     self.RunAndVerify('*', ACTIVE_TESTS)
     self.RunAndVerify('*.*', ACTIVE_TESTS)
     self.RunAndVerifyWithSharding('*.*', len(ACTIVE_TESTS) - 3, ACTIVE_TESTS)
     self.RunAndVerifyAllowingDisabled('*', ACTIVE_TESTS + DISABLED_TESTS)
     self.RunAndVerifyAllowingDisabled('*.*', ACTIVE_TESTS + DISABLED_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName ( self )

Tests using wildcard in the test case name.

Definition at line 444 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName().

   def testWildcardInTestCaseName(self):
     """Tests using wildcard in the test case name."""
 
     self.RunAndVerify('*a*.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName ( self )

Tests using wildcard in the test case name.

Definition at line 444 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName().

   def testWildcardInTestCaseName(self):
     """Tests using wildcard in the test case name."""
 
     self.RunAndVerify('*a*.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName ( self )

Tests using wildcard in the test case name.

Definition at line 444 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestCaseName().

   def testWildcardInTestCaseName(self):
     """Tests using wildcard in the test case name."""
 
     self.RunAndVerify('*a*.*', [
         'BarTest.TestOne',
         'BarTest.TestTwo',
         'BarTest.TestThree',
 
         'BazTest.TestOne',
         'BazTest.TestA',
         'BazTest.TestB', ] + DEATH_TESTS + PARAM_TESTS)
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName ( self )

Tests using wildcard in the test name.

Definition at line 456 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName().

   def testWildcardInTestName(self):
     """Tests using wildcard in the test name."""
 
     self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName ( self )

Tests using wildcard in the test name.

Definition at line 456 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify().

Referenced by gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName().

   def testWildcardInTestName(self):
     """Tests using wildcard in the test name."""
 
     self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

def gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName ( self )

Tests using wildcard in the test name.

Definition at line 456 of file gtest_filter_unittest.py.

References gtest_break_on_failure_unittest.GTestBreakOnFailureUnitTest.RunAndVerify(), gtest_filter_unittest.GTestFilterUnitTest.RunAndVerify(), and gtest_filter_unittest.GTestFilterUnitTest.testWildcardInTestName().

   def testWildcardInTestName(self):
     """Tests using wildcard in the test name."""
 
     self.RunAndVerify('*.*A*', ['FooTest.Abc', 'BazTest.TestA'])
 

Public Member Functions
def	AssertSetEqual (self, lhs, rhs)

def	AssertPartitionIsValid (self, set_var, list_of_sets)

def	AdjustForParameterizedTests (self, tests_to_run)

def	RunAndVerify (self, gtest_filter, tests_to_run)

def	RunAndVerifyWithSharding (self, gtest_filter, total_shards, tests_to_run, args=None, check_exit_0=False)

def	RunAndVerifyAllowingDisabled (self, gtest_filter, tests_to_run)

def	setUp (self)

def	testDefaultBehavior (self)

def	testDefaultBehaviorWithShards (self)

def	testEmptyFilter (self)

def	testBadFilter (self)

def	testFullName (self)

def	testUniversalFilters (self)

def	testFilterByTestCase (self)

def	testFilterByTest (self)

def	testFilterDisabledTests (self)

def	testWildcardInTestCaseName (self)

def	testWildcardInTestName (self)

def	testFilterWithoutDot (self)

def	testTwoPatterns (self)

def	testThreePatterns (self)

def	testNegativeFilters (self)

def	testFlagOverridesEnvVar (self)

def	testShardStatusFileIsCreated (self)

def	testShardStatusFileIsCreatedWithListTests (self)

def	testShardingWorksWithDeathTests (self)

def	AssertSetEqual (self, lhs, rhs)

def	AssertPartitionIsValid (self, set_var, list_of_sets)

def	AdjustForParameterizedTests (self, tests_to_run)

def	RunAndVerify (self, gtest_filter, tests_to_run)

def	RunAndVerifyWithSharding (self, gtest_filter, total_shards, tests_to_run, args=None, check_exit_0=False)

def	RunAndVerifyAllowingDisabled (self, gtest_filter, tests_to_run)

def	setUp (self)

def	testDefaultBehavior (self)

def	testDefaultBehaviorWithShards (self)

def	testEmptyFilter (self)

def	testBadFilter (self)

def	testFullName (self)

def	testUniversalFilters (self)

def	testFilterByTestCase (self)

def	testFilterByTest (self)

def	testFilterDisabledTests (self)

def	testWildcardInTestCaseName (self)

def	testWildcardInTestName (self)

def	testFilterWithoutDot (self)

def	testTwoPatterns (self)

def	testThreePatterns (self)

def	testNegativeFilters (self)

def	testFlagOverridesEnvVar (self)

def	testShardStatusFileIsCreated (self)

def	testShardStatusFileIsCreatedWithListTests (self)

def	testShardingWorksWithDeathTests (self)

def	AssertSetEqual (self, lhs, rhs)

def	AssertPartitionIsValid (self, set_var, list_of_sets)

def	AdjustForParameterizedTests (self, tests_to_run)

def	RunAndVerify (self, gtest_filter, tests_to_run)

def	RunAndVerifyWithSharding (self, gtest_filter, total_shards, tests_to_run, args=None, check_exit_0=False)

def	RunAndVerifyAllowingDisabled (self, gtest_filter, tests_to_run)

def	setUp (self)

def	testDefaultBehavior (self)

def	testDefaultBehaviorWithShards (self)

def	testEmptyFilter (self)

def	testBadFilter (self)

def	testFullName (self)

def	testUniversalFilters (self)

def	testFilterByTestCase (self)

def	testFilterByTest (self)

def	testFilterDisabledTests (self)

def	testWildcardInTestCaseName (self)

def	testWildcardInTestName (self)

def	testFilterWithoutDot (self)

def	testTwoPatterns (self)

def	testThreePatterns (self)

def	testNegativeFilters (self)

def	testFlagOverridesEnvVar (self)

def	testShardStatusFileIsCreated (self)

def	testShardStatusFileIsCreatedWithListTests (self)

def	testShardingWorksWithDeathTests (self)

Public Member Functions

Detailed Description

Member Function Documentation