utils/unittest/googletest/include/gtest/gtest-typed-test.h

   1 // Copyright 2008 Google Inc.
   2 // All Rights Reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // Author: wan@google.com (Zhanyong Wan)
  31
  32 #ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
  33 #define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
  34
  35 // This header implements typed tests and type-parameterized tests.
  36
  37 // Typed (aka type-driven) tests repeat the same test for types in a
  38 // list.  You must know which types you want to test with when writing
  39 // typed tests. Here's how you do it:
  40
  41 #if 0
  42
  43 // First, define a fixture class template.  It should be parameterized
  44 // by a type.  Remember to derive it from testing::Test.
  45 template <typename T>
  46 class FooTest : public testing::Test {
  47  public:
  48   ...
  49   typedef std::list<T> List;
  50   static T shared_;
  51   T value_;
  52 };
  53
  54 // Next, associate a list of types with the test case, which will be
  55 // repeated for each type in the list.  The typedef is necessary for
  56 // the macro to parse correctly.
  57 typedef testing::Types<char, int, unsigned int> MyTypes;
  58 TYPED_TEST_CASE(FooTest, MyTypes);
  59
  60 // If the type list contains only one type, you can write that type
  61 // directly without Types<...>:
  62 //   TYPED_TEST_CASE(FooTest, int);
  63
  64 // Then, use TYPED_TEST() instead of TEST_F() to define as many typed
  65 // tests for this test case as you want.
  66 TYPED_TEST(FooTest, DoesBlah) {
  67   // Inside a test, refer to TypeParam to get the type parameter.
  68   // Since we are inside a derived class template, C++ requires use to
  69   // visit the members of FooTest via 'this'.
  70   TypeParam n = this->value_;
  71
  72   // To visit static members of the fixture, add the TestFixture::
  73   // prefix.
  74   n += TestFixture::shared_;
  75
  76   // To refer to typedefs in the fixture, add the "typename
  77   // TestFixture::" prefix.
  78   typename TestFixture::List values;
  79   values.push_back(n);
  80   ...
  81 }
  82
  83 TYPED_TEST(FooTest, HasPropertyA) { ... }
  84
  85 #endif  // 0
  86
  87 // Type-parameterized tests are abstract test patterns parameterized
  88 // by a type.  Compared with typed tests, type-parameterized tests
  89 // allow you to define the test pattern without knowing what the type
  90 // parameters are.  The defined pattern can be instantiated with
  91 // different types any number of times, in any number of translation
  92 // units.
  93 //
  94 // If you are designing an interface or concept, you can define a
  95 // suite of type-parameterized tests to verify properties that any
  96 // valid implementation of the interface/concept should have.  Then,
  97 // each implementation can easily instantiate the test suite to verify
  98 // that it conforms to the requirements, without having to write
  99 // similar tests repeatedly.  Here's an example:
 100
 101 #if 0
 102
 103 // First, define a fixture class template.  It should be parameterized
 104 // by a type.  Remember to derive it from testing::Test.
 105 template <typename T>
 106 class FooTest : public testing::Test {
 107   ...
 108 };
 109
 110 // Next, declare that you will define a type-parameterized test case
 111 // (the _P suffix is for "parameterized" or "pattern", whichever you
 112 // prefer):
 113 TYPED_TEST_CASE_P(FooTest);
 114
 115 // Then, use TYPED_TEST_P() to define as many type-parameterized tests
 116 // for this type-parameterized test case as you want.
 117 TYPED_TEST_P(FooTest, DoesBlah) {
 118   // Inside a test, refer to TypeParam to get the type parameter.
 119   TypeParam n = 0;
 120   ...
 121 }
 122
 123 TYPED_TEST_P(FooTest, HasPropertyA) { ... }
 124
 125 // Now the tricky part: you need to register all test patterns before
 126 // you can instantiate them.  The first argument of the macro is the
 127 // test case name; the rest are the names of the tests in this test
 128 // case.
 129 REGISTER_TYPED_TEST_CASE_P(FooTest,
 130                            DoesBlah, HasPropertyA);
 131
 132 // Finally, you are free to instantiate the pattern with the types you
 133 // want.  If you put the above code in a header file, you can #include
 134 // it in multiple C++ source files and instantiate it multiple times.
 135 //
 136 // To distinguish different instances of the pattern, the first
 137 // argument to the INSTANTIATE_* macro is a prefix that will be added
 138 // to the actual test case name.  Remember to pick unique prefixes for
 139 // different instances.
 140 typedef testing::Types<char, int, unsigned int> MyTypes;
 141 INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
 142
 143 // If the type list contains only one type, you can write that type
 144 // directly without Types<...>:
 145 //   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
 146
 147 #endif  // 0
 148
 149 #include <gtest/internal/gtest-port.h>
 150 #include <gtest/internal/gtest-type-util.h>
 151
 152 // Implements typed tests.
 153
 154 #ifdef GTEST_HAS_TYPED_TEST
 155
 156 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 157 //
 158 // Expands to the name of the typedef for the type parameters of the
 159 // given test case.
 160 #define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
 161
 162 #define TYPED_TEST_CASE(CaseName, Types) \
 163   typedef ::testing::internal::TypeList<Types>::type \
 164       GTEST_TYPE_PARAMS_(CaseName)
 165
 166 #define TYPED_TEST(CaseName, TestName) \
 167   template <typename gtest_TypeParam_> \
 168   class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
 169       : public CaseName<gtest_TypeParam_> { \
 170    private: \
 171     typedef CaseName<gtest_TypeParam_> TestFixture; \
 172     typedef gtest_TypeParam_ TypeParam; \
 173     virtual void TestBody(); \
 174   }; \
 175   bool gtest_##CaseName##_##TestName##_registered_ = \
 176       ::testing::internal::TypeParameterizedTest< \
 177           CaseName, \
 178           ::testing::internal::TemplateSel< \
 179               GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
 180           GTEST_TYPE_PARAMS_(CaseName)>::Register(\
 181               "", #CaseName, #TestName, 0); \
 182   template <typename gtest_TypeParam_> \
 183   void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
 184
 185 #endif  // GTEST_HAS_TYPED_TEST
 186
 187 // Implements type-parameterized tests.
 188
 189 #ifdef GTEST_HAS_TYPED_TEST_P
 190
 191 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 192 //
 193 // Expands to the namespace name that the type-parameterized tests for
 194 // the given type-parameterized test case are defined in.  The exact
 195 // name of the namespace is subject to change without notice.
 196 #define GTEST_CASE_NAMESPACE_(TestCaseName) \
 197   gtest_case_##TestCaseName##_
 198
 199 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 200 //
 201 // Expands to the name of the variable used to remember the names of
 202 // the defined tests in the given test case.
 203 #define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
 204   gtest_typed_test_case_p_state_##TestCaseName##_
 205
 206 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
 207 //
 208 // Expands to the name of the variable used to remember the names of
 209 // the registered tests in the given test case.
 210 #define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
 211   gtest_registered_test_names_##TestCaseName##_
 212
 213 // The variables defined in the type-parameterized test macros are
 214 // static as typically these macros are used in a .h file that can be
 215 // #included in multiple translation units linked together.
 216 #define TYPED_TEST_CASE_P(CaseName) \
 217   static ::testing::internal::TypedTestCasePState \
 218       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
 219
 220 #define TYPED_TEST_P(CaseName, TestName) \
 221   namespace GTEST_CASE_NAMESPACE_(CaseName) { \
 222   template <typename gtest_TypeParam_> \
 223   class TestName : public CaseName<gtest_TypeParam_> { \
 224    private: \
 225     typedef CaseName<gtest_TypeParam_> TestFixture; \
 226     typedef gtest_TypeParam_ TypeParam; \
 227     virtual void TestBody(); \
 228   }; \
 229   static bool gtest_##TestName##_defined_ = \
 230       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
 231           __FILE__, __LINE__, #CaseName, #TestName); \
 232   } \
 233   template <typename gtest_TypeParam_> \
 234   void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
 235
 236 #define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
 237   namespace GTEST_CASE_NAMESPACE_(CaseName) { \
 238   typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
 239   } \
 240   static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
 241       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
 242           __FILE__, __LINE__, #__VA_ARGS__)
 243
 244 #define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
 245   bool gtest_##Prefix##_##CaseName = \
 246       ::testing::internal::TypeParameterizedTestCase<CaseName, \
 247           GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
 248           ::testing::internal::TypeList<Types>::type>::Register(\
 249               #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
 250
 251 #endif  // GTEST_HAS_TYPED_TEST_P
 252
 253 #endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_