A List of Test representing a path to access a Test.  
 More...
#include <TestPath.h>
A List of Test representing a path to access a Test. 
The path can be converted to a string and resolved from a string with toString() and TestPath( Test *root, const std::string &pathAsString ).
Pointed tests are not owned by the class.
- See also
- Test::resolvedTestPath() 
◆ PathTestNames
◆ Tests
◆ TestPath() [1/5]
Constructs an invalid path. 
The path is invalid until a test is added with add(). 
 
 
◆ TestPath() [2/5]
      
        
          | TestPath::TestPath | ( | Test * | root | ) |  | 
      
 
Constructs a valid path. 
- Parameters
- 
  
  
 
 
◆ TestPath() [3/5]
      
        
          | TestPath::TestPath | ( | const TestPath & | otherPath, | 
        
          |  |  | int | indexFirst, | 
        
          |  |  | int | count = -1 | 
        
          |  | ) |  |  | 
      
 
Constructs a path using a slice of another path. 
- Parameters
- 
  
    | otherPath | Path the test are copied from. |  | indexFirst | Zero based index of the first test to copy. Adjusted to be in valid range. count is adjusted with indexFirst. |  | count | Number of tests to copy. If < 0 then all test starting from index indexFirst are copied. |  
 
 
 
◆ TestPath() [4/5]
      
        
          | TestPath::TestPath | ( | Test * | searchRoot, | 
        
          |  |  | const std::string & | pathAsString | 
        
          |  | ) |  |  | 
      
 
Resolves a path from a string returned by toString(). 
If pathAsString is an absolute path (begins with '/'), then the first test name of the path must be the name of searchRoot. Otherwise, pathAsString is a relative path, and the first test found using Test::findTest() matching the first test name is used as root. An empty string resolve to a path containing searchRoot.
The resolved path is always valid.
- Parameters
- 
  
    | searchRoot | Test used to resolve the path. |  | pathAsString | String that contains the path as a string created by toString(). |  
 
- Exceptions
- 
  
    | std::invalid_argument | if one of the test names can not be resolved. |  
 
- See also
- toString(). 
 
 
◆ TestPath() [5/5]
      
        
          | TestPath::TestPath | ( | const TestPath & | other | ) |  | 
      
 
Copy constructor. 
- Parameters
- 
  
  
 
 
◆ ~TestPath()
◆ add() [1/2]
  
  | 
        
          | void TestPath::add | ( | const TestPath & | path | ) |  |  | virtual | 
 
Adds all the tests of the specified path. 
- Parameters
- 
  
    | path | Path that contains the test to add. |  
 
 
 
◆ add() [2/2]
  
  | 
        
          | void TestPath::add | ( | Test * | test | ) |  |  | virtual | 
 
Adds a test to the path. 
- Parameters
- 
  
    | test | Pointer on the test to add. Must not be NULL. |  
 
 
 
◆ checkIndexValid()
  
  | 
        
          | void TestPath::checkIndexValid | ( | int | index | ) | const |  | protected | 
 
Checks that the specified test index is within valid range. 
- Parameters
- 
  
    | index | Zero based index to check. |  
 
- Exceptions
- 
  
  
 
 
◆ findActualRoot()
  
  | 
        
          | Test * TestPath::findActualRoot | ( | Test * | searchRoot, |  
          |  |  | const std::string & | pathAsString, |  
          |  |  | PathTestNames & | testNames |  
          |  | ) |  |  |  | protected | 
 
Finds the actual root of a path string and get the path string name components. 
- Parameters
- 
  
    | searchRoot | Test used as root if the path string is absolute, or to search the root test if the path string is relative. |  | pathAsString | Path string. May be absolute or relative. |  | testNames | Test name components are added to that container. |  
 
- Returns
- Pointer on the resolved root test. Never NULL.
- Exceptions
- 
  
    | std::invalid_argument | if either the root name can not be resolved or if pathAsString contains no name components. |  
 
 
 
