diff options
author | Gennadiy Civil <gennadiycivil@users.noreply.github.com> | 2019-05-17 15:10:47 -0400 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-05-17 15:10:47 -0400 |
commit | f71fb4f9a912ec945401cc49a287a759b6131026 (patch) | |
tree | 1cbe476ff21536aaea50d4ef406a42f248ffba5b /googletest/docs | |
parent | 03273a89827ffedfee19cfaae5d85dee60779441 (diff) | |
download | googletest-f71fb4f9a912ec945401cc49a287a759b6131026.tar.gz googletest-f71fb4f9a912ec945401cc49a287a759b6131026.tar.bz2 googletest-f71fb4f9a912ec945401cc49a287a759b6131026.zip |
Update advanced.md
Adding back section that was lost in merge
Diffstat (limited to 'googletest/docs')
-rw-r--r-- | googletest/docs/advanced.md | 61 |
1 files changed, 61 insertions, 0 deletions
diff --git a/googletest/docs/advanced.md b/googletest/docs/advanced.md index b1a4815e..604b4715 100644 --- a/googletest/docs/advanced.md +++ b/googletest/docs/advanced.md @@ -1817,6 +1817,67 @@ For technical reasons, there are some caveats: 1. `statement` in `EXPECT_FATAL_FAILURE{_ON_ALL_THREADS}()()` cannot return a value. +## Registering tests programmatically + + The `TEST` macros handle the vast majority of all use cases, but there are few +were runtime registration logic is required. For those cases, the framework +provides the `::testing::RegisterTest` that allows callers to register arbitrary +tests dynamically. + This is an advanced API only to be used when the `TEST` macros are insufficient. +The macros should be preferred when possible, as they avoid most of the +complexity of calling this function. + It provides the following signature: + ```c++ +template <typename Factory> +TestInfo* RegisterTest(const char* test_case_name, const char* test_name, + const char* type_param, const char* value_param, + const char* file, int line, Factory factory); +``` + The `factory` argument is a factory callable (move-constructible) object or +function pointer that creates a new instance of the Test object. It handles +ownership to the caller. The signature of the callable is `Fixture*()`, where +`Fixture` is the test fixture class for the test. All tests registered with the +same `test_case_name` must return the same fixture type. This is checked at +runtime. + The framework will infer the fixture class from the factory and will call the +`SetUpTestCase` and `TearDownTestCase` for it. + Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is +undefined. + Use case example: + ```c++ +class MyFixture : public ::testing::Test { + public: + // All of these optional, just like in regular macro usage. + static void SetUpTestCase() { ... } + static void TearDownTestCase() { ... } + void SetUp() override { ... } + void TearDown() override { ... } +}; + class MyTest : public MyFixture { + public: + explicit MyTest(int data) : data_(data) {} + void TestBody() override { ... } + private: + int data_; +}; + void RegisterMyTests(const std::vector<int>& values) { + for (int v : values) { + ::testing::RegisterTest( + "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr, + std::to_string(v).c_str(), + __FILE__, __LINE__, + // Important to use the fixture type as the return type here. + [=]() -> MyFixture* { return new MyTest(v); }); + } +} +... +int main(int argc, char** argv) { + std::vector<int> values_to_test = LoadValuesFromConfig(); + RegisterMyTests(values_to_test); + ... + return RUN_ALL_TESTS(); +} +``` ## Getting the Current Test's Name |