googletest-shuffle-test.GTestShuffleUnitTest Class Reference

Inheritance diagram for googletest-shuffle-test.GTestShuffleUnitTest:

Public Member Functions
def	setUp (self)
def	testShufflePreservesNumberOfTests (self)
def	testShuffleChangesTestOrder (self)
def	testShuffleChangesTestCaseOrder (self)
def	testShuffleDoesNotRepeatTest (self)
def	testShuffleDoesNotCreateNewTest (self)
def	testShuffleIncludesAllTests (self)
def	testShuffleLeavesDeathTestsAtFront (self)
def	testShuffleDoesNotInterleaveTestCases (self)
def	testShuffleRestoresOrderAfterEachIteration (self)
def	testShuffleGeneratesNewOrderInEachIteration (self)
def	testShuffleShardedTestsPreservesPartition (self)

Detailed Description

Tests test shuffling.

Definition at line 167 of file googletest-shuffle-test.py.

Member Function Documentation

setUp()

def googletest-shuffle-test.GTestShuffleUnitTest.setUp

(

self

)

Definition at line 170 of file googletest-shuffle-test.py.

  def setUp(self):
    CalculateTestLists()
 

testShuffleChangesTestCaseOrder()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleChangesTestCaseOrder

(

self

)

Definition at line 187 of file googletest-shuffle-test.py.

  def testShuffleChangesTestCaseOrder(self):
    self.assert_(GetTestCases(SHUFFLED_ALL_TESTS) != GetTestCases(ALL_TESTS),
                 GetTestCases(SHUFFLED_ALL_TESTS))
    self.assert_(
        GetTestCases(SHUFFLED_ACTIVE_TESTS) != GetTestCases(ACTIVE_TESTS),
        GetTestCases(SHUFFLED_ACTIVE_TESTS))
    self.assert_(
        GetTestCases(SHUFFLED_FILTERED_TESTS) != GetTestCases(FILTERED_TESTS),
        GetTestCases(SHUFFLED_FILTERED_TESTS))
    self.assert_(
        GetTestCases(SHUFFLED_SHARDED_TESTS) != GetTestCases(SHARDED_TESTS),
        GetTestCases(SHUFFLED_SHARDED_TESTS))
 

testShuffleChangesTestOrder()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleChangesTestOrder

(

self

)

Definition at line 179 of file googletest-shuffle-test.py.

  def testShuffleChangesTestOrder(self):
    self.assert_(SHUFFLED_ALL_TESTS != ALL_TESTS, SHUFFLED_ALL_TESTS)
    self.assert_(SHUFFLED_ACTIVE_TESTS != ACTIVE_TESTS, SHUFFLED_ACTIVE_TESTS)
    self.assert_(SHUFFLED_FILTERED_TESTS != FILTERED_TESTS,
                 SHUFFLED_FILTERED_TESTS)
    self.assert_(SHUFFLED_SHARDED_TESTS != SHARDED_TESTS,
                 SHUFFLED_SHARDED_TESTS)
 

testShuffleDoesNotCreateNewTest()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleDoesNotCreateNewTest

(

self

)

Definition at line 214 of file googletest-shuffle-test.py.

  def testShuffleDoesNotCreateNewTest(self):
    for test in SHUFFLED_ALL_TESTS:
      self.assert_(test in ALL_TESTS, '%s is an invalid test' % (test,))
    for test in SHUFFLED_ACTIVE_TESTS:
      self.assert_(test in ACTIVE_TESTS, '%s is an invalid test' % (test,))
    for test in SHUFFLED_FILTERED_TESTS:
      self.assert_(test in FILTERED_TESTS, '%s is an invalid test' % (test,))
    for test in SHUFFLED_SHARDED_TESTS:
      self.assert_(test in SHARDED_TESTS, '%s is an invalid test' % (test,))
 

testShuffleDoesNotInterleaveTestCases()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleDoesNotInterleaveTestCases

(

self

)

Definition at line 253 of file googletest-shuffle-test.py.

  def testShuffleDoesNotInterleaveTestCases(self):
    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ALL_TESTS)
    self._VerifyTestCasesDoNotInterleave(SHUFFLED_ACTIVE_TESTS)
    self._VerifyTestCasesDoNotInterleave(SHUFFLED_FILTERED_TESTS)
    self._VerifyTestCasesDoNotInterleave(SHUFFLED_SHARDED_TESTS)
 

testShuffleDoesNotRepeatTest()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleDoesNotRepeatTest

(

self

)

Definition at line 200 of file googletest-shuffle-test.py.

  def testShuffleDoesNotRepeatTest(self):
    for test in SHUFFLED_ALL_TESTS:
      self.assertEqual(1, SHUFFLED_ALL_TESTS.count(test),
                       '%s appears more than once' % (test,))
    for test in SHUFFLED_ACTIVE_TESTS:
      self.assertEqual(1, SHUFFLED_ACTIVE_TESTS.count(test),
                       '%s appears more than once' % (test,))
    for test in SHUFFLED_FILTERED_TESTS:
      self.assertEqual(1, SHUFFLED_FILTERED_TESTS.count(test),
                       '%s appears more than once' % (test,))
    for test in SHUFFLED_SHARDED_TESTS:
      self.assertEqual(1, SHUFFLED_SHARDED_TESTS.count(test),
                       '%s appears more than once' % (test,))
 

testShuffleGeneratesNewOrderInEachIteration()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleGeneratesNewOrderInEachIteration

(

self

)

