Qucs-core
0.0.19
|
00001 // Copyright 2008 Google Inc. 00002 // All Rights Reserved. 00003 // 00004 // Redistribution and use in source and binary forms, with or without 00005 // modification, are permitted provided that the following conditions are 00006 // met: 00007 // 00008 // * Redistributions of source code must retain the above copyright 00009 // notice, this list of conditions and the following disclaimer. 00010 // * Redistributions in binary form must reproduce the above 00011 // copyright notice, this list of conditions and the following disclaimer 00012 // in the documentation and/or other materials provided with the 00013 // distribution. 00014 // * Neither the name of Google Inc. nor the names of its 00015 // contributors may be used to endorse or promote products derived from 00016 // this software without specific prior written permission. 00017 // 00018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00019 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00020 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 00021 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 00022 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00023 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 00024 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 00025 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 00026 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 00027 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00028 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00029 // 00030 // Author: wan@google.com (Zhanyong Wan) 00031 00032 #ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ 00033 #define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ 00034 00035 // This header implements typed tests and type-parameterized tests. 00036 00037 // Typed (aka type-driven) tests repeat the same test for types in a 00038 // list. You must know which types you want to test with when writing 00039 // typed tests. Here's how you do it: 00040 00041 #if 0 00042 00043 // First, define a fixture class template. It should be parameterized 00044 // by a type. Remember to derive it from testing::Test. 00045 template <typename T> 00046 class FooTest : public testing::Test { 00047 public: 00048 ... 00049 typedef std::list<T> List; 00050 static T shared_; 00051 T value_; 00052 }; 00053 00054 // Next, associate a list of types with the test case, which will be 00055 // repeated for each type in the list. The typedef is necessary for 00056 // the macro to parse correctly. 00057 typedef testing::Types<char, int, unsigned int> MyTypes; 00058 TYPED_TEST_CASE(FooTest, MyTypes); 00059 00060 // If the type list contains only one type, you can write that type 00061 // directly without Types<...>: 00062 // TYPED_TEST_CASE(FooTest, int); 00063 00064 // Then, use TYPED_TEST() instead of TEST_F() to define as many typed 00065 // tests for this test case as you want. 00066 TYPED_TEST(FooTest, DoesBlah) { 00067 // Inside a test, refer to TypeParam to get the type parameter. 00068 // Since we are inside a derived class template, C++ requires use to 00069 // visit the members of FooTest via 'this'. 00070 TypeParam n = this->value_; 00071 00072 // To visit static members of the fixture, add the TestFixture:: 00073 // prefix. 00074 n += TestFixture::shared_; 00075 00076 // To refer to typedefs in the fixture, add the "typename 00077 // TestFixture::" prefix. 00078 typename TestFixture::List values; 00079 values.push_back(n); 00080 ... 00081 } 00082 00083 TYPED_TEST(FooTest, HasPropertyA) { ... } 00084 00085 #endif // 0 00086 00087 // Type-parameterized tests are abstract test patterns parameterized 00088 // by a type. Compared with typed tests, type-parameterized tests 00089 // allow you to define the test pattern without knowing what the type 00090 // parameters are. The defined pattern can be instantiated with 00091 // different types any number of times, in any number of translation 00092 // units. 00093 // 00094 // If you are designing an interface or concept, you can define a 00095 // suite of type-parameterized tests to verify properties that any 00096 // valid implementation of the interface/concept should have. Then, 00097 // each implementation can easily instantiate the test suite to verify 00098 // that it conforms to the requirements, without having to write 00099 // similar tests repeatedly. Here's an example: 00100 00101 #if 0 00102 00103 // First, define a fixture class template. It should be parameterized 00104 // by a type. Remember to derive it from testing::Test. 00105 template <typename T> 00106 class FooTest : public testing::Test { 00107 ... 00108 }; 00109 00110 // Next, declare that you will define a type-parameterized test case 00111 // (the _P suffix is for "parameterized" or "pattern", whichever you 00112 // prefer): 00113 TYPED_TEST_CASE_P(FooTest); 00114 00115 // Then, use TYPED_TEST_P() to define as many type-parameterized tests 00116 // for this type-parameterized test case as you want. 00117 TYPED_TEST_P(FooTest, DoesBlah) { 00118 // Inside a test, refer to TypeParam to get the type parameter. 00119 TypeParam n = 0; 00120 ... 00121 } 00122 00123 TYPED_TEST_P(FooTest, HasPropertyA) { ... } 00124 00125 // Now the tricky part: you need to register all test patterns before 00126 // you can instantiate them. The first argument of the macro is the 00127 // test case name; the rest are the names of the tests in this test 00128 // case. 00129 REGISTER_TYPED_TEST_CASE_P(FooTest, 00130 DoesBlah, HasPropertyA); 00131 00132 // Finally, you are free to instantiate the pattern with the types you 00133 // want. If you put the above code in a header file, you can #include 00134 // it in multiple C++ source files and instantiate it multiple times. 00135 // 00136 // To distinguish different instances of the pattern, the first 00137 // argument to the INSTANTIATE_* macro is a prefix that will be added 00138 // to the actual test case name. Remember to pick unique prefixes for 00139 // different instances. 00140 typedef testing::Types<char, int, unsigned int> MyTypes; 00141 INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); 00142 00143 // If the type list contains only one type, you can write that type 00144 // directly without Types<...>: 00145 // INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int); 00146 00147 #endif // 0 00148 00149 #include "gtest/internal/gtest-port.h" 00150 #include "gtest/internal/gtest-type-util.h" 00151 00152 // Implements typed tests. 00153 00154 #if GTEST_HAS_TYPED_TEST 00155 00156 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 00157 // 00158 // Expands to the name of the typedef for the type parameters of the 00159 // given test case. 00160 # define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ 00161 00162 // The 'Types' template argument below must have spaces around it 00163 // since some compilers may choke on '>>' when passing a template 00164 // instance (e.g. Types<int>) 00165 # define TYPED_TEST_CASE(CaseName, Types) \ 00166 typedef ::testing::internal::TypeList< Types >::type \ 00167 GTEST_TYPE_PARAMS_(CaseName) 00168 00169 # define TYPED_TEST(CaseName, TestName) \ 00170 template <typename gtest_TypeParam_> \ 00171 class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ 00172 : public CaseName<gtest_TypeParam_> { \ 00173 private: \ 00174 typedef CaseName<gtest_TypeParam_> TestFixture; \ 00175 typedef gtest_TypeParam_ TypeParam; \ 00176 virtual void TestBody(); \ 00177 }; \ 00178 bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \ 00179 ::testing::internal::TypeParameterizedTest< \ 00180 CaseName, \ 00181 ::testing::internal::TemplateSel< \ 00182 GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \ 00183 GTEST_TYPE_PARAMS_(CaseName)>::Register(\ 00184 "", #CaseName, #TestName, 0); \ 00185 template <typename gtest_TypeParam_> \ 00186 void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody() 00187 00188 #endif // GTEST_HAS_TYPED_TEST 00189 00190 // Implements type-parameterized tests. 00191 00192 #if GTEST_HAS_TYPED_TEST_P 00193 00194 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 00195 // 00196 // Expands to the namespace name that the type-parameterized tests for 00197 // the given type-parameterized test case are defined in. The exact 00198 // name of the namespace is subject to change without notice. 00199 # define GTEST_CASE_NAMESPACE_(TestCaseName) \ 00200 gtest_case_##TestCaseName##_ 00201 00202 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 00203 // 00204 // Expands to the name of the variable used to remember the names of 00205 // the defined tests in the given test case. 00206 # define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \ 00207 gtest_typed_test_case_p_state_##TestCaseName##_ 00208 00209 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY. 00210 // 00211 // Expands to the name of the variable used to remember the names of 00212 // the registered tests in the given test case. 00213 # define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \ 00214 gtest_registered_test_names_##TestCaseName##_ 00215 00216 // The variables defined in the type-parameterized test macros are 00217 // static as typically these macros are used in a .h file that can be 00218 // #included in multiple translation units linked together. 00219 # define TYPED_TEST_CASE_P(CaseName) \ 00220 static ::testing::internal::TypedTestCasePState \ 00221 GTEST_TYPED_TEST_CASE_P_STATE_(CaseName) 00222 00223 # define TYPED_TEST_P(CaseName, TestName) \ 00224 namespace GTEST_CASE_NAMESPACE_(CaseName) { \ 00225 template <typename gtest_TypeParam_> \ 00226 class TestName : public CaseName<gtest_TypeParam_> { \ 00227 private: \ 00228 typedef CaseName<gtest_TypeParam_> TestFixture; \ 00229 typedef gtest_TypeParam_ TypeParam; \ 00230 virtual void TestBody(); \ 00231 }; \ 00232 static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ 00233 GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\ 00234 __FILE__, __LINE__, #CaseName, #TestName); \ 00235 } \ 00236 template <typename gtest_TypeParam_> \ 00237 void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody() 00238 00239 # define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \ 00240 namespace GTEST_CASE_NAMESPACE_(CaseName) { \ 00241 typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \ 00242 } \ 00243 static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \ 00244 GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\ 00245 __FILE__, __LINE__, #__VA_ARGS__) 00246 00247 // The 'Types' template argument below must have spaces around it 00248 // since some compilers may choke on '>>' when passing a template 00249 // instance (e.g. Types<int>) 00250 # define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ 00251 bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \ 00252 ::testing::internal::TypeParameterizedTestCase<CaseName, \ 00253 GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \ 00254 ::testing::internal::TypeList< Types >::type>::Register(\ 00255 #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) 00256 00257 #endif // GTEST_HAS_TYPED_TEST_P 00258 00259 #endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_