]>
Commit | Line | Data |
---|---|---|
31f18b77 FG |
1 | // Copyright 2005, 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 | // This sample teaches how to reuse a test fixture in multiple test | |
33 | // cases by deriving sub-fixtures from it. | |
34 | // | |
35 | // When you define a test fixture, you specify the name of the test | |
36 | // case that will use this fixture. Therefore, a test fixture can | |
37 | // be used by only one test case. | |
38 | // | |
39 | // Sometimes, more than one test cases may want to use the same or | |
40 | // slightly different test fixtures. For example, you may want to | |
41 | // make sure that all tests for a GUI library don't leak important | |
42 | // system resources like fonts and brushes. In Google Test, you do | |
43 | // this by putting the shared logic in a super (as in "super class") | |
44 | // test fixture, and then have each test case use a fixture derived | |
45 | // from this super fixture. | |
46 | ||
47 | #include <limits.h> | |
48 | #include <time.h> | |
49 | #include "sample3-inl.h" | |
50 | #include "gtest/gtest.h" | |
51 | #include "sample1.h" | |
52 | ||
53 | // In this sample, we want to ensure that every test finishes within | |
54 | // ~5 seconds. If a test takes longer to run, we consider it a | |
55 | // failure. | |
56 | // | |
57 | // We put the code for timing a test in a test fixture called | |
58 | // "QuickTest". QuickTest is intended to be the super fixture that | |
59 | // other fixtures derive from, therefore there is no test case with | |
60 | // the name "QuickTest". This is OK. | |
61 | // | |
62 | // Later, we will derive multiple test fixtures from QuickTest. | |
63 | class QuickTest : public testing::Test { | |
64 | protected: | |
65 | // Remember that SetUp() is run immediately before a test starts. | |
66 | // This is a good place to record the start time. | |
67 | virtual void SetUp() { | |
68 | start_time_ = time(NULL); | |
69 | } | |
70 | ||
71 | // TearDown() is invoked immediately after a test finishes. Here we | |
72 | // check if the test was too slow. | |
73 | virtual void TearDown() { | |
74 | // Gets the time when the test finishes | |
75 | const time_t end_time = time(NULL); | |
76 | ||
77 | // Asserts that the test took no more than ~5 seconds. Did you | |
78 | // know that you can use assertions in SetUp() and TearDown() as | |
79 | // well? | |
80 | EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long."; | |
81 | } | |
82 | ||
83 | // The UTC time (in seconds) when the test starts | |
84 | time_t start_time_; | |
85 | }; | |
86 | ||
87 | ||
88 | // We derive a fixture named IntegerFunctionTest from the QuickTest | |
89 | // fixture. All tests using this fixture will be automatically | |
90 | // required to be quick. | |
91 | class IntegerFunctionTest : public QuickTest { | |
92 | // We don't need any more logic than already in the QuickTest fixture. | |
93 | // Therefore the body is empty. | |
94 | }; | |
95 | ||
96 | ||
97 | // Now we can write tests in the IntegerFunctionTest test case. | |
98 | ||
99 | // Tests Factorial() | |
100 | TEST_F(IntegerFunctionTest, Factorial) { | |
101 | // Tests factorial of negative numbers. | |
102 | EXPECT_EQ(1, Factorial(-5)); | |
103 | EXPECT_EQ(1, Factorial(-1)); | |
104 | EXPECT_GT(Factorial(-10), 0); | |
105 | ||
106 | // Tests factorial of 0. | |
107 | EXPECT_EQ(1, Factorial(0)); | |
108 | ||
109 | // Tests factorial of positive numbers. | |
110 | EXPECT_EQ(1, Factorial(1)); | |
111 | EXPECT_EQ(2, Factorial(2)); | |
112 | EXPECT_EQ(6, Factorial(3)); | |
113 | EXPECT_EQ(40320, Factorial(8)); | |
114 | } | |
115 | ||
116 | ||
117 | // Tests IsPrime() | |
118 | TEST_F(IntegerFunctionTest, IsPrime) { | |
119 | // Tests negative input. | |
120 | EXPECT_FALSE(IsPrime(-1)); | |
121 | EXPECT_FALSE(IsPrime(-2)); | |
122 | EXPECT_FALSE(IsPrime(INT_MIN)); | |
123 | ||
124 | // Tests some trivial cases. | |
125 | EXPECT_FALSE(IsPrime(0)); | |
126 | EXPECT_FALSE(IsPrime(1)); | |
127 | EXPECT_TRUE(IsPrime(2)); | |
128 | EXPECT_TRUE(IsPrime(3)); | |
129 | ||
130 | // Tests positive input. | |
131 | EXPECT_FALSE(IsPrime(4)); | |
132 | EXPECT_TRUE(IsPrime(5)); | |
133 | EXPECT_FALSE(IsPrime(6)); | |
134 | EXPECT_TRUE(IsPrime(23)); | |
135 | } | |
136 | ||
137 | ||
138 | // The next test case (named "QueueTest") also needs to be quick, so | |
139 | // we derive another fixture from QuickTest. | |
140 | // | |
141 | // The QueueTest test fixture has some logic and shared objects in | |
142 | // addition to what's in QuickTest already. We define the additional | |
143 | // stuff inside the body of the test fixture, as usual. | |
144 | class QueueTest : public QuickTest { | |
145 | protected: | |
146 | virtual void SetUp() { | |
147 | // First, we need to set up the super fixture (QuickTest). | |
148 | QuickTest::SetUp(); | |
149 | ||
150 | // Second, some additional setup for this fixture. | |
151 | q1_.Enqueue(1); | |
152 | q2_.Enqueue(2); | |
153 | q2_.Enqueue(3); | |
154 | } | |
155 | ||
156 | // By default, TearDown() inherits the behavior of | |
157 | // QuickTest::TearDown(). As we have no additional cleaning work | |
158 | // for QueueTest, we omit it here. | |
159 | // | |
160 | // virtual void TearDown() { | |
161 | // QuickTest::TearDown(); | |
162 | // } | |
163 | ||
164 | Queue<int> q0_; | |
165 | Queue<int> q1_; | |
166 | Queue<int> q2_; | |
167 | }; | |
168 | ||
169 | ||
170 | // Now, let's write tests using the QueueTest fixture. | |
171 | ||
172 | // Tests the default constructor. | |
173 | TEST_F(QueueTest, DefaultConstructor) { | |
174 | EXPECT_EQ(0u, q0_.Size()); | |
175 | } | |
176 | ||
177 | // Tests Dequeue(). | |
178 | TEST_F(QueueTest, Dequeue) { | |
179 | int* n = q0_.Dequeue(); | |
180 | EXPECT_TRUE(n == NULL); | |
181 | ||
182 | n = q1_.Dequeue(); | |
183 | EXPECT_TRUE(n != NULL); | |
184 | EXPECT_EQ(1, *n); | |
185 | EXPECT_EQ(0u, q1_.Size()); | |
186 | delete n; | |
187 | ||
188 | n = q2_.Dequeue(); | |
189 | EXPECT_TRUE(n != NULL); | |
190 | EXPECT_EQ(2, *n); | |
191 | EXPECT_EQ(1u, q2_.Size()); | |
192 | delete n; | |
193 | } | |
194 | ||
195 | // If necessary, you can derive further test fixtures from a derived | |
196 | // fixture itself. For example, you can derive another fixture from | |
197 | // QueueTest. Google Test imposes no limit on how deep the hierarchy | |
198 | // can be. In practice, however, you probably don't want it to be too | |
199 | // deep as to be confusing. |