ceph/src/jaegertracing/opentelemetry-cpp/third_party/prometheus-cpp/3rdparty/googletest/googletest/test/gtest-unittest-api_test.cc

   1 // Copyright 2009 Google Inc.  All rights reserved.
   2 //
   3 // Redistribution and use in source and binary forms, with or without
   4 // modification, are permitted provided that the following conditions are
   5 // met:
   6 //
   7 //     * Redistributions of source code must retain the above copyright
   8 // notice, this list of conditions and the following disclaimer.
   9 //     * Redistributions in binary form must reproduce the above
  10 // copyright notice, this list of conditions and the following disclaimer
  11 // in the documentation and/or other materials provided with the
  12 // distribution.
  13 //     * Neither the name of Google Inc. nor the names of its
  14 // contributors may be used to endorse or promote products derived from
  15 // this software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 //
  30 // The Google C++ Testing and Mocking Framework (Google Test)
  31 //
  32 // This file contains tests verifying correctness of data provided via
  33 // UnitTest's public methods.
  34
  35 #include "gtest/gtest.h"
  36
  37 #include <string.h>  // For strcmp.
  38 #include <algorithm>
  39
  40 using ::testing::InitGoogleTest;
  41
  42 namespace testing {
  43 namespace internal {
  44
  45 template <typename T>
  46 struct LessByName {
  47   bool operator()(const T* a, const T* b) {
  48     return strcmp(a->name(), b->name()) < 0;
  49   }
  50 };
  51
  52 class UnitTestHelper {
  53  public:
  54   // Returns the array of pointers to all test suites sorted by the test suite
  55   // name.  The caller is responsible for deleting the array.
  56   static TestSuite const** GetSortedTestSuites() {
  57     UnitTest& unit_test = *UnitTest::GetInstance();
  58     auto const** const test_suites = new const TestSuite*[static_cast<size_t>(
  59       unit_test.total_test_suite_count())];
  60
  61     for (int i = 0; i < unit_test.total_test_suite_count(); ++i)
  62       test_suites[i] = unit_test.GetTestSuite(i);
  63
  64     std::sort(test_suites,
  65               test_suites + unit_test.total_test_suite_count(),
  66               LessByName<TestSuite>());
  67     return test_suites;
  68   }
  69
  70   // Returns the test suite by its name.  The caller doesn't own the returned
  71   // pointer.
  72   static const TestSuite* FindTestSuite(const char* name) {
  73     UnitTest& unit_test = *UnitTest::GetInstance();
  74     for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
  75       const TestSuite* test_suite = unit_test.GetTestSuite(i);
  76       if (0 == strcmp(test_suite->name(), name))
  77         return test_suite;
  78     }
  79     return nullptr;
  80   }
  81
  82   // Returns the array of pointers to all tests in a particular test suite
  83   // sorted by the test name.  The caller is responsible for deleting the
  84   // array.
  85   static TestInfo const** GetSortedTests(const TestSuite* test_suite) {
  86     TestInfo const** const tests = new const TestInfo*[static_cast<size_t>(
  87       test_suite->total_test_count())];
  88
  89     for (int i = 0; i < test_suite->total_test_count(); ++i)
  90       tests[i] = test_suite->GetTestInfo(i);
  91
  92     std::sort(tests, tests + test_suite->total_test_count(),
  93               LessByName<TestInfo>());
  94     return tests;
  95   }
  96 };
  97
  98 template <typename T> class TestSuiteWithCommentTest : public Test {};
  99 TYPED_TEST_SUITE(TestSuiteWithCommentTest, Types<int>);
 100 TYPED_TEST(TestSuiteWithCommentTest, Dummy) {}
 101
 102 const int kTypedTestSuites = 1;
 103 const int kTypedTests = 1;
 104
 105 // We can only test the accessors that do not change value while tests run.
 106 // Since tests can be run in any order, the values the accessors that track
 107 // test execution (such as failed_test_count) can not be predicted.
 108 TEST(ApiTest, UnitTestImmutableAccessorsWork) {
 109   UnitTest* unit_test = UnitTest::GetInstance();
 110
 111   ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count());
 112   EXPECT_EQ(1 + kTypedTestSuites, unit_test->test_suite_to_run_count());
 113   EXPECT_EQ(2, unit_test->disabled_test_count());
 114   EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
 115   EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
 116
 117   const TestSuite** const test_suites = UnitTestHelper::GetSortedTestSuites();
 118
 119   EXPECT_STREQ("ApiTest", test_suites[0]->name());
 120   EXPECT_STREQ("DISABLED_Test", test_suites[1]->name());
 121   EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suites[2]->name());
 122
 123   delete[] test_suites;
 124
 125   // The following lines initiate actions to verify certain methods in
 126   // FinalSuccessChecker::TearDown.
 127
 128   // Records a test property to verify TestResult::GetTestProperty().
 129   RecordProperty("key", "value");
 130 }
 131
 132 AssertionResult IsNull(const char* str) {
 133   if (str != nullptr) {
 134     return testing::AssertionFailure() << "argument is " << str;
 135   }
 136   return AssertionSuccess();
 137 }
 138
 139 TEST(ApiTest, TestSuiteImmutableAccessorsWork) {
 140   const TestSuite* test_suite = UnitTestHelper::FindTestSuite("ApiTest");
 141   ASSERT_TRUE(test_suite != nullptr);
 142
 143   EXPECT_STREQ("ApiTest", test_suite->name());
 144   EXPECT_TRUE(IsNull(test_suite->type_param()));
 145   EXPECT_TRUE(test_suite->should_run());
 146   EXPECT_EQ(1, test_suite->disabled_test_count());
 147   EXPECT_EQ(3, test_suite->test_to_run_count());
 148   ASSERT_EQ(4, test_suite->total_test_count());
 149
 150   const TestInfo** tests = UnitTestHelper::GetSortedTests(test_suite);
 151
 152   EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
 153   EXPECT_STREQ("ApiTest", tests[0]->test_suite_name());
 154   EXPECT_TRUE(IsNull(tests[0]->value_param()));
 155   EXPECT_TRUE(IsNull(tests[0]->type_param()));
 156   EXPECT_FALSE(tests[0]->should_run());
 157
 158   EXPECT_STREQ("TestSuiteDisabledAccessorsWork", tests[1]->name());
 159   EXPECT_STREQ("ApiTest", tests[1]->test_suite_name());
 160   EXPECT_TRUE(IsNull(tests[1]->value_param()));
 161   EXPECT_TRUE(IsNull(tests[1]->type_param()));
 162   EXPECT_TRUE(tests[1]->should_run());
 163
 164   EXPECT_STREQ("TestSuiteImmutableAccessorsWork", tests[2]->name());
 165   EXPECT_STREQ("ApiTest", tests[2]->test_suite_name());
 166   EXPECT_TRUE(IsNull(tests[2]->value_param()));
 167   EXPECT_TRUE(IsNull(tests[2]->type_param()));
 168   EXPECT_TRUE(tests[2]->should_run());
 169
 170   EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
 171   EXPECT_STREQ("ApiTest", tests[3]->test_suite_name());
 172   EXPECT_TRUE(IsNull(tests[3]->value_param()));
 173   EXPECT_TRUE(IsNull(tests[3]->type_param()));
 174   EXPECT_TRUE(tests[3]->should_run());
 175
 176   delete[] tests;
 177   tests = nullptr;
 178
 179   test_suite = UnitTestHelper::FindTestSuite("TestSuiteWithCommentTest/0");
 180   ASSERT_TRUE(test_suite != nullptr);
 181
 182   EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suite->name());
 183   EXPECT_STREQ(GetTypeName<Types<int>>().c_str(), test_suite->type_param());
 184   EXPECT_TRUE(test_suite->should_run());
 185   EXPECT_EQ(0, test_suite->disabled_test_count());
 186   EXPECT_EQ(1, test_suite->test_to_run_count());
 187   ASSERT_EQ(1, test_suite->total_test_count());
 188
 189   tests = UnitTestHelper::GetSortedTests(test_suite);
 190
 191   EXPECT_STREQ("Dummy", tests[0]->name());
 192   EXPECT_STREQ("TestSuiteWithCommentTest/0", tests[0]->test_suite_name());
 193   EXPECT_TRUE(IsNull(tests[0]->value_param()));
 194   EXPECT_STREQ(GetTypeName<Types<int>>().c_str(), tests[0]->type_param());
 195   EXPECT_TRUE(tests[0]->should_run());
 196
 197   delete[] tests;
 198 }
 199
 200 TEST(ApiTest, TestSuiteDisabledAccessorsWork) {
 201   const TestSuite* test_suite = UnitTestHelper::FindTestSuite("DISABLED_Test");
 202   ASSERT_TRUE(test_suite != nullptr);
 203
 204   EXPECT_STREQ("DISABLED_Test", test_suite->name());
 205   EXPECT_TRUE(IsNull(test_suite->type_param()));
 206   EXPECT_FALSE(test_suite->should_run());
 207   EXPECT_EQ(1, test_suite->disabled_test_count());
 208   EXPECT_EQ(0, test_suite->test_to_run_count());
 209   ASSERT_EQ(1, test_suite->total_test_count());
 210
 211   const TestInfo* const test_info = test_suite->GetTestInfo(0);
 212   EXPECT_STREQ("Dummy2", test_info->name());
 213   EXPECT_STREQ("DISABLED_Test", test_info->test_suite_name());
 214   EXPECT_TRUE(IsNull(test_info->value_param()));
 215   EXPECT_TRUE(IsNull(test_info->type_param()));
 216   EXPECT_FALSE(test_info->should_run());
 217 }
 218
 219 // These two tests are here to provide support for testing
 220 // test_suite_to_run_count, disabled_test_count, and test_to_run_count.
 221 TEST(ApiTest, DISABLED_Dummy1) {}
 222 TEST(DISABLED_Test, Dummy2) {}
 223
 224 class FinalSuccessChecker : public Environment {
 225  protected:
 226   void TearDown() override {
 227     UnitTest* unit_test = UnitTest::GetInstance();
 228
 229     EXPECT_EQ(1 + kTypedTestSuites, unit_test->successful_test_suite_count());
 230     EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
 231     EXPECT_EQ(0, unit_test->failed_test_suite_count());
 232     EXPECT_EQ(0, unit_test->failed_test_count());
 233     EXPECT_TRUE(unit_test->Passed());
 234     EXPECT_FALSE(unit_test->Failed());
 235     ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count());
 236
 237     const TestSuite** const test_suites = UnitTestHelper::GetSortedTestSuites();
 238
 239     EXPECT_STREQ("ApiTest", test_suites[0]->name());
 240     EXPECT_TRUE(IsNull(test_suites[0]->type_param()));
 241     EXPECT_TRUE(test_suites[0]->should_run());
 242     EXPECT_EQ(1, test_suites[0]->disabled_test_count());
 243     ASSERT_EQ(4, test_suites[0]->total_test_count());
 244     EXPECT_EQ(3, test_suites[0]->successful_test_count());
 245     EXPECT_EQ(0, test_suites[0]->failed_test_count());
 246     EXPECT_TRUE(test_suites[0]->Passed());
 247     EXPECT_FALSE(test_suites[0]->Failed());
 248
 249     EXPECT_STREQ("DISABLED_Test", test_suites[1]->name());
 250     EXPECT_TRUE(IsNull(test_suites[1]->type_param()));
 251     EXPECT_FALSE(test_suites[1]->should_run());
 252     EXPECT_EQ(1, test_suites[1]->disabled_test_count());
 253     ASSERT_EQ(1, test_suites[1]->total_test_count());
 254     EXPECT_EQ(0, test_suites[1]->successful_test_count());
 255     EXPECT_EQ(0, test_suites[1]->failed_test_count());
 256
 257     EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suites[2]->name());
 258     EXPECT_STREQ(GetTypeName<Types<int>>().c_str(),
 259                  test_suites[2]->type_param());
 260     EXPECT_TRUE(test_suites[2]->should_run());
 261     EXPECT_EQ(0, test_suites[2]->disabled_test_count());
 262     ASSERT_EQ(1, test_suites[2]->total_test_count());
 263     EXPECT_EQ(1, test_suites[2]->successful_test_count());
 264     EXPECT_EQ(0, test_suites[2]->failed_test_count());
 265     EXPECT_TRUE(test_suites[2]->Passed());
 266     EXPECT_FALSE(test_suites[2]->Failed());
 267
 268     const TestSuite* test_suite = UnitTestHelper::FindTestSuite("ApiTest");
 269     const TestInfo** tests = UnitTestHelper::GetSortedTests(test_suite);
 270     EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
 271     EXPECT_STREQ("ApiTest", tests[0]->test_suite_name());
 272     EXPECT_FALSE(tests[0]->should_run());
 273
 274     EXPECT_STREQ("TestSuiteDisabledAccessorsWork", tests[1]->name());
 275     EXPECT_STREQ("ApiTest", tests[1]->test_suite_name());
 276     EXPECT_TRUE(IsNull(tests[1]->value_param()));
 277     EXPECT_TRUE(IsNull(tests[1]->type_param()));
 278     EXPECT_TRUE(tests[1]->should_run());
 279     EXPECT_TRUE(tests[1]->result()->Passed());
 280     EXPECT_EQ(0, tests[1]->result()->test_property_count());
 281
 282     EXPECT_STREQ("TestSuiteImmutableAccessorsWork", tests[2]->name());
 283     EXPECT_STREQ("ApiTest", tests[2]->test_suite_name());
 284     EXPECT_TRUE(IsNull(tests[2]->value_param()));
 285     EXPECT_TRUE(IsNull(tests[2]->type_param()));
 286     EXPECT_TRUE(tests[2]->should_run());
 287     EXPECT_TRUE(tests[2]->result()->Passed());
 288     EXPECT_EQ(0, tests[2]->result()->test_property_count());
 289
 290     EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
 291     EXPECT_STREQ("ApiTest", tests[3]->test_suite_name());
 292     EXPECT_TRUE(IsNull(tests[3]->value_param()));
 293     EXPECT_TRUE(IsNull(tests[3]->type_param()));
 294     EXPECT_TRUE(tests[3]->should_run());
 295     EXPECT_TRUE(tests[3]->result()->Passed());
 296     EXPECT_EQ(1, tests[3]->result()->test_property_count());
 297     const TestProperty& property = tests[3]->result()->GetTestProperty(0);
 298     EXPECT_STREQ("key", property.key());
 299     EXPECT_STREQ("value", property.value());
 300
 301     delete[] tests;
 302
 303     test_suite = UnitTestHelper::FindTestSuite("TestSuiteWithCommentTest/0");
 304     tests = UnitTestHelper::GetSortedTests(test_suite);
 305
 306     EXPECT_STREQ("Dummy", tests[0]->name());
 307     EXPECT_STREQ("TestSuiteWithCommentTest/0", tests[0]->test_suite_name());
 308     EXPECT_TRUE(IsNull(tests[0]->value_param()));
 309     EXPECT_STREQ(GetTypeName<Types<int>>().c_str(), tests[0]->type_param());
 310     EXPECT_TRUE(tests[0]->should_run());
 311     EXPECT_TRUE(tests[0]->result()->Passed());
 312     EXPECT_EQ(0, tests[0]->result()->test_property_count());
 313
 314     delete[] tests;
 315     delete[] test_suites;
 316   }
 317 };
 318
 319 }  // namespace internal
 320 }  // namespace testing
 321
 322 int main(int argc, char **argv) {
 323   InitGoogleTest(&argc, argv);
 324
 325   AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
 326
 327   return RUN_ALL_TESTS();
 328 }