Definition at line 291 of file googletest-shuffle-test.py.

  def testShuffleGeneratesNewOrderInEachIteration(self):
    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
        GetTestsForAllIterations(
            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
 
    self.assert_(tests_in_iteration1 != tests_in_iteration2,
                 tests_in_iteration1)
    self.assert_(tests_in_iteration1 != tests_in_iteration3,
                 tests_in_iteration1)
    self.assert_(tests_in_iteration2 != tests_in_iteration3,
                 tests_in_iteration2)
 

testShuffleIncludesAllTests()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleIncludesAllTests

(

self

)

Definition at line 224 of file googletest-shuffle-test.py.

  def testShuffleIncludesAllTests(self):
    for test in ALL_TESTS:
      self.assert_(test in SHUFFLED_ALL_TESTS, '%s is missing' % (test,))
    for test in ACTIVE_TESTS:
      self.assert_(test in SHUFFLED_ACTIVE_TESTS, '%s is missing' % (test,))
    for test in FILTERED_TESTS:
      self.assert_(test in SHUFFLED_FILTERED_TESTS, '%s is missing' % (test,))
    for test in SHARDED_TESTS:
      self.assert_(test in SHUFFLED_SHARDED_TESTS, '%s is missing' % (test,))
 

testShuffleLeavesDeathTestsAtFront()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleLeavesDeathTestsAtFront

(

self

)

Definition at line 234 of file googletest-shuffle-test.py.

  def testShuffleLeavesDeathTestsAtFront(self):
    non_death_test_found = False
    for test in SHUFFLED_ACTIVE_TESTS:
      if 'DeathTest.' in test:
        self.assert_(not non_death_test_found,
                     '%s appears after a non-death test' % (test,))
      else:
        non_death_test_found = True
 

testShufflePreservesNumberOfTests()

def googletest-shuffle-test.GTestShuffleUnitTest.testShufflePreservesNumberOfTests

(

self

)

Definition at line 173 of file googletest-shuffle-test.py.

  def testShufflePreservesNumberOfTests(self):
    self.assertEqual(len(ALL_TESTS), len(SHUFFLED_ALL_TESTS))
    self.assertEqual(len(ACTIVE_TESTS), len(SHUFFLED_ACTIVE_TESTS))
    self.assertEqual(len(FILTERED_TESTS), len(SHUFFLED_FILTERED_TESTS))
    self.assertEqual(len(SHARDED_TESTS), len(SHUFFLED_SHARDED_TESTS))
 

testShuffleRestoresOrderAfterEachIteration()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleRestoresOrderAfterEachIteration

(

self

)

Definition at line 259 of file googletest-shuffle-test.py.

  def testShuffleRestoresOrderAfterEachIteration(self):
    # Get the test lists in all 3 iterations, using random seed 1, 2,
    # and 3 respectively.  Google Test picks a different seed in each
    # iteration, and this test depends on the current implementation
    # picking successive numbers.  This dependency is not ideal, but
    # makes the test much easier to write.
    [tests_in_iteration1, tests_in_iteration2, tests_in_iteration3] = (
        GetTestsForAllIterations(
            {}, [ShuffleFlag(), RandomSeedFlag(1), RepeatFlag(3)]))
 
    # Make sure running the tests with random seed 1 gets the same
    # order as in iteration 1 above.
    [tests_with_seed1] = GetTestsForAllIterations(
        {}, [ShuffleFlag(), RandomSeedFlag(1)])
    self.assertEqual(tests_in_iteration1, tests_with_seed1)
 
    # Make sure running the tests with random seed 2 gets the same
    # order as in iteration 2 above.  Success means that Google Test
    # correctly restores the test order before re-shuffling at the
    # beginning of iteration 2.
    [tests_with_seed2] = GetTestsForAllIterations(
        {}, [ShuffleFlag(), RandomSeedFlag(2)])
    self.assertEqual(tests_in_iteration2, tests_with_seed2)
 
    # Make sure running the tests with random seed 3 gets the same
    # order as in iteration 3 above.  Success means that Google Test
    # correctly restores the test order before re-shuffling at the
    # beginning of iteration 3.
    [tests_with_seed3] = GetTestsForAllIterations(
        {}, [ShuffleFlag(), RandomSeedFlag(3)])
    self.assertEqual(tests_in_iteration3, tests_with_seed3)
 

testShuffleShardedTestsPreservesPartition()

def googletest-shuffle-test.GTestShuffleUnitTest.testShuffleShardedTestsPreservesPartition

(

self

)

Definition at line 303 of file googletest-shuffle-test.py.

  def testShuffleShardedTestsPreservesPartition(self):
    # If we run M tests on N shards, the same M tests should be run in
    # total, regardless of the random seeds used by the shards.
    [tests1] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
                                         SHARD_INDEX_ENV_VAR: '0'},
                                        [ShuffleFlag(), RandomSeedFlag(1)])
    [tests2] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
                                         SHARD_INDEX_ENV_VAR: '1'},
                                        [ShuffleFlag(), RandomSeedFlag(20)])
    [tests3] = GetTestsForAllIterations({TOTAL_SHARDS_ENV_VAR: '3',
                                         SHARD_INDEX_ENV_VAR: '2'},
                                        [ShuffleFlag(), RandomSeedFlag(25)])
    sorted_sharded_tests = tests1 + tests2 + tests3
    sorted_sharded_tests.sort()
    sorted_active_tests = []
    sorted_active_tests.extend(ACTIVE_TESTS)
    sorted_active_tests.sort()
    self.assertEqual(sorted_active_tests, sorted_sharded_tests)
 

---

The documentation for this class was generated from the following file:

• /media/home/debian/src/github/tesseract-ocr/tesseract/unittest/third_party/googletest/googletest/test/googletest-shuffle-test.py