◆ getChildTest()
  
  | 
        
          | Test * TestPath::getChildTest | ( |  | ) | const |  | virtual | 
 
Get the last test of the path. 
- Returns
- Pointer on the last test (test at the bottom of the hierarchy). Never NULL.
- Exceptions
- 
  
    | std::out_of_range | if the path is not valid ( isValid() returns false). |  
 
 
 
◆ getTestAt()
  
  | 
        
          | Test * TestPath::getTestAt | ( | int | index | ) | const |  | virtual | 
 
Returns the test of the specified index. 
- Parameters
- 
  
    | index | Zero based index of the test to return. |  
 
- Returns
- Pointer on the test at index index. Never NULL.
- Exceptions
- 
  
  
 
 
◆ getTestCount()
  
  | 
        
          | int TestPath::getTestCount | ( |  | ) | const |  | virtual | 
 
Returns the number of tests in the path. 
- Returns
- Number of tests in the path. 
 
 
◆ insert() [1/2]
  
  | 
        
          | void TestPath::insert | ( | const TestPath & | path, |  
          |  |  | int | index |  
          |  | ) |  |  |  | virtual | 
 
Inserts all the tests at the specified path at a given index. 
- Parameters
- 
  
    | path | Path that contains the test to insert. |  | index | Zero based index indicating where the tests are inserted. |  
 
- Exceptions
- 
  
    | std::out_of_range | is index < 0 or index > getTestCount(), and path is valid. |  
 
 
 
◆ insert() [2/2]
  
  | 
        
          | void TestPath::insert | ( | Test * | test, |  
          |  |  | int | index |  
          |  | ) |  |  |  | virtual | 
 
Inserts a test at the specified index. 
- Parameters
- 
  
    | test | Pointer on the test to insert. Must not be NULL. |  | index | Zero based index indicating where the test is inserted. |  
 
- Exceptions
- 
  
  
 
 
◆ isValid()
  
  | 
        
          | bool TestPath::isValid | ( |  | ) | const |  | virtual | 
 
Tests if the path contains at least one test. 
- Returns
- trueif the path contains at least one test, otherwise returns- false.
 
 
◆ operator=()
Assignment operator. 
- Parameters
- 
  
  
- Returns
- This object. 
 
 
◆ removeTest()
  
  | 
        
          | void TestPath::removeTest | ( | int | index | ) |  |  | virtual | 
 
Removes the test at the specified index of the path. 
- Parameters
- 
  
    | index | Zero based index of the test to remove. |  
 
- Exceptions
- 
  
  
 
 
◆ removeTests()
  
  | 
        
          | void TestPath::removeTests | ( |  | ) |  |  | virtual | 
 
Removes all the test from the path. 
The path becomes invalid after this call. 
 
 
◆ splitPathString()
  
  | 
        
          | bool TestPath::splitPathString | ( | const std::string & | pathAsString, |  
          |  |  | PathTestNames & | testNames |  
          |  | ) |  |  |  | protected | 
 
Splits a path string into its test name components. 
- Parameters
- 
  
    | pathAsString | Path string created with toString(). |  | testNames | Test name components are added to that container. |  
 
- Returns
- trueif the path is relative (does not begin with '/'),- falseif it is absolute (begin with '/').
 
 
◆ toString()
  
  | 
        
          | std::string TestPath::toString | ( |  | ) | const |  | virtual | 
 
Returns the path as a string. 
For example, if a path is composed of three tests named "All Tests", "Math" and "Math::testAdd", toString() will return:
"All Tests/Math/Math::testAdd".
- Returns
- A string composed of the test names separated with a '/'. It is a relative path. 
 
 
◆ up()
Removes the last test. 
- Exceptions
- 
  
    | std::out_of_range | is the path is invalid. |  
 
- See also
- isValid(). 
 
 
◆ m_tests
The documentation for this class was generated from the following files: