Torque2D Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | List of all members
GTestFilterUnitTest Class Reference
Inheritance diagram for GTestFilterUnitTest:

## 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
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)

## Detailed Description

    Tests the env variable or the command line flag to filter tests.

## Member Function Documentation

def AdjustForParameterizedTests | ( |  | self,
|  |  | tests_to_run
| ) |  |

    Adjust tests_to_run in case value parameterized tests are disabled.

def AssertPartitionIsValid | ( |  | self,
|  |  | set_var,
|  |  | list_of_sets
| ) |  |

    Asserts that list_of_sets is a valid partition of set_var.

def AssertSetEqual | ( |  | self,
|  |  | lhs,
|  |  | rhs
| ) |  |

    Asserts that two sets are equal.

def RunAndVerify | ( |  | self,
|  |  | gtest_filter,
|  |  | tests_to_run
| ) |  |

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

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.

def 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.

def setUp | ( |  | self | ) |

    Sets up test case.

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

def testBadFilter | ( |  | self | ) |

    Tests a filter that matches nothing.

def testDefaultBehavior | ( |  | self | ) |

    Tests the behavior of not specifying the filter.

def testDefaultBehaviorWithShards | ( |  | self | ) |

    Tests the behavior without the filter, with sharding enabled.

def testEmptyFilter | ( |  | self | ) |

    Tests an empty filter.

def testFilterByTest | ( |  | self | ) |

    Tests filtering by test name.

def testFilterByTestCase | ( |  | self | ) |

    Tests filtering by test case name.

def testFilterDisabledTests | ( |  | self | ) |

    Select only the disabled tests to run.

def testFilterWithoutDot | ( |  | self | ) |

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

def testFlagOverridesEnvVar | ( |  | self | ) |

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

def testFullName | ( |  | self | ) |

    Tests filtering by full name.

def testNegativeFilters | ( |  | self | ) |

def testShardingWorksWithDeathTests | ( |  | self | ) |

    Tests integration with death tests and sharding.

def testShardStatusFileIsCreated | ( |  | self | ) |

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

def testShardStatusFileIsCreatedWithListTests | ( |  | self | ) |

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

def testThreePatterns | ( |  | self | ) |

    Tests filters that consist of three patterns.

def testTwoPatterns | ( |  | self | ) |

    Tests filters that consist of two patterns.

def testUniversalFilters | ( |  | self | ) |

    Tests filters that match everything.

def testWildcardInTestCaseName | ( |  | self | ) |

    Tests using wildcard in the test case name.

def testWildcardInTestName | ( |  | self | ) |

    Tests using wildcard in the test name.

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

- testing/googleTest/test/gtest_filter_unittest.py