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 <string.h>  // For strcmp.
36
37#include <algorithm>
38
39#include "gtest/gtest.h"
40
41using ::testing::InitGoogleTest;
42
43namespace testing {
44namespace internal {
45
46template <typename T>
47struct LessByName {
48  bool operator()(const T* a, const T* b) {
49    return strcmp(a->name(), b->name()) < 0;
50  }
51};
52
53class UnitTestHelper {
54 public:
55  // Returns the array of pointers to all test suites sorted by the test suite
56  // name.  The caller is responsible for deleting the array.
57  static TestSuite const** GetSortedTestSuites() {
58    UnitTest& unit_test = *UnitTest::GetInstance();
59    auto const** const test_suites = new const TestSuite*[static_cast<size_t>(
60        unit_test.total_test_suite_count())];
61
62    for (int i = 0; i < unit_test.total_test_suite_count(); ++i)
63      test_suites[i] = unit_test.GetTestSuite(i);
64
65    std::sort(test_suites, 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)) return test_suite;
77    }
78    return nullptr;
79  }
80
81  // Returns the array of pointers to all tests in a particular test suite
82  // sorted by the test name.  The caller is responsible for deleting the
83  // array.
84  static TestInfo const** GetSortedTests(const TestSuite* test_suite) {
85    TestInfo const** const tests = new const TestInfo*[static_cast<size_t>(
86        test_suite->total_test_count())];
87
88    for (int i = 0; i < test_suite->total_test_count(); ++i)
89      tests[i] = test_suite->GetTestInfo(i);
90
91    std::sort(tests, tests + test_suite->total_test_count(),
92              LessByName<TestInfo>());
93    return tests;
94  }
95};
96
97template <typename T>
98class TestSuiteWithCommentTest : public Test {};
99TYPED_TEST_SUITE(TestSuiteWithCommentTest, Types<int>);
100TYPED_TEST(TestSuiteWithCommentTest, Dummy) {}
101
102const int kTypedTestSuites = 1;
103const 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.
108TEST(ApiTest, UnitTestImmutableAccessorsWork) {
109  const auto& 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
132AssertionResult IsNull(const char* str) {
133  if (str != nullptr) {
134    return testing::AssertionFailure() << "argument is " << str;
135  }
136  return AssertionSuccess();
137}
138
139TEST(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
200TEST(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.
221TEST(ApiTest, DISABLED_Dummy1) {}
222TEST(DISABLED_Test, Dummy2) {}
223
224class FinalSuccessChecker : public Environment {
225 protected:
226  void TearDown() override {
227    const auto& 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
322int main(int argc, char** argv) {
323  InitGoogleTest(&argc, argv);
324
325  AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
326
327  return RUN_ALL_TESTS();
328}
329