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 // Tests for Google Test itself. This verifies that the basic constructs of
33 // Google Test work.
34
35 #include "gtest/gtest.h"
36
37 // Verifies that the command line flag variables can be accessed
38 // in code once <gtest/gtest.h> has been #included.
39 // Do not move it after other #includes.
TEST(CommandLineFlagsTest,CanBeAccessedInCodeOnceGTestHIsIncluded)40 TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
41 bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
42 || testing::GTEST_FLAG(break_on_failure)
43 || testing::GTEST_FLAG(catch_exceptions)
44 || testing::GTEST_FLAG(color) != "unknown"
45 || testing::GTEST_FLAG(filter) != "unknown"
46 || testing::GTEST_FLAG(list_tests)
47 || testing::GTEST_FLAG(output) != "unknown"
48 || testing::GTEST_FLAG(print_time)
49 || testing::GTEST_FLAG(random_seed)
50 || testing::GTEST_FLAG(repeat) > 0
51 || testing::GTEST_FLAG(show_internal_stack_frames)
52 || testing::GTEST_FLAG(shuffle)
53 || testing::GTEST_FLAG(stack_trace_depth) > 0
54 || testing::GTEST_FLAG(stream_result_to) != "unknown"
55 || testing::GTEST_FLAG(throw_on_failure);
56 EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused.
57 }
58
59 #include <limits.h> // For INT_MAX.
60 #include <stdlib.h>
61 #include <string.h>
62 #include <time.h>
63
64 #include <map>
65 #include <vector>
66 #include <ostream>
67
68 #include "gtest/gtest-spi.h"
69
70 // Indicates that this translation unit is part of Google Test's
71 // implementation. It must come before gtest-internal-inl.h is
72 // included, or there will be a compiler error. This trick is to
73 // prevent a user from accidentally including gtest-internal-inl.h in
74 // his code.
75 #define GTEST_IMPLEMENTATION_ 1
76 #include "src/gtest-internal-inl.h"
77 #undef GTEST_IMPLEMENTATION_
78
79 namespace testing {
80 namespace internal {
81
82 // Provides access to otherwise private parts of the TestEventListeners class
83 // that are needed to test it.
84 class TestEventListenersAccessor {
85 public:
GetRepeater(TestEventListeners * listeners)86 static TestEventListener* GetRepeater(TestEventListeners* listeners) {
87 return listeners->repeater();
88 }
89
SetDefaultResultPrinter(TestEventListeners * listeners,TestEventListener * listener)90 static void SetDefaultResultPrinter(TestEventListeners* listeners,
91 TestEventListener* listener) {
92 listeners->SetDefaultResultPrinter(listener);
93 }
SetDefaultXmlGenerator(TestEventListeners * listeners,TestEventListener * listener)94 static void SetDefaultXmlGenerator(TestEventListeners* listeners,
95 TestEventListener* listener) {
96 listeners->SetDefaultXmlGenerator(listener);
97 }
98
EventForwardingEnabled(const TestEventListeners & listeners)99 static bool EventForwardingEnabled(const TestEventListeners& listeners) {
100 return listeners.EventForwardingEnabled();
101 }
102
SuppressEventForwarding(TestEventListeners * listeners)103 static void SuppressEventForwarding(TestEventListeners* listeners) {
104 listeners->SuppressEventForwarding();
105 }
106 };
107
108 } // namespace internal
109 } // namespace testing
110
111 using testing::AssertionFailure;
112 using testing::AssertionResult;
113 using testing::AssertionSuccess;
114 using testing::DoubleLE;
115 using testing::EmptyTestEventListener;
116 using testing::FloatLE;
117 using testing::GTEST_FLAG(also_run_disabled_tests);
118 using testing::GTEST_FLAG(break_on_failure);
119 using testing::GTEST_FLAG(catch_exceptions);
120 using testing::GTEST_FLAG(color);
121 using testing::GTEST_FLAG(death_test_use_fork);
122 using testing::GTEST_FLAG(filter);
123 using testing::GTEST_FLAG(list_tests);
124 using testing::GTEST_FLAG(output);
125 using testing::GTEST_FLAG(print_time);
126 using testing::GTEST_FLAG(random_seed);
127 using testing::GTEST_FLAG(repeat);
128 using testing::GTEST_FLAG(show_internal_stack_frames);
129 using testing::GTEST_FLAG(shuffle);
130 using testing::GTEST_FLAG(stack_trace_depth);
131 using testing::GTEST_FLAG(stream_result_to);
132 using testing::GTEST_FLAG(throw_on_failure);
133 using testing::IsNotSubstring;
134 using testing::IsSubstring;
135 using testing::Message;
136 using testing::ScopedFakeTestPartResultReporter;
137 using testing::StaticAssertTypeEq;
138 using testing::Test;
139 using testing::TestCase;
140 using testing::TestEventListeners;
141 using testing::TestPartResult;
142 using testing::TestPartResultArray;
143 using testing::TestProperty;
144 using testing::TestResult;
145 using testing::TimeInMillis;
146 using testing::UnitTest;
147 using testing::kMaxStackTraceDepth;
148 using testing::internal::AddReference;
149 using testing::internal::AlwaysFalse;
150 using testing::internal::AlwaysTrue;
151 using testing::internal::AppendUserMessage;
152 using testing::internal::ArrayAwareFind;
153 using testing::internal::ArrayEq;
154 using testing::internal::CodePointToUtf8;
155 using testing::internal::CompileAssertTypesEqual;
156 using testing::internal::CopyArray;
157 using testing::internal::CountIf;
158 using testing::internal::EqFailure;
159 using testing::internal::FloatingPoint;
160 using testing::internal::ForEach;
161 using testing::internal::FormatEpochTimeInMillisAsIso8601;
162 using testing::internal::FormatTimeInMillisAsSeconds;
163 using testing::internal::GTestFlagSaver;
164 using testing::internal::GetCurrentOsStackTraceExceptTop;
165 using testing::internal::GetElementOr;
166 using testing::internal::GetNextRandomSeed;
167 using testing::internal::GetRandomSeedFromFlag;
168 using testing::internal::GetTestTypeId;
169 using testing::internal::GetTimeInMillis;
170 using testing::internal::GetTypeId;
171 using testing::internal::GetUnitTestImpl;
172 using testing::internal::ImplicitlyConvertible;
173 using testing::internal::Int32;
174 using testing::internal::Int32FromEnvOrDie;
175 using testing::internal::IsAProtocolMessage;
176 using testing::internal::IsContainer;
177 using testing::internal::IsContainerTest;
178 using testing::internal::IsNotContainer;
179 using testing::internal::NativeArray;
180 using testing::internal::ParseInt32Flag;
181 using testing::internal::RemoveConst;
182 using testing::internal::RemoveReference;
183 using testing::internal::ShouldRunTestOnShard;
184 using testing::internal::ShouldShard;
185 using testing::internal::ShouldUseColor;
186 using testing::internal::Shuffle;
187 using testing::internal::ShuffleRange;
188 using testing::internal::SkipPrefix;
189 using testing::internal::StreamableToString;
190 using testing::internal::String;
191 using testing::internal::TestEventListenersAccessor;
192 using testing::internal::TestResultAccessor;
193 using testing::internal::UInt32;
194 using testing::internal::WideStringToUtf8;
195 using testing::internal::kCopy;
196 using testing::internal::kMaxRandomSeed;
197 using testing::internal::kReference;
198 using testing::internal::kTestTypeIdInGoogleTest;
199 using testing::internal::scoped_ptr;
200
201 #if GTEST_HAS_STREAM_REDIRECTION
202 using testing::internal::CaptureStdout;
203 using testing::internal::GetCapturedStdout;
204 #endif
205
206 #if GTEST_IS_THREADSAFE
207 using testing::internal::ThreadWithParam;
208 #endif
209
210 class TestingVector : public std::vector<int> {
211 };
212
operator <<(::std::ostream & os,const TestingVector & vector)213 ::std::ostream& operator<<(::std::ostream& os,
214 const TestingVector& vector) {
215 os << "{ ";
216 for (size_t i = 0; i < vector.size(); i++) {
217 os << vector[i] << " ";
218 }
219 os << "}";
220 return os;
221 }
222
223 // This line tests that we can define tests in an unnamed namespace.
224 namespace {
225
TEST(GetRandomSeedFromFlagTest,HandlesZero)226 TEST(GetRandomSeedFromFlagTest, HandlesZero) {
227 const int seed = GetRandomSeedFromFlag(0);
228 EXPECT_LE(1, seed);
229 EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed));
230 }
231
TEST(GetRandomSeedFromFlagTest,PreservesValidSeed)232 TEST(GetRandomSeedFromFlagTest, PreservesValidSeed) {
233 EXPECT_EQ(1, GetRandomSeedFromFlag(1));
234 EXPECT_EQ(2, GetRandomSeedFromFlag(2));
235 EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1));
236 EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
237 GetRandomSeedFromFlag(kMaxRandomSeed));
238 }
239
TEST(GetRandomSeedFromFlagTest,NormalizesInvalidSeed)240 TEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) {
241 const int seed1 = GetRandomSeedFromFlag(-1);
242 EXPECT_LE(1, seed1);
243 EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed));
244
245 const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1);
246 EXPECT_LE(1, seed2);
247 EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed));
248 }
249
TEST(GetNextRandomSeedTest,WorksForValidInput)250 TEST(GetNextRandomSeedTest, WorksForValidInput) {
251 EXPECT_EQ(2, GetNextRandomSeed(1));
252 EXPECT_EQ(3, GetNextRandomSeed(2));
253 EXPECT_EQ(static_cast<int>(kMaxRandomSeed),
254 GetNextRandomSeed(kMaxRandomSeed - 1));
255 EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed));
256
257 // We deliberately don't test GetNextRandomSeed() with invalid
258 // inputs, as that requires death tests, which are expensive. This
259 // is fine as GetNextRandomSeed() is internal and has a
260 // straightforward definition.
261 }
262
ClearCurrentTestPartResults()263 static void ClearCurrentTestPartResults() {
264 TestResultAccessor::ClearTestPartResults(
265 GetUnitTestImpl()->current_test_result());
266 }
267
268 // Tests GetTypeId.
269
TEST(GetTypeIdTest,ReturnsSameValueForSameType)270 TEST(GetTypeIdTest, ReturnsSameValueForSameType) {
271 EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>());
272 EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>());
273 }
274
275 class SubClassOfTest : public Test {};
276 class AnotherSubClassOfTest : public Test {};
277
TEST(GetTypeIdTest,ReturnsDifferentValuesForDifferentTypes)278 TEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) {
279 EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>());
280 EXPECT_NE(GetTypeId<int>(), GetTypeId<char>());
281 EXPECT_NE(GetTypeId<int>(), GetTestTypeId());
282 EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId());
283 EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId());
284 EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>());
285 }
286
287 // Verifies that GetTestTypeId() returns the same value, no matter it
288 // is called from inside Google Test or outside of it.
TEST(GetTestTypeIdTest,ReturnsTheSameValueInsideOrOutsideOfGoogleTest)289 TEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) {
290 EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId());
291 }
292
293 // Tests FormatTimeInMillisAsSeconds().
294
TEST(FormatTimeInMillisAsSecondsTest,FormatsZero)295 TEST(FormatTimeInMillisAsSecondsTest, FormatsZero) {
296 EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0));
297 }
298
TEST(FormatTimeInMillisAsSecondsTest,FormatsPositiveNumber)299 TEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) {
300 EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3));
301 EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10));
302 EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200));
303 EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200));
304 EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000));
305 }
306
TEST(FormatTimeInMillisAsSecondsTest,FormatsNegativeNumber)307 TEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) {
308 EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3));
309 EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10));
310 EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200));
311 EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200));
312 EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000));
313 }
314
315 // Tests FormatEpochTimeInMillisAsIso8601(). The correctness of conversion
316 // for particular dates below was verified in Python using
317 // datetime.datetime.fromutctimestamp(<timetamp>/1000).
318
319 // FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
320 // have to set up a particular timezone to obtain predictable results.
321 class FormatEpochTimeInMillisAsIso8601Test : public Test {
322 public:
323 // On Cygwin, GCC doesn't allow unqualified integer literals to exceed
324 // 32 bits, even when 64-bit integer types are available. We have to
325 // force the constants to have a 64-bit type here.
326 static const TimeInMillis kMillisPerSec = 1000;
327
328 private:
SetUp()329 virtual void SetUp() {
330 saved_tz_ = NULL;
331 #if _MSC_VER
332 # pragma warning(push) // Saves the current warning state.
333 # pragma warning(disable:4996) // Temporarily disables warning 4996
334 // (function or variable may be unsafe
335 // for getenv, function is deprecated for
336 // strdup).
337 if (getenv("TZ"))
338 saved_tz_ = strdup(getenv("TZ"));
339 # pragma warning(pop) // Restores the warning state again.
340 #else
341 if (getenv("TZ"))
342 saved_tz_ = strdup(getenv("TZ"));
343 #endif
344
345 // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We
346 // cannot use the local time zone because the function's output depends
347 // on the time zone.
348 SetTimeZone("UTC+00");
349 }
350
TearDown()351 virtual void TearDown() {
352 SetTimeZone(saved_tz_);
353 free(const_cast<char*>(saved_tz_));
354 saved_tz_ = NULL;
355 }
356
SetTimeZone(const char * time_zone)357 static void SetTimeZone(const char* time_zone) {
358 // tzset() distinguishes between the TZ variable being present and empty
359 // and not being present, so we have to consider the case of time_zone
360 // being NULL.
361 #if _MSC_VER
362 // ...Unless it's MSVC, whose standard library's _putenv doesn't
363 // distinguish between an empty and a missing variable.
364 const std::string env_var =
365 std::string("TZ=") + (time_zone ? time_zone : "");
366 _putenv(env_var.c_str());
367 # pragma warning(push) // Saves the current warning state.
368 # pragma warning(disable:4996) // Temporarily disables warning 4996
369 // (function is deprecated).
370 tzset();
371 # pragma warning(pop) // Restores the warning state again.
372 #else
373 if (time_zone) {
374 setenv(("TZ"), time_zone, 1);
375 } else {
376 unsetenv("TZ");
377 }
378 tzset();
379 #endif
380 }
381
382 const char* saved_tz_;
383 };
384
385 const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec;
386
TEST_F(FormatEpochTimeInMillisAsIso8601Test,PrintsTwoDigitSegments)387 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) {
388 EXPECT_EQ("2011-10-31T18:52:42",
389 FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec));
390 }
391
TEST_F(FormatEpochTimeInMillisAsIso8601Test,MillisecondsDoNotAffectResult)392 TEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) {
393 EXPECT_EQ(
394 "2011-10-31T18:52:42",
395 FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234));
396 }
397
TEST_F(FormatEpochTimeInMillisAsIso8601Test,PrintsLeadingZeroes)398 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) {
399 EXPECT_EQ("2011-09-03T05:07:02",
400 FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec));
401 }
402
TEST_F(FormatEpochTimeInMillisAsIso8601Test,Prints24HourTime)403 TEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) {
404 EXPECT_EQ("2011-09-28T17:08:22",
405 FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec));
406 }
407
TEST_F(FormatEpochTimeInMillisAsIso8601Test,PrintsEpochStart)408 TEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) {
409 EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0));
410 }
411
412 #if GTEST_CAN_COMPARE_NULL
413
414 # ifdef __BORLANDC__
415 // Silences warnings: "Condition is always true", "Unreachable code"
416 # pragma option push -w-ccc -w-rch
417 # endif
418
419 // Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null
420 // pointer literal.
TEST(NullLiteralTest,IsTrueForNullLiterals)421 TEST(NullLiteralTest, IsTrueForNullLiterals) {
422 EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL));
423 EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0));
424 EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U));
425 EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L));
426
427 # ifndef __BORLANDC__
428
429 // Some compilers may fail to detect some null pointer literals;
430 // as long as users of the framework don't use such literals, this
431 // is harmless.
432 EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1));
433
434 # endif
435 }
436
437 // Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null
438 // pointer literal.
TEST(NullLiteralTest,IsFalseForNonNullLiterals)439 TEST(NullLiteralTest, IsFalseForNonNullLiterals) {
440 EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1));
441 EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0));
442 EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a'));
443 EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL)));
444 }
445
446 # ifdef __BORLANDC__
447 // Restores warnings after previous "#pragma option push" suppressed them.
448 # pragma option pop
449 # endif
450
451 #endif // GTEST_CAN_COMPARE_NULL
452 //
453 // Tests CodePointToUtf8().
454
455 // Tests that the NUL character L'\0' is encoded correctly.
TEST(CodePointToUtf8Test,CanEncodeNul)456 TEST(CodePointToUtf8Test, CanEncodeNul) {
457 char buffer[32];
458 EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer));
459 }
460
461 // Tests that ASCII characters are encoded correctly.
TEST(CodePointToUtf8Test,CanEncodeAscii)462 TEST(CodePointToUtf8Test, CanEncodeAscii) {
463 char buffer[32];
464 EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer));
465 EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer));
466 EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer));
467 EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer));
468 }
469
470 // Tests that Unicode code-points that have 8 to 11 bits are encoded
471 // as 110xxxxx 10xxxxxx.
TEST(CodePointToUtf8Test,CanEncode8To11Bits)472 TEST(CodePointToUtf8Test, CanEncode8To11Bits) {
473 char buffer[32];
474 // 000 1101 0011 => 110-00011 10-010011
475 EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer));
476
477 // 101 0111 0110 => 110-10101 10-110110
478 // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints
479 // in wide strings and wide chars. In order to accomodate them, we have to
480 // introduce such character constants as integers.
481 EXPECT_STREQ("\xD5\xB6",
482 CodePointToUtf8(static_cast<wchar_t>(0x576), buffer));
483 }
484
485 // Tests that Unicode code-points that have 12 to 16 bits are encoded
486 // as 1110xxxx 10xxxxxx 10xxxxxx.
TEST(CodePointToUtf8Test,CanEncode12To16Bits)487 TEST(CodePointToUtf8Test, CanEncode12To16Bits) {
488 char buffer[32];
489 // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
490 EXPECT_STREQ("\xE0\xA3\x93",
491 CodePointToUtf8(static_cast<wchar_t>(0x8D3), buffer));
492
493 // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
494 EXPECT_STREQ("\xEC\x9D\x8D",
495 CodePointToUtf8(static_cast<wchar_t>(0xC74D), buffer));
496 }
497
498 #if !GTEST_WIDE_STRING_USES_UTF16_
499 // Tests in this group require a wchar_t to hold > 16 bits, and thus
500 // are skipped on Windows, Cygwin, and Symbian, where a wchar_t is
501 // 16-bit wide. This code may not compile on those systems.
502
503 // Tests that Unicode code-points that have 17 to 21 bits are encoded
504 // as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx.
TEST(CodePointToUtf8Test,CanEncode17To21Bits)505 TEST(CodePointToUtf8Test, CanEncode17To21Bits) {
506 char buffer[32];
507 // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
508 EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer));
509
510 // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000
511 EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer));
512
513 // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
514 EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer));
515 }
516
517 // Tests that encoding an invalid code-point generates the expected result.
TEST(CodePointToUtf8Test,CanEncodeInvalidCodePoint)518 TEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) {
519 char buffer[32];
520 EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)",
521 CodePointToUtf8(L'\x1234ABCD', buffer));
522 }
523
524 #endif // !GTEST_WIDE_STRING_USES_UTF16_
525
526 // Tests WideStringToUtf8().
527
528 // Tests that the NUL character L'\0' is encoded correctly.
TEST(WideStringToUtf8Test,CanEncodeNul)529 TEST(WideStringToUtf8Test, CanEncodeNul) {
530 EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str());
531 EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str());
532 }
533
534 // Tests that ASCII strings are encoded correctly.
TEST(WideStringToUtf8Test,CanEncodeAscii)535 TEST(WideStringToUtf8Test, CanEncodeAscii) {
536 EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str());
537 EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str());
538 EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str());
539 EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str());
540 }
541
542 // Tests that Unicode code-points that have 8 to 11 bits are encoded
543 // as 110xxxxx 10xxxxxx.
TEST(WideStringToUtf8Test,CanEncode8To11Bits)544 TEST(WideStringToUtf8Test, CanEncode8To11Bits) {
545 // 000 1101 0011 => 110-00011 10-010011
546 EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str());
547 EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str());
548
549 // 101 0111 0110 => 110-10101 10-110110
550 const wchar_t s[] = { 0x576, '\0' };
551 EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str());
552 EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str());
553 }
554
555 // Tests that Unicode code-points that have 12 to 16 bits are encoded
556 // as 1110xxxx 10xxxxxx 10xxxxxx.
TEST(WideStringToUtf8Test,CanEncode12To16Bits)557 TEST(WideStringToUtf8Test, CanEncode12To16Bits) {
558 // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011
559 const wchar_t s1[] = { 0x8D3, '\0' };
560 EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str());
561 EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str());
562
563 // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101
564 const wchar_t s2[] = { 0xC74D, '\0' };
565 EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str());
566 EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str());
567 }
568
569 // Tests that the conversion stops when the function encounters \0 character.
TEST(WideStringToUtf8Test,StopsOnNulCharacter)570 TEST(WideStringToUtf8Test, StopsOnNulCharacter) {
571 EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str());
572 }
573
574 // Tests that the conversion stops when the function reaches the limit
575 // specified by the 'length' parameter.
TEST(WideStringToUtf8Test,StopsWhenLengthLimitReached)576 TEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) {
577 EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str());
578 }
579
580 #if !GTEST_WIDE_STRING_USES_UTF16_
581 // Tests that Unicode code-points that have 17 to 21 bits are encoded
582 // as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile
583 // on the systems using UTF-16 encoding.
TEST(WideStringToUtf8Test,CanEncode17To21Bits)584 TEST(WideStringToUtf8Test, CanEncode17To21Bits) {
585 // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011
586 EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str());
587 EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str());
588
589 // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100
590 EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str());
591 EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str());
592 }
593
594 // Tests that encoding an invalid code-point generates the expected result.
TEST(WideStringToUtf8Test,CanEncodeInvalidCodePoint)595 TEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) {
596 EXPECT_STREQ("(Invalid Unicode 0xABCDFF)",
597 WideStringToUtf8(L"\xABCDFF", -1).c_str());
598 }
599 #else // !GTEST_WIDE_STRING_USES_UTF16_
600 // Tests that surrogate pairs are encoded correctly on the systems using
601 // UTF-16 encoding in the wide strings.
TEST(WideStringToUtf8Test,CanEncodeValidUtf16SUrrogatePairs)602 TEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) {
603 const wchar_t s[] = { 0xD801, 0xDC00, '\0' };
604 EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str());
605 }
606
607 // Tests that encoding an invalid UTF-16 surrogate pair
608 // generates the expected result.
TEST(WideStringToUtf8Test,CanEncodeInvalidUtf16SurrogatePair)609 TEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) {
610 // Leading surrogate is at the end of the string.
611 const wchar_t s1[] = { 0xD800, '\0' };
612 EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str());
613 // Leading surrogate is not followed by the trailing surrogate.
614 const wchar_t s2[] = { 0xD800, 'M', '\0' };
615 EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str());
616 // Trailing surrogate appearas without a leading surrogate.
617 const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' };
618 EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str());
619 }
620 #endif // !GTEST_WIDE_STRING_USES_UTF16_
621
622 // Tests that codepoint concatenation works correctly.
623 #if !GTEST_WIDE_STRING_USES_UTF16_
TEST(WideStringToUtf8Test,ConcatenatesCodepointsCorrectly)624 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
625 const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'};
626 EXPECT_STREQ(
627 "\xF4\x88\x98\xB4"
628 "\xEC\x9D\x8D"
629 "\n"
630 "\xD5\xB6"
631 "\xE0\xA3\x93"
632 "\xF4\x88\x98\xB4",
633 WideStringToUtf8(s, -1).c_str());
634 }
635 #else
TEST(WideStringToUtf8Test,ConcatenatesCodepointsCorrectly)636 TEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) {
637 const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'};
638 EXPECT_STREQ(
639 "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93",
640 WideStringToUtf8(s, -1).c_str());
641 }
642 #endif // !GTEST_WIDE_STRING_USES_UTF16_
643
644 // Tests the Random class.
645
TEST(RandomDeathTest,GeneratesCrashesOnInvalidRange)646 TEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) {
647 testing::internal::Random random(42);
648 EXPECT_DEATH_IF_SUPPORTED(
649 random.Generate(0),
650 "Cannot generate a number in the range \\[0, 0\\)");
651 EXPECT_DEATH_IF_SUPPORTED(
652 random.Generate(testing::internal::Random::kMaxRange + 1),
653 "Generation of a number in \\[0, 2147483649\\) was requested, "
654 "but this can only generate numbers in \\[0, 2147483648\\)");
655 }
656
TEST(RandomTest,GeneratesNumbersWithinRange)657 TEST(RandomTest, GeneratesNumbersWithinRange) {
658 const UInt32 kRange = 10000;
659 testing::internal::Random random(12345);
660 for (int i = 0; i < 10; i++) {
661 EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i;
662 }
663
664 testing::internal::Random random2(testing::internal::Random::kMaxRange);
665 for (int i = 0; i < 10; i++) {
666 EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i;
667 }
668 }
669
TEST(RandomTest,RepeatsWhenReseeded)670 TEST(RandomTest, RepeatsWhenReseeded) {
671 const int kSeed = 123;
672 const int kArraySize = 10;
673 const UInt32 kRange = 10000;
674 UInt32 values[kArraySize];
675
676 testing::internal::Random random(kSeed);
677 for (int i = 0; i < kArraySize; i++) {
678 values[i] = random.Generate(kRange);
679 }
680
681 random.Reseed(kSeed);
682 for (int i = 0; i < kArraySize; i++) {
683 EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i;
684 }
685 }
686
687 // Tests STL container utilities.
688
689 // Tests CountIf().
690
IsPositive(int n)691 static bool IsPositive(int n) { return n > 0; }
692
TEST(ContainerUtilityTest,CountIf)693 TEST(ContainerUtilityTest, CountIf) {
694 std::vector<int> v;
695 EXPECT_EQ(0, CountIf(v, IsPositive)); // Works for an empty container.
696
697 v.push_back(-1);
698 v.push_back(0);
699 EXPECT_EQ(0, CountIf(v, IsPositive)); // Works when no value satisfies.
700
701 v.push_back(2);
702 v.push_back(-10);
703 v.push_back(10);
704 EXPECT_EQ(2, CountIf(v, IsPositive));
705 }
706
707 // Tests ForEach().
708
709 static int g_sum = 0;
Accumulate(int n)710 static void Accumulate(int n) { g_sum += n; }
711
TEST(ContainerUtilityTest,ForEach)712 TEST(ContainerUtilityTest, ForEach) {
713 std::vector<int> v;
714 g_sum = 0;
715 ForEach(v, Accumulate);
716 EXPECT_EQ(0, g_sum); // Works for an empty container;
717
718 g_sum = 0;
719 v.push_back(1);
720 ForEach(v, Accumulate);
721 EXPECT_EQ(1, g_sum); // Works for a container with one element.
722
723 g_sum = 0;
724 v.push_back(20);
725 v.push_back(300);
726 ForEach(v, Accumulate);
727 EXPECT_EQ(321, g_sum);
728 }
729
730 // Tests GetElementOr().
TEST(ContainerUtilityTest,GetElementOr)731 TEST(ContainerUtilityTest, GetElementOr) {
732 std::vector<char> a;
733 EXPECT_EQ('x', GetElementOr(a, 0, 'x'));
734
735 a.push_back('a');
736 a.push_back('b');
737 EXPECT_EQ('a', GetElementOr(a, 0, 'x'));
738 EXPECT_EQ('b', GetElementOr(a, 1, 'x'));
739 EXPECT_EQ('x', GetElementOr(a, -2, 'x'));
740 EXPECT_EQ('x', GetElementOr(a, 2, 'x'));
741 }
742
TEST(ContainerUtilityDeathTest,ShuffleRange)743 TEST(ContainerUtilityDeathTest, ShuffleRange) {
744 std::vector<int> a;
745 a.push_back(0);
746 a.push_back(1);
747 a.push_back(2);
748 testing::internal::Random random(1);
749
750 EXPECT_DEATH_IF_SUPPORTED(
751 ShuffleRange(&random, -1, 1, &a),
752 "Invalid shuffle range start -1: must be in range \\[0, 3\\]");
753 EXPECT_DEATH_IF_SUPPORTED(
754 ShuffleRange(&random, 4, 4, &a),
755 "Invalid shuffle range start 4: must be in range \\[0, 3\\]");
756 EXPECT_DEATH_IF_SUPPORTED(
757 ShuffleRange(&random, 3, 2, &a),
758 "Invalid shuffle range finish 2: must be in range \\[3, 3\\]");
759 EXPECT_DEATH_IF_SUPPORTED(
760 ShuffleRange(&random, 3, 4, &a),
761 "Invalid shuffle range finish 4: must be in range \\[3, 3\\]");
762 }
763
764 class VectorShuffleTest : public Test {
765 protected:
766 static const int kVectorSize = 20;
767
VectorShuffleTest()768 VectorShuffleTest() : random_(1) {
769 for (int i = 0; i < kVectorSize; i++) {
770 vector_.push_back(i);
771 }
772 }
773
VectorIsCorrupt(const TestingVector & vector)774 static bool VectorIsCorrupt(const TestingVector& vector) {
775 if (kVectorSize != static_cast<int>(vector.size())) {
776 return true;
777 }
778
779 bool found_in_vector[kVectorSize] = { false };
780 for (size_t i = 0; i < vector.size(); i++) {
781 const int e = vector[i];
782 if (e < 0 || e >= kVectorSize || found_in_vector[e]) {
783 return true;
784 }
785 found_in_vector[e] = true;
786 }
787
788 // Vector size is correct, elements' range is correct, no
789 // duplicate elements. Therefore no corruption has occurred.
790 return false;
791 }
792
VectorIsNotCorrupt(const TestingVector & vector)793 static bool VectorIsNotCorrupt(const TestingVector& vector) {
794 return !VectorIsCorrupt(vector);
795 }
796
RangeIsShuffled(const TestingVector & vector,int begin,int end)797 static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) {
798 for (int i = begin; i < end; i++) {
799 if (i != vector[i]) {
800 return true;
801 }
802 }
803 return false;
804 }
805
RangeIsUnshuffled(const TestingVector & vector,int begin,int end)806 static bool RangeIsUnshuffled(
807 const TestingVector& vector, int begin, int end) {
808 return !RangeIsShuffled(vector, begin, end);
809 }
810
VectorIsShuffled(const TestingVector & vector)811 static bool VectorIsShuffled(const TestingVector& vector) {
812 return RangeIsShuffled(vector, 0, static_cast<int>(vector.size()));
813 }
814
VectorIsUnshuffled(const TestingVector & vector)815 static bool VectorIsUnshuffled(const TestingVector& vector) {
816 return !VectorIsShuffled(vector);
817 }
818
819 testing::internal::Random random_;
820 TestingVector vector_;
821 }; // class VectorShuffleTest
822
823 const int VectorShuffleTest::kVectorSize;
824
TEST_F(VectorShuffleTest,HandlesEmptyRange)825 TEST_F(VectorShuffleTest, HandlesEmptyRange) {
826 // Tests an empty range at the beginning...
827 ShuffleRange(&random_, 0, 0, &vector_);
828 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
829 ASSERT_PRED1(VectorIsUnshuffled, vector_);
830
831 // ...in the middle...
832 ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_);
833 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
834 ASSERT_PRED1(VectorIsUnshuffled, vector_);
835
836 // ...at the end...
837 ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_);
838 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
839 ASSERT_PRED1(VectorIsUnshuffled, vector_);
840
841 // ...and past the end.
842 ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_);
843 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
844 ASSERT_PRED1(VectorIsUnshuffled, vector_);
845 }
846
TEST_F(VectorShuffleTest,HandlesRangeOfSizeOne)847 TEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) {
848 // Tests a size one range at the beginning...
849 ShuffleRange(&random_, 0, 1, &vector_);
850 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
851 ASSERT_PRED1(VectorIsUnshuffled, vector_);
852
853 // ...in the middle...
854 ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_);
855 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
856 ASSERT_PRED1(VectorIsUnshuffled, vector_);
857
858 // ...and at the end.
859 ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_);
860 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
861 ASSERT_PRED1(VectorIsUnshuffled, vector_);
862 }
863
864 // Because we use our own random number generator and a fixed seed,
865 // we can guarantee that the following "random" tests will succeed.
866
TEST_F(VectorShuffleTest,ShufflesEntireVector)867 TEST_F(VectorShuffleTest, ShufflesEntireVector) {
868 Shuffle(&random_, &vector_);
869 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
870 EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_;
871
872 // Tests the first and last elements in particular to ensure that
873 // there are no off-by-one problems in our shuffle algorithm.
874 EXPECT_NE(0, vector_[0]);
875 EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]);
876 }
877
TEST_F(VectorShuffleTest,ShufflesStartOfVector)878 TEST_F(VectorShuffleTest, ShufflesStartOfVector) {
879 const int kRangeSize = kVectorSize/2;
880
881 ShuffleRange(&random_, 0, kRangeSize, &vector_);
882
883 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
884 EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize);
885 EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize);
886 }
887
TEST_F(VectorShuffleTest,ShufflesEndOfVector)888 TEST_F(VectorShuffleTest, ShufflesEndOfVector) {
889 const int kRangeSize = kVectorSize / 2;
890 ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_);
891
892 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
893 EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
894 EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize);
895 }
896
TEST_F(VectorShuffleTest,ShufflesMiddleOfVector)897 TEST_F(VectorShuffleTest, ShufflesMiddleOfVector) {
898 int kRangeSize = kVectorSize/3;
899 ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_);
900
901 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
902 EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize);
903 EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize);
904 EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize);
905 }
906
TEST_F(VectorShuffleTest,ShufflesRepeatably)907 TEST_F(VectorShuffleTest, ShufflesRepeatably) {
908 TestingVector vector2;
909 for (int i = 0; i < kVectorSize; i++) {
910 vector2.push_back(i);
911 }
912
913 random_.Reseed(1234);
914 Shuffle(&random_, &vector_);
915 random_.Reseed(1234);
916 Shuffle(&random_, &vector2);
917
918 ASSERT_PRED1(VectorIsNotCorrupt, vector_);
919 ASSERT_PRED1(VectorIsNotCorrupt, vector2);
920
921 for (int i = 0; i < kVectorSize; i++) {
922 EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i;
923 }
924 }
925
926 // Tests the size of the AssertHelper class.
927
TEST(AssertHelperTest,AssertHelperIsSmall)928 TEST(AssertHelperTest, AssertHelperIsSmall) {
929 // To avoid breaking clients that use lots of assertions in one
930 // function, we cannot grow the size of AssertHelper.
931 EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*));
932 }
933
934 // Tests String::EndsWithCaseInsensitive().
TEST(StringTest,EndsWithCaseInsensitive)935 TEST(StringTest, EndsWithCaseInsensitive) {
936 EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR"));
937 EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar"));
938 EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", ""));
939 EXPECT_TRUE(String::EndsWithCaseInsensitive("", ""));
940
941 EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo"));
942 EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo"));
943 EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo"));
944 }
945
946 // C++Builder's preprocessor is buggy; it fails to expand macros that
947 // appear in macro parameters after wide char literals. Provide an alias
948 // for NULL as a workaround.
949 static const wchar_t* const kNull = NULL;
950
951 // Tests String::CaseInsensitiveWideCStringEquals
TEST(StringTest,CaseInsensitiveWideCStringEquals)952 TEST(StringTest, CaseInsensitiveWideCStringEquals) {
953 EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL));
954 EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L""));
955 EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull));
956 EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar"));
957 EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull));
958 EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar"));
959 EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR"));
960 EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
961 }
962
963 // Tests that String::Format() works.
TEST(StringTest,FormatWorks)964 TEST(StringTest, FormatWorks) {
965 // Normal case: the format spec is valid, the arguments match the
966 // spec, and the result is < 4095 characters.
967 EXPECT_STREQ("Hello, 42", String::Format("%s, %d", "Hello", 42).c_str());
968
969 // Edge case: the result is 4095 characters.
970 char buffer[4096];
971 const size_t kSize = sizeof(buffer);
972 memset(buffer, 'a', kSize - 1);
973 buffer[kSize - 1] = '\0';
974 EXPECT_EQ(buffer, String::Format("%s", buffer));
975
976 // The result needs to be 4096 characters, exceeding Format()'s limit.
977 EXPECT_EQ("<formatting error or buffer exceeded>",
978 String::Format("x%s", buffer));
979
980 #if GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
981 // On Linux, invalid format spec should lead to an error message.
982 // In other environment (e.g. MSVC on Windows), String::Format() may
983 // simply ignore a bad format spec, so this assertion is run on
984 // Linux only.
985 EXPECT_EQ("<formatting error or buffer exceeded>",
986 String::Format("%"));
987 #endif
988 }
989
990 #if GTEST_OS_WINDOWS
991
992 // Tests String::ShowWideCString().
TEST(StringTest,ShowWideCString)993 TEST(StringTest, ShowWideCString) {
994 EXPECT_STREQ("(null)",
995 String::ShowWideCString(NULL).c_str());
996 EXPECT_STREQ("", String::ShowWideCString(L"").c_str());
997 EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
998 }
999
1000 # if GTEST_OS_WINDOWS_MOBILE
TEST(StringTest,AnsiAndUtf16Null)1001 TEST(StringTest, AnsiAndUtf16Null) {
1002 EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
1003 EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
1004 }
1005
TEST(StringTest,AnsiAndUtf16ConvertBasic)1006 TEST(StringTest, AnsiAndUtf16ConvertBasic) {
1007 const char* ansi = String::Utf16ToAnsi(L"str");
1008 EXPECT_STREQ("str", ansi);
1009 delete [] ansi;
1010 const WCHAR* utf16 = String::AnsiToUtf16("str");
1011 EXPECT_EQ(0, wcsncmp(L"str", utf16, 3));
1012 delete [] utf16;
1013 }
1014
TEST(StringTest,AnsiAndUtf16ConvertPathChars)1015 TEST(StringTest, AnsiAndUtf16ConvertPathChars) {
1016 const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?");
1017 EXPECT_STREQ(".:\\ \"*?", ansi);
1018 delete [] ansi;
1019 const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?");
1020 EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3));
1021 delete [] utf16;
1022 }
1023 # endif // GTEST_OS_WINDOWS_MOBILE
1024
1025 #endif // GTEST_OS_WINDOWS
1026
1027 // Tests TestProperty construction.
TEST(TestPropertyTest,StringValue)1028 TEST(TestPropertyTest, StringValue) {
1029 TestProperty property("key", "1");
1030 EXPECT_STREQ("key", property.key());
1031 EXPECT_STREQ("1", property.value());
1032 }
1033
1034 // Tests TestProperty replacing a value.
TEST(TestPropertyTest,ReplaceStringValue)1035 TEST(TestPropertyTest, ReplaceStringValue) {
1036 TestProperty property("key", "1");
1037 EXPECT_STREQ("1", property.value());
1038 property.SetValue("2");
1039 EXPECT_STREQ("2", property.value());
1040 }
1041
1042 // AddFatalFailure() and AddNonfatalFailure() must be stand-alone
1043 // functions (i.e. their definitions cannot be inlined at the call
1044 // sites), or C++Builder won't compile the code.
AddFatalFailure()1045 static void AddFatalFailure() {
1046 FAIL() << "Expected fatal failure.";
1047 }
1048
AddNonfatalFailure()1049 static void AddNonfatalFailure() {
1050 ADD_FAILURE() << "Expected non-fatal failure.";
1051 }
1052
1053 class ScopedFakeTestPartResultReporterTest : public Test {
1054 public: // Must be public and not protected due to a bug in g++ 3.4.2.
1055 enum FailureMode {
1056 FATAL_FAILURE,
1057 NONFATAL_FAILURE
1058 };
AddFailure(FailureMode failure)1059 static void AddFailure(FailureMode failure) {
1060 if (failure == FATAL_FAILURE) {
1061 AddFatalFailure();
1062 } else {
1063 AddNonfatalFailure();
1064 }
1065 }
1066 };
1067
1068 // Tests that ScopedFakeTestPartResultReporter intercepts test
1069 // failures.
TEST_F(ScopedFakeTestPartResultReporterTest,InterceptsTestFailures)1070 TEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) {
1071 TestPartResultArray results;
1072 {
1073 ScopedFakeTestPartResultReporter reporter(
1074 ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD,
1075 &results);
1076 AddFailure(NONFATAL_FAILURE);
1077 AddFailure(FATAL_FAILURE);
1078 }
1079
1080 EXPECT_EQ(2, results.size());
1081 EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
1082 EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
1083 }
1084
TEST_F(ScopedFakeTestPartResultReporterTest,DeprecatedConstructor)1085 TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
1086 TestPartResultArray results;
1087 {
1088 // Tests, that the deprecated constructor still works.
1089 ScopedFakeTestPartResultReporter reporter(&results);
1090 AddFailure(NONFATAL_FAILURE);
1091 }
1092 EXPECT_EQ(1, results.size());
1093 }
1094
1095 #if GTEST_IS_THREADSAFE
1096
1097 class ScopedFakeTestPartResultReporterWithThreadsTest
1098 : public ScopedFakeTestPartResultReporterTest {
1099 protected:
AddFailureInOtherThread(FailureMode failure)1100 static void AddFailureInOtherThread(FailureMode failure) {
1101 ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL);
1102 thread.Join();
1103 }
1104 };
1105
TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,InterceptsTestFailuresInAllThreads)1106 TEST_F(ScopedFakeTestPartResultReporterWithThreadsTest,
1107 InterceptsTestFailuresInAllThreads) {
1108 TestPartResultArray results;
1109 {
1110 ScopedFakeTestPartResultReporter reporter(
1111 ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results);
1112 AddFailure(NONFATAL_FAILURE);
1113 AddFailure(FATAL_FAILURE);
1114 AddFailureInOtherThread(NONFATAL_FAILURE);
1115 AddFailureInOtherThread(FATAL_FAILURE);
1116 }
1117
1118 EXPECT_EQ(4, results.size());
1119 EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed());
1120 EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed());
1121 EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed());
1122 EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed());
1123 }
1124
1125 #endif // GTEST_IS_THREADSAFE
1126
1127 // Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they
1128 // work even if the failure is generated in a called function rather than
1129 // the current context.
1130
1131 typedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest;
1132
TEST_F(ExpectFatalFailureTest,CatchesFatalFaliure)1133 TEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) {
1134 EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure.");
1135 }
1136
1137 #if GTEST_HAS_GLOBAL_STRING
TEST_F(ExpectFatalFailureTest,AcceptsStringObject)1138 TEST_F(ExpectFatalFailureTest, AcceptsStringObject) {
1139 EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure."));
1140 }
1141 #endif
1142
TEST_F(ExpectFatalFailureTest,AcceptsStdStringObject)1143 TEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) {
1144 EXPECT_FATAL_FAILURE(AddFatalFailure(),
1145 ::std::string("Expected fatal failure."));
1146 }
1147
TEST_F(ExpectFatalFailureTest,CatchesFatalFailureOnAllThreads)1148 TEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) {
1149 // We have another test below to verify that the macro catches fatal
1150 // failures generated on another thread.
1151 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(),
1152 "Expected fatal failure.");
1153 }
1154
1155 #ifdef __BORLANDC__
1156 // Silences warnings: "Condition is always true"
1157 # pragma option push -w-ccc
1158 #endif
1159
1160 // Tests that EXPECT_FATAL_FAILURE() can be used in a non-void
1161 // function even when the statement in it contains ASSERT_*.
1162
NonVoidFunction()1163 int NonVoidFunction() {
1164 EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
1165 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
1166 return 0;
1167 }
1168
TEST_F(ExpectFatalFailureTest,CanBeUsedInNonVoidFunction)1169 TEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) {
1170 NonVoidFunction();
1171 }
1172
1173 // Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the
1174 // current function even though 'statement' generates a fatal failure.
1175
DoesNotAbortHelper(bool * aborted)1176 void DoesNotAbortHelper(bool* aborted) {
1177 EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), "");
1178 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), "");
1179
1180 *aborted = false;
1181 }
1182
1183 #ifdef __BORLANDC__
1184 // Restores warnings after previous "#pragma option push" suppressed them.
1185 # pragma option pop
1186 #endif
1187
TEST_F(ExpectFatalFailureTest,DoesNotAbort)1188 TEST_F(ExpectFatalFailureTest, DoesNotAbort) {
1189 bool aborted = true;
1190 DoesNotAbortHelper(&aborted);
1191 EXPECT_FALSE(aborted);
1192 }
1193
1194 // Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a
1195 // statement that contains a macro which expands to code containing an
1196 // unprotected comma.
1197
1198 static int global_var = 0;
1199 #define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++
1200
TEST_F(ExpectFatalFailureTest,AcceptsMacroThatExpandsToUnprotectedComma)1201 TEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
1202 #ifndef __BORLANDC__
1203 // ICE's in C++Builder.
1204 EXPECT_FATAL_FAILURE({
1205 GTEST_USE_UNPROTECTED_COMMA_;
1206 AddFatalFailure();
1207 }, "");
1208 #endif
1209
1210 EXPECT_FATAL_FAILURE_ON_ALL_THREADS({
1211 GTEST_USE_UNPROTECTED_COMMA_;
1212 AddFatalFailure();
1213 }, "");
1214 }
1215
1216 // Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}.
1217
1218 typedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest;
1219
TEST_F(ExpectNonfatalFailureTest,CatchesNonfatalFailure)1220 TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) {
1221 EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1222 "Expected non-fatal failure.");
1223 }
1224
1225 #if GTEST_HAS_GLOBAL_STRING
TEST_F(ExpectNonfatalFailureTest,AcceptsStringObject)1226 TEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) {
1227 EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1228 ::string("Expected non-fatal failure."));
1229 }
1230 #endif
1231
TEST_F(ExpectNonfatalFailureTest,AcceptsStdStringObject)1232 TEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) {
1233 EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(),
1234 ::std::string("Expected non-fatal failure."));
1235 }
1236
TEST_F(ExpectNonfatalFailureTest,CatchesNonfatalFailureOnAllThreads)1237 TEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) {
1238 // We have another test below to verify that the macro catches
1239 // non-fatal failures generated on another thread.
1240 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(),
1241 "Expected non-fatal failure.");
1242 }
1243
1244 // Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a
1245 // statement that contains a macro which expands to code containing an
1246 // unprotected comma.
TEST_F(ExpectNonfatalFailureTest,AcceptsMacroThatExpandsToUnprotectedComma)1247 TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
1248 EXPECT_NONFATAL_FAILURE({
1249 GTEST_USE_UNPROTECTED_COMMA_;
1250 AddNonfatalFailure();
1251 }, "");
1252
1253 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({
1254 GTEST_USE_UNPROTECTED_COMMA_;
1255 AddNonfatalFailure();
1256 }, "");
1257 }
1258
1259 #if GTEST_IS_THREADSAFE
1260
1261 typedef ScopedFakeTestPartResultReporterWithThreadsTest
1262 ExpectFailureWithThreadsTest;
1263
TEST_F(ExpectFailureWithThreadsTest,ExpectFatalFailureOnAllThreads)1264 TEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) {
1265 EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE),
1266 "Expected fatal failure.");
1267 }
1268
TEST_F(ExpectFailureWithThreadsTest,ExpectNonFatalFailureOnAllThreads)1269 TEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) {
1270 EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(
1271 AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure.");
1272 }
1273
1274 #endif // GTEST_IS_THREADSAFE
1275
1276 // Tests the TestProperty class.
1277
TEST(TestPropertyTest,ConstructorWorks)1278 TEST(TestPropertyTest, ConstructorWorks) {
1279 const TestProperty property("key", "value");
1280 EXPECT_STREQ("key", property.key());
1281 EXPECT_STREQ("value", property.value());
1282 }
1283
TEST(TestPropertyTest,SetValue)1284 TEST(TestPropertyTest, SetValue) {
1285 TestProperty property("key", "value_1");
1286 EXPECT_STREQ("key", property.key());
1287 property.SetValue("value_2");
1288 EXPECT_STREQ("key", property.key());
1289 EXPECT_STREQ("value_2", property.value());
1290 }
1291
1292 // Tests the TestResult class
1293
1294 // The test fixture for testing TestResult.
1295 class TestResultTest : public Test {
1296 protected:
1297 typedef std::vector<TestPartResult> TPRVector;
1298
1299 // We make use of 2 TestPartResult objects,
1300 TestPartResult * pr1, * pr2;
1301
1302 // ... and 3 TestResult objects.
1303 TestResult * r0, * r1, * r2;
1304
SetUp()1305 virtual void SetUp() {
1306 // pr1 is for success.
1307 pr1 = new TestPartResult(TestPartResult::kSuccess,
1308 "foo/bar.cc",
1309 10,
1310 "Success!");
1311
1312 // pr2 is for fatal failure.
1313 pr2 = new TestPartResult(TestPartResult::kFatalFailure,
1314 "foo/bar.cc",
1315 -1, // This line number means "unknown"
1316 "Failure!");
1317
1318 // Creates the TestResult objects.
1319 r0 = new TestResult();
1320 r1 = new TestResult();
1321 r2 = new TestResult();
1322
1323 // In order to test TestResult, we need to modify its internal
1324 // state, in particular the TestPartResult vector it holds.
1325 // test_part_results() returns a const reference to this vector.
1326 // We cast it to a non-const object s.t. it can be modified (yes,
1327 // this is a hack).
1328 TPRVector* results1 = const_cast<TPRVector*>(
1329 &TestResultAccessor::test_part_results(*r1));
1330 TPRVector* results2 = const_cast<TPRVector*>(
1331 &TestResultAccessor::test_part_results(*r2));
1332
1333 // r0 is an empty TestResult.
1334
1335 // r1 contains a single SUCCESS TestPartResult.
1336 results1->push_back(*pr1);
1337
1338 // r2 contains a SUCCESS, and a FAILURE.
1339 results2->push_back(*pr1);
1340 results2->push_back(*pr2);
1341 }
1342
TearDown()1343 virtual void TearDown() {
1344 delete pr1;
1345 delete pr2;
1346
1347 delete r0;
1348 delete r1;
1349 delete r2;
1350 }
1351
1352 // Helper that compares two two TestPartResults.
CompareTestPartResult(const TestPartResult & expected,const TestPartResult & actual)1353 static void CompareTestPartResult(const TestPartResult& expected,
1354 const TestPartResult& actual) {
1355 EXPECT_EQ(expected.type(), actual.type());
1356 EXPECT_STREQ(expected.file_name(), actual.file_name());
1357 EXPECT_EQ(expected.line_number(), actual.line_number());
1358 EXPECT_STREQ(expected.summary(), actual.summary());
1359 EXPECT_STREQ(expected.message(), actual.message());
1360 EXPECT_EQ(expected.passed(), actual.passed());
1361 EXPECT_EQ(expected.failed(), actual.failed());
1362 EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed());
1363 EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed());
1364 }
1365 };
1366
1367 // Tests TestResult::total_part_count().
TEST_F(TestResultTest,total_part_count)1368 TEST_F(TestResultTest, total_part_count) {
1369 ASSERT_EQ(0, r0->total_part_count());
1370 ASSERT_EQ(1, r1->total_part_count());
1371 ASSERT_EQ(2, r2->total_part_count());
1372 }
1373
1374 // Tests TestResult::Passed().
TEST_F(TestResultTest,Passed)1375 TEST_F(TestResultTest, Passed) {
1376 ASSERT_TRUE(r0->Passed());
1377 ASSERT_TRUE(r1->Passed());
1378 ASSERT_FALSE(r2->Passed());
1379 }
1380
1381 // Tests TestResult::Failed().
TEST_F(TestResultTest,Failed)1382 TEST_F(TestResultTest, Failed) {
1383 ASSERT_FALSE(r0->Failed());
1384 ASSERT_FALSE(r1->Failed());
1385 ASSERT_TRUE(r2->Failed());
1386 }
1387
1388 // Tests TestResult::GetTestPartResult().
1389
1390 typedef TestResultTest TestResultDeathTest;
1391
TEST_F(TestResultDeathTest,GetTestPartResult)1392 TEST_F(TestResultDeathTest, GetTestPartResult) {
1393 CompareTestPartResult(*pr1, r2->GetTestPartResult(0));
1394 CompareTestPartResult(*pr2, r2->GetTestPartResult(1));
1395 EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), "");
1396 EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), "");
1397 }
1398
1399 // Tests TestResult has no properties when none are added.
TEST(TestResultPropertyTest,NoPropertiesFoundWhenNoneAreAdded)1400 TEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) {
1401 TestResult test_result;
1402 ASSERT_EQ(0, test_result.test_property_count());
1403 }
1404
1405 // Tests TestResult has the expected property when added.
TEST(TestResultPropertyTest,OnePropertyFoundWhenAdded)1406 TEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) {
1407 TestResult test_result;
1408 TestProperty property("key_1", "1");
1409 TestResultAccessor::RecordProperty(&test_result, property);
1410 ASSERT_EQ(1, test_result.test_property_count());
1411 const TestProperty& actual_property = test_result.GetTestProperty(0);
1412 EXPECT_STREQ("key_1", actual_property.key());
1413 EXPECT_STREQ("1", actual_property.value());
1414 }
1415
1416 // Tests TestResult has multiple properties when added.
TEST(TestResultPropertyTest,MultiplePropertiesFoundWhenAdded)1417 TEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) {
1418 TestResult test_result;
1419 TestProperty property_1("key_1", "1");
1420 TestProperty property_2("key_2", "2");
1421 TestResultAccessor::RecordProperty(&test_result, property_1);
1422 TestResultAccessor::RecordProperty(&test_result, property_2);
1423 ASSERT_EQ(2, test_result.test_property_count());
1424 const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
1425 EXPECT_STREQ("key_1", actual_property_1.key());
1426 EXPECT_STREQ("1", actual_property_1.value());
1427
1428 const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
1429 EXPECT_STREQ("key_2", actual_property_2.key());
1430 EXPECT_STREQ("2", actual_property_2.value());
1431 }
1432
1433 // Tests TestResult::RecordProperty() overrides values for duplicate keys.
TEST(TestResultPropertyTest,OverridesValuesForDuplicateKeys)1434 TEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) {
1435 TestResult test_result;
1436 TestProperty property_1_1("key_1", "1");
1437 TestProperty property_2_1("key_2", "2");
1438 TestProperty property_1_2("key_1", "12");
1439 TestProperty property_2_2("key_2", "22");
1440 TestResultAccessor::RecordProperty(&test_result, property_1_1);
1441 TestResultAccessor::RecordProperty(&test_result, property_2_1);
1442 TestResultAccessor::RecordProperty(&test_result, property_1_2);
1443 TestResultAccessor::RecordProperty(&test_result, property_2_2);
1444
1445 ASSERT_EQ(2, test_result.test_property_count());
1446 const TestProperty& actual_property_1 = test_result.GetTestProperty(0);
1447 EXPECT_STREQ("key_1", actual_property_1.key());
1448 EXPECT_STREQ("12", actual_property_1.value());
1449
1450 const TestProperty& actual_property_2 = test_result.GetTestProperty(1);
1451 EXPECT_STREQ("key_2", actual_property_2.key());
1452 EXPECT_STREQ("22", actual_property_2.value());
1453 }
1454
1455 // Tests TestResult::GetTestProperty().
TEST(TestResultPropertyDeathTest,GetTestProperty)1456 TEST(TestResultPropertyDeathTest, GetTestProperty) {
1457 TestResult test_result;
1458 TestProperty property_1("key_1", "1");
1459 TestProperty property_2("key_2", "2");
1460 TestProperty property_3("key_3", "3");
1461 TestResultAccessor::RecordProperty(&test_result, property_1);
1462 TestResultAccessor::RecordProperty(&test_result, property_2);
1463 TestResultAccessor::RecordProperty(&test_result, property_3);
1464
1465 const TestProperty& fetched_property_1 = test_result.GetTestProperty(0);
1466 const TestProperty& fetched_property_2 = test_result.GetTestProperty(1);
1467 const TestProperty& fetched_property_3 = test_result.GetTestProperty(2);
1468
1469 EXPECT_STREQ("key_1", fetched_property_1.key());
1470 EXPECT_STREQ("1", fetched_property_1.value());
1471
1472 EXPECT_STREQ("key_2", fetched_property_2.key());
1473 EXPECT_STREQ("2", fetched_property_2.value());
1474
1475 EXPECT_STREQ("key_3", fetched_property_3.key());
1476 EXPECT_STREQ("3", fetched_property_3.value());
1477
1478 EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), "");
1479 EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), "");
1480 }
1481
1482 // When a property using a reserved key is supplied to this function, it tests
1483 // that a non-fatal failure is added, a fatal failure is not added, and that the
1484 // property is not recorded.
ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char * key)1485 void ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) {
1486 TestResult test_result;
1487 TestProperty property(key, "1");
1488 EXPECT_NONFATAL_FAILURE(
1489 TestResultAccessor::RecordProperty(&test_result, property),
1490 "Reserved key");
1491 ASSERT_EQ(0, test_result.test_property_count()) << "Not recorded";
1492 }
1493
1494 // Attempting to recording a property with the Reserved literal "name"
1495 // should add a non-fatal failure and the property should not be recorded.
TEST(TestResultPropertyTest,AddFailureWhenUsingReservedKeyCalledName)1496 TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) {
1497 ExpectNonFatalFailureRecordingPropertyWithReservedKey("name");
1498 }
1499
1500 // Attempting to recording a property with the Reserved literal "status"
1501 // should add a non-fatal failure and the property should not be recorded.
TEST(TestResultPropertyTest,AddFailureWhenUsingReservedKeyCalledStatus)1502 TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) {
1503 ExpectNonFatalFailureRecordingPropertyWithReservedKey("status");
1504 }
1505
1506 // Attempting to recording a property with the Reserved literal "time"
1507 // should add a non-fatal failure and the property should not be recorded.
TEST(TestResultPropertyTest,AddFailureWhenUsingReservedKeyCalledTime)1508 TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) {
1509 ExpectNonFatalFailureRecordingPropertyWithReservedKey("time");
1510 }
1511
1512 // Attempting to recording a property with the Reserved literal "classname"
1513 // should add a non-fatal failure and the property should not be recorded.
TEST(TestResultPropertyTest,AddFailureWhenUsingReservedKeyCalledClassname)1514 TEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) {
1515 ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname");
1516 }
1517
1518 // Tests that GTestFlagSaver works on Windows and Mac.
1519
1520 class GTestFlagSaverTest : public Test {
1521 protected:
1522 // Saves the Google Test flags such that we can restore them later, and
1523 // then sets them to their default values. This will be called
1524 // before the first test in this test case is run.
SetUpTestCase()1525 static void SetUpTestCase() {
1526 saver_ = new GTestFlagSaver;
1527
1528 GTEST_FLAG(also_run_disabled_tests) = false;
1529 GTEST_FLAG(break_on_failure) = false;
1530 GTEST_FLAG(catch_exceptions) = false;
1531 GTEST_FLAG(death_test_use_fork) = false;
1532 GTEST_FLAG(color) = "auto";
1533 GTEST_FLAG(filter) = "";
1534 GTEST_FLAG(list_tests) = false;
1535 GTEST_FLAG(output) = "";
1536 GTEST_FLAG(print_time) = true;
1537 GTEST_FLAG(random_seed) = 0;
1538 GTEST_FLAG(repeat) = 1;
1539 GTEST_FLAG(shuffle) = false;
1540 GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
1541 GTEST_FLAG(stream_result_to) = "";
1542 GTEST_FLAG(throw_on_failure) = false;
1543 }
1544
1545 // Restores the Google Test flags that the tests have modified. This will
1546 // be called after the last test in this test case is run.
TearDownTestCase()1547 static void TearDownTestCase() {
1548 delete saver_;
1549 saver_ = NULL;
1550 }
1551
1552 // Verifies that the Google Test flags have their default values, and then
1553 // modifies each of them.
VerifyAndModifyFlags()1554 void VerifyAndModifyFlags() {
1555 EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests));
1556 EXPECT_FALSE(GTEST_FLAG(break_on_failure));
1557 EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
1558 EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
1559 EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
1560 EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
1561 EXPECT_FALSE(GTEST_FLAG(list_tests));
1562 EXPECT_STREQ("", GTEST_FLAG(output).c_str());
1563 EXPECT_TRUE(GTEST_FLAG(print_time));
1564 EXPECT_EQ(0, GTEST_FLAG(random_seed));
1565 EXPECT_EQ(1, GTEST_FLAG(repeat));
1566 EXPECT_FALSE(GTEST_FLAG(shuffle));
1567 EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth));
1568 EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str());
1569 EXPECT_FALSE(GTEST_FLAG(throw_on_failure));
1570
1571 GTEST_FLAG(also_run_disabled_tests) = true;
1572 GTEST_FLAG(break_on_failure) = true;
1573 GTEST_FLAG(catch_exceptions) = true;
1574 GTEST_FLAG(color) = "no";
1575 GTEST_FLAG(death_test_use_fork) = true;
1576 GTEST_FLAG(filter) = "abc";
1577 GTEST_FLAG(list_tests) = true;
1578 GTEST_FLAG(output) = "xml:foo.xml";
1579 GTEST_FLAG(print_time) = false;
1580 GTEST_FLAG(random_seed) = 1;
1581 GTEST_FLAG(repeat) = 100;
1582 GTEST_FLAG(shuffle) = true;
1583 GTEST_FLAG(stack_trace_depth) = 1;
1584 GTEST_FLAG(stream_result_to) = "localhost:1234";
1585 GTEST_FLAG(throw_on_failure) = true;
1586 }
1587
1588 private:
1589 // For saving Google Test flags during this test case.
1590 static GTestFlagSaver* saver_;
1591 };
1592
1593 GTestFlagSaver* GTestFlagSaverTest::saver_ = NULL;
1594
1595 // Google Test doesn't guarantee the order of tests. The following two
1596 // tests are designed to work regardless of their order.
1597
1598 // Modifies the Google Test flags in the test body.
TEST_F(GTestFlagSaverTest,ModifyGTestFlags)1599 TEST_F(GTestFlagSaverTest, ModifyGTestFlags) {
1600 VerifyAndModifyFlags();
1601 }
1602
1603 // Verifies that the Google Test flags in the body of the previous test were
1604 // restored to their original values.
TEST_F(GTestFlagSaverTest,VerifyGTestFlags)1605 TEST_F(GTestFlagSaverTest, VerifyGTestFlags) {
1606 VerifyAndModifyFlags();
1607 }
1608
1609 // Sets an environment variable with the given name to the given
1610 // value. If the value argument is "", unsets the environment
1611 // variable. The caller must ensure that both arguments are not NULL.
SetEnv(const char * name,const char * value)1612 static void SetEnv(const char* name, const char* value) {
1613 #if GTEST_OS_WINDOWS_MOBILE
1614 // Environment variables are not supported on Windows CE.
1615 return;
1616 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
1617 // C++Builder's putenv only stores a pointer to its parameter; we have to
1618 // ensure that the string remains valid as long as it might be needed.
1619 // We use an std::map to do so.
1620 static std::map<std::string, std::string*> added_env;
1621
1622 // Because putenv stores a pointer to the string buffer, we can't delete the
1623 // previous string (if present) until after it's replaced.
1624 std::string *prev_env = NULL;
1625 if (added_env.find(name) != added_env.end()) {
1626 prev_env = added_env[name];
1627 }
1628 added_env[name] = new std::string(
1629 (Message() << name << "=" << value).GetString());
1630
1631 // The standard signature of putenv accepts a 'char*' argument. Other
1632 // implementations, like C++Builder's, accept a 'const char*'.
1633 // We cast away the 'const' since that would work for both variants.
1634 putenv(const_cast<char*>(added_env[name]->c_str()));
1635 delete prev_env;
1636 #elif GTEST_OS_WINDOWS // If we are on Windows proper.
1637 _putenv((Message() << name << "=" << value).GetString().c_str());
1638 #else
1639 if (*value == '\0') {
1640 unsetenv(name);
1641 } else {
1642 setenv(name, value, 1);
1643 }
1644 #endif // GTEST_OS_WINDOWS_MOBILE
1645 }
1646
1647 #if !GTEST_OS_WINDOWS_MOBILE
1648 // Environment variables are not supported on Windows CE.
1649
1650 using testing::internal::Int32FromGTestEnv;
1651
1652 // Tests Int32FromGTestEnv().
1653
1654 // Tests that Int32FromGTestEnv() returns the default value when the
1655 // environment variable is not set.
TEST(Int32FromGTestEnvTest,ReturnsDefaultWhenVariableIsNotSet)1656 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) {
1657 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "");
1658 EXPECT_EQ(10, Int32FromGTestEnv("temp", 10));
1659 }
1660
1661 // Tests that Int32FromGTestEnv() returns the default value when the
1662 // environment variable overflows as an Int32.
TEST(Int32FromGTestEnvTest,ReturnsDefaultWhenValueOverflows)1663 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) {
1664 printf("(expecting 2 warnings)\n");
1665
1666 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321");
1667 EXPECT_EQ(20, Int32FromGTestEnv("temp", 20));
1668
1669 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321");
1670 EXPECT_EQ(30, Int32FromGTestEnv("temp", 30));
1671 }
1672
1673 // Tests that Int32FromGTestEnv() returns the default value when the
1674 // environment variable does not represent a valid decimal integer.
TEST(Int32FromGTestEnvTest,ReturnsDefaultWhenValueIsInvalid)1675 TEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) {
1676 printf("(expecting 2 warnings)\n");
1677
1678 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1");
1679 EXPECT_EQ(40, Int32FromGTestEnv("temp", 40));
1680
1681 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X");
1682 EXPECT_EQ(50, Int32FromGTestEnv("temp", 50));
1683 }
1684
1685 // Tests that Int32FromGTestEnv() parses and returns the value of the
1686 // environment variable when it represents a valid decimal integer in
1687 // the range of an Int32.
TEST(Int32FromGTestEnvTest,ParsesAndReturnsValidValue)1688 TEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) {
1689 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123");
1690 EXPECT_EQ(123, Int32FromGTestEnv("temp", 0));
1691
1692 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321");
1693 EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0));
1694 }
1695 #endif // !GTEST_OS_WINDOWS_MOBILE
1696
1697 // Tests ParseInt32Flag().
1698
1699 // Tests that ParseInt32Flag() returns false and doesn't change the
1700 // output value when the flag has wrong format
TEST(ParseInt32FlagTest,ReturnsFalseForInvalidFlag)1701 TEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) {
1702 Int32 value = 123;
1703 EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value));
1704 EXPECT_EQ(123, value);
1705
1706 EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value));
1707 EXPECT_EQ(123, value);
1708 }
1709
1710 // Tests that ParseInt32Flag() returns false and doesn't change the
1711 // output value when the flag overflows as an Int32.
TEST(ParseInt32FlagTest,ReturnsDefaultWhenValueOverflows)1712 TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) {
1713 printf("(expecting 2 warnings)\n");
1714
1715 Int32 value = 123;
1716 EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value));
1717 EXPECT_EQ(123, value);
1718
1719 EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value));
1720 EXPECT_EQ(123, value);
1721 }
1722
1723 // Tests that ParseInt32Flag() returns false and doesn't change the
1724 // output value when the flag does not represent a valid decimal
1725 // integer.
TEST(ParseInt32FlagTest,ReturnsDefaultWhenValueIsInvalid)1726 TEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) {
1727 printf("(expecting 2 warnings)\n");
1728
1729 Int32 value = 123;
1730 EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value));
1731 EXPECT_EQ(123, value);
1732
1733 EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value));
1734 EXPECT_EQ(123, value);
1735 }
1736
1737 // Tests that ParseInt32Flag() parses the value of the flag and
1738 // returns true when the flag represents a valid decimal integer in
1739 // the range of an Int32.
TEST(ParseInt32FlagTest,ParsesAndReturnsValidValue)1740 TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
1741 Int32 value = 123;
1742 EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value));
1743 EXPECT_EQ(456, value);
1744
1745 EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789",
1746 "abc", &value));
1747 EXPECT_EQ(-789, value);
1748 }
1749
1750 // Tests that Int32FromEnvOrDie() parses the value of the var or
1751 // returns the correct default.
1752 // Environment variables are not supported on Windows CE.
1753 #if !GTEST_OS_WINDOWS_MOBILE
TEST(Int32FromEnvOrDieTest,ParsesAndReturnsValidValue)1754 TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
1755 EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1756 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
1757 EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1758 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123");
1759 EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
1760 }
1761 #endif // !GTEST_OS_WINDOWS_MOBILE
1762
1763 // Tests that Int32FromEnvOrDie() aborts with an error message
1764 // if the variable is not an Int32.
TEST(Int32FromEnvOrDieDeathTest,AbortsOnFailure)1765 TEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) {
1766 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx");
1767 EXPECT_DEATH_IF_SUPPORTED(
1768 Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
1769 ".*");
1770 }
1771
1772 // Tests that Int32FromEnvOrDie() aborts with an error message
1773 // if the variable cannot be represnted by an Int32.
TEST(Int32FromEnvOrDieDeathTest,AbortsOnInt32Overflow)1774 TEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) {
1775 SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234");
1776 EXPECT_DEATH_IF_SUPPORTED(
1777 Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123),
1778 ".*");
1779 }
1780
1781 // Tests that ShouldRunTestOnShard() selects all tests
1782 // where there is 1 shard.
TEST(ShouldRunTestOnShardTest,IsPartitionWhenThereIsOneShard)1783 TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) {
1784 EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0));
1785 EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1));
1786 EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2));
1787 EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3));
1788 EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4));
1789 }
1790
1791 class ShouldShardTest : public testing::Test {
1792 protected:
SetUp()1793 virtual void SetUp() {
1794 index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX";
1795 total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL";
1796 }
1797
TearDown()1798 virtual void TearDown() {
1799 SetEnv(index_var_, "");
1800 SetEnv(total_var_, "");
1801 }
1802
1803 const char* index_var_;
1804 const char* total_var_;
1805 };
1806
1807 // Tests that sharding is disabled if neither of the environment variables
1808 // are set.
TEST_F(ShouldShardTest,ReturnsFalseWhenNeitherEnvVarIsSet)1809 TEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) {
1810 SetEnv(index_var_, "");
1811 SetEnv(total_var_, "");
1812
1813 EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
1814 EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1815 }
1816
1817 // Tests that sharding is not enabled if total_shards == 1.
TEST_F(ShouldShardTest,ReturnsFalseWhenTotalShardIsOne)1818 TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
1819 SetEnv(index_var_, "0");
1820 SetEnv(total_var_, "1");
1821 EXPECT_FALSE(ShouldShard(total_var_, index_var_, false));
1822 EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1823 }
1824
1825 // Tests that sharding is enabled if total_shards > 1 and
1826 // we are not in a death test subprocess.
1827 // Environment variables are not supported on Windows CE.
1828 #if !GTEST_OS_WINDOWS_MOBILE
TEST_F(ShouldShardTest,WorksWhenShardEnvVarsAreValid)1829 TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
1830 SetEnv(index_var_, "4");
1831 SetEnv(total_var_, "22");
1832 EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1833 EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1834
1835 SetEnv(index_var_, "8");
1836 SetEnv(total_var_, "9");
1837 EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1838 EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1839
1840 SetEnv(index_var_, "0");
1841 SetEnv(total_var_, "9");
1842 EXPECT_TRUE(ShouldShard(total_var_, index_var_, false));
1843 EXPECT_FALSE(ShouldShard(total_var_, index_var_, true));
1844 }
1845 #endif // !GTEST_OS_WINDOWS_MOBILE
1846
1847 // Tests that we exit in error if the sharding values are not valid.
1848
1849 typedef ShouldShardTest ShouldShardDeathTest;
1850
TEST_F(ShouldShardDeathTest,AbortsWhenShardingEnvVarsAreInvalid)1851 TEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) {
1852 SetEnv(index_var_, "4");
1853 SetEnv(total_var_, "4");
1854 EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1855
1856 SetEnv(index_var_, "4");
1857 SetEnv(total_var_, "-2");
1858 EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1859
1860 SetEnv(index_var_, "5");
1861 SetEnv(total_var_, "");
1862 EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1863
1864 SetEnv(index_var_, "");
1865 SetEnv(total_var_, "5");
1866 EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*");
1867 }
1868
1869 // Tests that ShouldRunTestOnShard is a partition when 5
1870 // shards are used.
TEST(ShouldRunTestOnShardTest,IsPartitionWhenThereAreFiveShards)1871 TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) {
1872 // Choose an arbitrary number of tests and shards.
1873 const int num_tests = 17;
1874 const int num_shards = 5;
1875
1876 // Check partitioning: each test should be on exactly 1 shard.
1877 for (int test_id = 0; test_id < num_tests; test_id++) {
1878 int prev_selected_shard_index = -1;
1879 for (int shard_index = 0; shard_index < num_shards; shard_index++) {
1880 if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) {
1881 if (prev_selected_shard_index < 0) {
1882 prev_selected_shard_index = shard_index;
1883 } else {
1884 ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and "
1885 << shard_index << " are both selected to run test " << test_id;
1886 }
1887 }
1888 }
1889 }
1890
1891 // Check balance: This is not required by the sharding protocol, but is a
1892 // desirable property for performance.
1893 for (int shard_index = 0; shard_index < num_shards; shard_index++) {
1894 int num_tests_on_shard = 0;
1895 for (int test_id = 0; test_id < num_tests; test_id++) {
1896 num_tests_on_shard +=
1897 ShouldRunTestOnShard(num_shards, shard_index, test_id);
1898 }
1899 EXPECT_GE(num_tests_on_shard, num_tests / num_shards);
1900 }
1901 }
1902
1903 // For the same reason we are not explicitly testing everything in the
1904 // Test class, there are no separate tests for the following classes
1905 // (except for some trivial cases):
1906 //
1907 // TestCase, UnitTest, UnitTestResultPrinter.
1908 //
1909 // Similarly, there are no separate tests for the following macros:
1910 //
1911 // TEST, TEST_F, RUN_ALL_TESTS
1912
TEST(UnitTestTest,CanGetOriginalWorkingDir)1913 TEST(UnitTestTest, CanGetOriginalWorkingDir) {
1914 ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL);
1915 EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), "");
1916 }
1917
TEST(UnitTestTest,ReturnsPlausibleTimestamp)1918 TEST(UnitTestTest, ReturnsPlausibleTimestamp) {
1919 EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp());
1920 EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis());
1921 }
1922
1923 // This group of tests is for predicate assertions (ASSERT_PRED*, etc)
1924 // of various arities. They do not attempt to be exhaustive. Rather,
1925 // view them as smoke tests that can be easily reviewed and verified.
1926 // A more complete set of tests for predicate assertions can be found
1927 // in gtest_pred_impl_unittest.cc.
1928
1929 // First, some predicates and predicate-formatters needed by the tests.
1930
1931 // Returns true iff the argument is an even number.
IsEven(int n)1932 bool IsEven(int n) {
1933 return (n % 2) == 0;
1934 }
1935
1936 // A functor that returns true iff the argument is an even number.
1937 struct IsEvenFunctor {
operator ()__anon7c331e2f0111::IsEvenFunctor1938 bool operator()(int n) { return IsEven(n); }
1939 };
1940
1941 // A predicate-formatter function that asserts the argument is an even
1942 // number.
AssertIsEven(const char * expr,int n)1943 AssertionResult AssertIsEven(const char* expr, int n) {
1944 if (IsEven(n)) {
1945 return AssertionSuccess();
1946 }
1947
1948 Message msg;
1949 msg << expr << " evaluates to " << n << ", which is not even.";
1950 return AssertionFailure(msg);
1951 }
1952
1953 // A predicate function that returns AssertionResult for use in
1954 // EXPECT/ASSERT_TRUE/FALSE.
ResultIsEven(int n)1955 AssertionResult ResultIsEven(int n) {
1956 if (IsEven(n))
1957 return AssertionSuccess() << n << " is even";
1958 else
1959 return AssertionFailure() << n << " is odd";
1960 }
1961
1962 // A predicate function that returns AssertionResult but gives no
1963 // explanation why it succeeds. Needed for testing that
1964 // EXPECT/ASSERT_FALSE handles such functions correctly.
ResultIsEvenNoExplanation(int n)1965 AssertionResult ResultIsEvenNoExplanation(int n) {
1966 if (IsEven(n))
1967 return AssertionSuccess();
1968 else
1969 return AssertionFailure() << n << " is odd";
1970 }
1971
1972 // A predicate-formatter functor that asserts the argument is an even
1973 // number.
1974 struct AssertIsEvenFunctor {
operator ()__anon7c331e2f0111::AssertIsEvenFunctor1975 AssertionResult operator()(const char* expr, int n) {
1976 return AssertIsEven(expr, n);
1977 }
1978 };
1979
1980 // Returns true iff the sum of the arguments is an even number.
SumIsEven2(int n1,int n2)1981 bool SumIsEven2(int n1, int n2) {
1982 return IsEven(n1 + n2);
1983 }
1984
1985 // A functor that returns true iff the sum of the arguments is an even
1986 // number.
1987 struct SumIsEven3Functor {
operator ()__anon7c331e2f0111::SumIsEven3Functor1988 bool operator()(int n1, int n2, int n3) {
1989 return IsEven(n1 + n2 + n3);
1990 }
1991 };
1992
1993 // A predicate-formatter function that asserts the sum of the
1994 // arguments is an even number.
AssertSumIsEven4(const char * e1,const char * e2,const char * e3,const char * e4,int n1,int n2,int n3,int n4)1995 AssertionResult AssertSumIsEven4(
1996 const char* e1, const char* e2, const char* e3, const char* e4,
1997 int n1, int n2, int n3, int n4) {
1998 const int sum = n1 + n2 + n3 + n4;
1999 if (IsEven(sum)) {
2000 return AssertionSuccess();
2001 }
2002
2003 Message msg;
2004 msg << e1 << " + " << e2 << " + " << e3 << " + " << e4
2005 << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4
2006 << ") evaluates to " << sum << ", which is not even.";
2007 return AssertionFailure(msg);
2008 }
2009
2010 // A predicate-formatter functor that asserts the sum of the arguments
2011 // is an even number.
2012 struct AssertSumIsEven5Functor {
operator ()__anon7c331e2f0111::AssertSumIsEven5Functor2013 AssertionResult operator()(
2014 const char* e1, const char* e2, const char* e3, const char* e4,
2015 const char* e5, int n1, int n2, int n3, int n4, int n5) {
2016 const int sum = n1 + n2 + n3 + n4 + n5;
2017 if (IsEven(sum)) {
2018 return AssertionSuccess();
2019 }
2020
2021 Message msg;
2022 msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5
2023 << " ("
2024 << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5
2025 << ") evaluates to " << sum << ", which is not even.";
2026 return AssertionFailure(msg);
2027 }
2028 };
2029
2030
2031 // Tests unary predicate assertions.
2032
2033 // Tests unary predicate assertions that don't use a custom formatter.
TEST(Pred1Test,WithoutFormat)2034 TEST(Pred1Test, WithoutFormat) {
2035 // Success cases.
2036 EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!";
2037 ASSERT_PRED1(IsEven, 4);
2038
2039 // Failure cases.
2040 EXPECT_NONFATAL_FAILURE({ // NOLINT
2041 EXPECT_PRED1(IsEven, 5) << "This failure is expected.";
2042 }, "This failure is expected.");
2043 EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5),
2044 "evaluates to false");
2045 }
2046
2047 // Tests unary predicate assertions that use a custom formatter.
TEST(Pred1Test,WithFormat)2048 TEST(Pred1Test, WithFormat) {
2049 // Success cases.
2050 EXPECT_PRED_FORMAT1(AssertIsEven, 2);
2051 ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4)
2052 << "This failure is UNEXPECTED!";
2053
2054 // Failure cases.
2055 const int n = 5;
2056 EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n),
2057 "n evaluates to 5, which is not even.");
2058 EXPECT_FATAL_FAILURE({ // NOLINT
2059 ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected.";
2060 }, "This failure is expected.");
2061 }
2062
2063 // Tests that unary predicate assertions evaluates their arguments
2064 // exactly once.
TEST(Pred1Test,SingleEvaluationOnFailure)2065 TEST(Pred1Test, SingleEvaluationOnFailure) {
2066 // A success case.
2067 static int n = 0;
2068 EXPECT_PRED1(IsEven, n++);
2069 EXPECT_EQ(1, n) << "The argument is not evaluated exactly once.";
2070
2071 // A failure case.
2072 EXPECT_FATAL_FAILURE({ // NOLINT
2073 ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++)
2074 << "This failure is expected.";
2075 }, "This failure is expected.");
2076 EXPECT_EQ(2, n) << "The argument is not evaluated exactly once.";
2077 }
2078
2079
2080 // Tests predicate assertions whose arity is >= 2.
2081
2082 // Tests predicate assertions that don't use a custom formatter.
TEST(PredTest,WithoutFormat)2083 TEST(PredTest, WithoutFormat) {
2084 // Success cases.
2085 ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!";
2086 EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8);
2087
2088 // Failure cases.
2089 const int n1 = 1;
2090 const int n2 = 2;
2091 EXPECT_NONFATAL_FAILURE({ // NOLINT
2092 EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected.";
2093 }, "This failure is expected.");
2094 EXPECT_FATAL_FAILURE({ // NOLINT
2095 ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4);
2096 }, "evaluates to false");
2097 }
2098
2099 // Tests predicate assertions that use a custom formatter.
TEST(PredTest,WithFormat)2100 TEST(PredTest, WithFormat) {
2101 // Success cases.
2102 ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) <<
2103 "This failure is UNEXPECTED!";
2104 EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10);
2105
2106 // Failure cases.
2107 const int n1 = 1;
2108 const int n2 = 2;
2109 const int n3 = 4;
2110 const int n4 = 6;
2111 EXPECT_NONFATAL_FAILURE({ // NOLINT
2112 EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4);
2113 }, "evaluates to 13, which is not even.");
2114 EXPECT_FATAL_FAILURE({ // NOLINT
2115 ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8)
2116 << "This failure is expected.";
2117 }, "This failure is expected.");
2118 }
2119
2120 // Tests that predicate assertions evaluates their arguments
2121 // exactly once.
TEST(PredTest,SingleEvaluationOnFailure)2122 TEST(PredTest, SingleEvaluationOnFailure) {
2123 // A success case.
2124 int n1 = 0;
2125 int n2 = 0;
2126 EXPECT_PRED2(SumIsEven2, n1++, n2++);
2127 EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2128 EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2129
2130 // Another success case.
2131 n1 = n2 = 0;
2132 int n3 = 0;
2133 int n4 = 0;
2134 int n5 = 0;
2135 ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(),
2136 n1++, n2++, n3++, n4++, n5++)
2137 << "This failure is UNEXPECTED!";
2138 EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2139 EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2140 EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2141 EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
2142 EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once.";
2143
2144 // A failure case.
2145 n1 = n2 = n3 = 0;
2146 EXPECT_NONFATAL_FAILURE({ // NOLINT
2147 EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++)
2148 << "This failure is expected.";
2149 }, "This failure is expected.");
2150 EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2151 EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2152 EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2153
2154 // Another failure case.
2155 n1 = n2 = n3 = n4 = 0;
2156 EXPECT_NONFATAL_FAILURE({ // NOLINT
2157 EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++);
2158 }, "evaluates to 1, which is not even.");
2159 EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once.";
2160 EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once.";
2161 EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once.";
2162 EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once.";
2163 }
2164
2165
2166 // Some helper functions for testing using overloaded/template
2167 // functions with ASSERT_PREDn and EXPECT_PREDn.
2168
IsPositive(double x)2169 bool IsPositive(double x) {
2170 return x > 0;
2171 }
2172
2173 template <typename T>
IsNegative(T x)2174 bool IsNegative(T x) {
2175 return x < 0;
2176 }
2177
2178 template <typename T1, typename T2>
GreaterThan(T1 x1,T2 x2)2179 bool GreaterThan(T1 x1, T2 x2) {
2180 return x1 > x2;
2181 }
2182
2183 // Tests that overloaded functions can be used in *_PRED* as long as
2184 // their types are explicitly specified.
TEST(PredicateAssertionTest,AcceptsOverloadedFunction)2185 TEST(PredicateAssertionTest, AcceptsOverloadedFunction) {
2186 // C++Builder requires C-style casts rather than static_cast.
2187 EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT
2188 ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT
2189 }
2190
2191 // Tests that template functions can be used in *_PRED* as long as
2192 // their types are explicitly specified.
TEST(PredicateAssertionTest,AcceptsTemplateFunction)2193 TEST(PredicateAssertionTest, AcceptsTemplateFunction) {
2194 EXPECT_PRED1(IsNegative<int>, -5);
2195 // Makes sure that we can handle templates with more than one
2196 // parameter.
2197 ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
2198 }
2199
2200
2201 // Some helper functions for testing using overloaded/template
2202 // functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn.
2203
IsPositiveFormat(const char *,int n)2204 AssertionResult IsPositiveFormat(const char* /* expr */, int n) {
2205 return n > 0 ? AssertionSuccess() :
2206 AssertionFailure(Message() << "Failure");
2207 }
2208
IsPositiveFormat(const char *,double x)2209 AssertionResult IsPositiveFormat(const char* /* expr */, double x) {
2210 return x > 0 ? AssertionSuccess() :
2211 AssertionFailure(Message() << "Failure");
2212 }
2213
2214 template <typename T>
IsNegativeFormat(const char *,T x)2215 AssertionResult IsNegativeFormat(const char* /* expr */, T x) {
2216 return x < 0 ? AssertionSuccess() :
2217 AssertionFailure(Message() << "Failure");
2218 }
2219
2220 template <typename T1, typename T2>
EqualsFormat(const char *,const char *,const T1 & x1,const T2 & x2)2221 AssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */,
2222 const T1& x1, const T2& x2) {
2223 return x1 == x2 ? AssertionSuccess() :
2224 AssertionFailure(Message() << "Failure");
2225 }
2226
2227 // Tests that overloaded functions can be used in *_PRED_FORMAT*
2228 // without explicitly specifying their types.
TEST(PredicateFormatAssertionTest,AcceptsOverloadedFunction)2229 TEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) {
2230 EXPECT_PRED_FORMAT1(IsPositiveFormat, 5);
2231 ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0);
2232 }
2233
2234 // Tests that template functions can be used in *_PRED_FORMAT* without
2235 // explicitly specifying their types.
TEST(PredicateFormatAssertionTest,AcceptsTemplateFunction)2236 TEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) {
2237 EXPECT_PRED_FORMAT1(IsNegativeFormat, -5);
2238 ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3);
2239 }
2240
2241
2242 // Tests string assertions.
2243
2244 // Tests ASSERT_STREQ with non-NULL arguments.
TEST(StringAssertionTest,ASSERT_STREQ)2245 TEST(StringAssertionTest, ASSERT_STREQ) {
2246 const char * const p1 = "good";
2247 ASSERT_STREQ(p1, p1);
2248
2249 // Let p2 have the same content as p1, but be at a different address.
2250 const char p2[] = "good";
2251 ASSERT_STREQ(p1, p2);
2252
2253 EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
2254 "Expected: \"bad\"");
2255 }
2256
2257 // Tests ASSERT_STREQ with NULL arguments.
TEST(StringAssertionTest,ASSERT_STREQ_Null)2258 TEST(StringAssertionTest, ASSERT_STREQ_Null) {
2259 ASSERT_STREQ(static_cast<const char *>(NULL), NULL);
2260 EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"),
2261 "non-null");
2262 }
2263
2264 // Tests ASSERT_STREQ with NULL arguments.
TEST(StringAssertionTest,ASSERT_STREQ_Null2)2265 TEST(StringAssertionTest, ASSERT_STREQ_Null2) {
2266 EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL),
2267 "non-null");
2268 }
2269
2270 // Tests ASSERT_STRNE.
TEST(StringAssertionTest,ASSERT_STRNE)2271 TEST(StringAssertionTest, ASSERT_STRNE) {
2272 ASSERT_STRNE("hi", "Hi");
2273 ASSERT_STRNE("Hi", NULL);
2274 ASSERT_STRNE(NULL, "Hi");
2275 ASSERT_STRNE("", NULL);
2276 ASSERT_STRNE(NULL, "");
2277 ASSERT_STRNE("", "Hi");
2278 ASSERT_STRNE("Hi", "");
2279 EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"),
2280 "\"Hi\" vs \"Hi\"");
2281 }
2282
2283 // Tests ASSERT_STRCASEEQ.
TEST(StringAssertionTest,ASSERT_STRCASEEQ)2284 TEST(StringAssertionTest, ASSERT_STRCASEEQ) {
2285 ASSERT_STRCASEEQ("hi", "Hi");
2286 ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL);
2287
2288 ASSERT_STRCASEEQ("", "");
2289 EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"),
2290 "(ignoring case)");
2291 }
2292
2293 // Tests ASSERT_STRCASENE.
TEST(StringAssertionTest,ASSERT_STRCASENE)2294 TEST(StringAssertionTest, ASSERT_STRCASENE) {
2295 ASSERT_STRCASENE("hi1", "Hi2");
2296 ASSERT_STRCASENE("Hi", NULL);
2297 ASSERT_STRCASENE(NULL, "Hi");
2298 ASSERT_STRCASENE("", NULL);
2299 ASSERT_STRCASENE(NULL, "");
2300 ASSERT_STRCASENE("", "Hi");
2301 ASSERT_STRCASENE("Hi", "");
2302 EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"),
2303 "(ignoring case)");
2304 }
2305
2306 // Tests *_STREQ on wide strings.
TEST(StringAssertionTest,STREQ_Wide)2307 TEST(StringAssertionTest, STREQ_Wide) {
2308 // NULL strings.
2309 ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL);
2310
2311 // Empty strings.
2312 ASSERT_STREQ(L"", L"");
2313
2314 // Non-null vs NULL.
2315 EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL),
2316 "non-null");
2317
2318 // Equal strings.
2319 EXPECT_STREQ(L"Hi", L"Hi");
2320
2321 // Unequal strings.
2322 EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"),
2323 "Abc");
2324
2325 // Strings containing wide characters.
2326 EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"),
2327 "abc");
2328
2329 // The streaming variation.
2330 EXPECT_NONFATAL_FAILURE({ // NOLINT
2331 EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure";
2332 }, "Expected failure");
2333 }
2334
2335 // Tests *_STRNE on wide strings.
TEST(StringAssertionTest,STRNE_Wide)2336 TEST(StringAssertionTest, STRNE_Wide) {
2337 // NULL strings.
2338 EXPECT_NONFATAL_FAILURE({ // NOLINT
2339 EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL);
2340 }, "");
2341
2342 // Empty strings.
2343 EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""),
2344 "L\"\"");
2345
2346 // Non-null vs NULL.
2347 ASSERT_STRNE(L"non-null", NULL);
2348
2349 // Equal strings.
2350 EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"),
2351 "L\"Hi\"");
2352
2353 // Unequal strings.
2354 EXPECT_STRNE(L"abc", L"Abc");
2355
2356 // Strings containing wide characters.
2357 EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"),
2358 "abc");
2359
2360 // The streaming variation.
2361 ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen";
2362 }
2363
2364 // Tests for ::testing::IsSubstring().
2365
2366 // Tests that IsSubstring() returns the correct result when the input
2367 // argument type is const char*.
TEST(IsSubstringTest,ReturnsCorrectResultForCString)2368 TEST(IsSubstringTest, ReturnsCorrectResultForCString) {
2369 EXPECT_FALSE(IsSubstring("", "", NULL, "a"));
2370 EXPECT_FALSE(IsSubstring("", "", "b", NULL));
2371 EXPECT_FALSE(IsSubstring("", "", "needle", "haystack"));
2372
2373 EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL));
2374 EXPECT_TRUE(IsSubstring("", "", "needle", "two needles"));
2375 }
2376
2377 // Tests that IsSubstring() returns the correct result when the input
2378 // argument type is const wchar_t*.
TEST(IsSubstringTest,ReturnsCorrectResultForWideCString)2379 TEST(IsSubstringTest, ReturnsCorrectResultForWideCString) {
2380 EXPECT_FALSE(IsSubstring("", "", kNull, L"a"));
2381 EXPECT_FALSE(IsSubstring("", "", L"b", kNull));
2382 EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack"));
2383
2384 EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL));
2385 EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles"));
2386 }
2387
2388 // Tests that IsSubstring() generates the correct message when the input
2389 // argument type is const char*.
TEST(IsSubstringTest,GeneratesCorrectMessageForCString)2390 TEST(IsSubstringTest, GeneratesCorrectMessageForCString) {
2391 EXPECT_STREQ("Value of: needle_expr\n"
2392 " Actual: \"needle\"\n"
2393 "Expected: a substring of haystack_expr\n"
2394 "Which is: \"haystack\"",
2395 IsSubstring("needle_expr", "haystack_expr",
2396 "needle", "haystack").failure_message());
2397 }
2398
2399 // Tests that IsSubstring returns the correct result when the input
2400 // argument type is ::std::string.
TEST(IsSubstringTest,ReturnsCorrectResultsForStdString)2401 TEST(IsSubstringTest, ReturnsCorrectResultsForStdString) {
2402 EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob"));
2403 EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world")));
2404 }
2405
2406 #if GTEST_HAS_STD_WSTRING
2407 // Tests that IsSubstring returns the correct result when the input
2408 // argument type is ::std::wstring.
TEST(IsSubstringTest,ReturnsCorrectResultForStdWstring)2409 TEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) {
2410 EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
2411 EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack")));
2412 }
2413
2414 // Tests that IsSubstring() generates the correct message when the input
2415 // argument type is ::std::wstring.
TEST(IsSubstringTest,GeneratesCorrectMessageForWstring)2416 TEST(IsSubstringTest, GeneratesCorrectMessageForWstring) {
2417 EXPECT_STREQ("Value of: needle_expr\n"
2418 " Actual: L\"needle\"\n"
2419 "Expected: a substring of haystack_expr\n"
2420 "Which is: L\"haystack\"",
2421 IsSubstring(
2422 "needle_expr", "haystack_expr",
2423 ::std::wstring(L"needle"), L"haystack").failure_message());
2424 }
2425
2426 #endif // GTEST_HAS_STD_WSTRING
2427
2428 // Tests for ::testing::IsNotSubstring().
2429
2430 // Tests that IsNotSubstring() returns the correct result when the input
2431 // argument type is const char*.
TEST(IsNotSubstringTest,ReturnsCorrectResultForCString)2432 TEST(IsNotSubstringTest, ReturnsCorrectResultForCString) {
2433 EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack"));
2434 EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles"));
2435 }
2436
2437 // Tests that IsNotSubstring() returns the correct result when the input
2438 // argument type is const wchar_t*.
TEST(IsNotSubstringTest,ReturnsCorrectResultForWideCString)2439 TEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) {
2440 EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack"));
2441 EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles"));
2442 }
2443
2444 // Tests that IsNotSubstring() generates the correct message when the input
2445 // argument type is const wchar_t*.
TEST(IsNotSubstringTest,GeneratesCorrectMessageForWideCString)2446 TEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) {
2447 EXPECT_STREQ("Value of: needle_expr\n"
2448 " Actual: L\"needle\"\n"
2449 "Expected: not a substring of haystack_expr\n"
2450 "Which is: L\"two needles\"",
2451 IsNotSubstring(
2452 "needle_expr", "haystack_expr",
2453 L"needle", L"two needles").failure_message());
2454 }
2455
2456 // Tests that IsNotSubstring returns the correct result when the input
2457 // argument type is ::std::string.
TEST(IsNotSubstringTest,ReturnsCorrectResultsForStdString)2458 TEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) {
2459 EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob"));
2460 EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world")));
2461 }
2462
2463 // Tests that IsNotSubstring() generates the correct message when the input
2464 // argument type is ::std::string.
TEST(IsNotSubstringTest,GeneratesCorrectMessageForStdString)2465 TEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) {
2466 EXPECT_STREQ("Value of: needle_expr\n"
2467 " Actual: \"needle\"\n"
2468 "Expected: not a substring of haystack_expr\n"
2469 "Which is: \"two needles\"",
2470 IsNotSubstring(
2471 "needle_expr", "haystack_expr",
2472 ::std::string("needle"), "two needles").failure_message());
2473 }
2474
2475 #if GTEST_HAS_STD_WSTRING
2476
2477 // Tests that IsNotSubstring returns the correct result when the input
2478 // argument type is ::std::wstring.
TEST(IsNotSubstringTest,ReturnsCorrectResultForStdWstring)2479 TEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) {
2480 EXPECT_FALSE(
2481 IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles"));
2482 EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack")));
2483 }
2484
2485 #endif // GTEST_HAS_STD_WSTRING
2486
2487 // Tests floating-point assertions.
2488
2489 template <typename RawType>
2490 class FloatingPointTest : public Test {
2491 protected:
2492 // Pre-calculated numbers to be used by the tests.
2493 struct TestValues {
2494 RawType close_to_positive_zero;
2495 RawType close_to_negative_zero;
2496 RawType further_from_negative_zero;
2497
2498 RawType close_to_one;
2499 RawType further_from_one;
2500
2501 RawType infinity;
2502 RawType close_to_infinity;
2503 RawType further_from_infinity;
2504
2505 RawType nan1;
2506 RawType nan2;
2507 };
2508
2509 typedef typename testing::internal::FloatingPoint<RawType> Floating;
2510 typedef typename Floating::Bits Bits;
2511
SetUp()2512 virtual void SetUp() {
2513 const size_t max_ulps = Floating::kMaxUlps;
2514
2515 // The bits that represent 0.0.
2516 const Bits zero_bits = Floating(0).bits();
2517
2518 // Makes some numbers close to 0.0.
2519 values_.close_to_positive_zero = Floating::ReinterpretBits(
2520 zero_bits + max_ulps/2);
2521 values_.close_to_negative_zero = -Floating::ReinterpretBits(
2522 zero_bits + max_ulps - max_ulps/2);
2523 values_.further_from_negative_zero = -Floating::ReinterpretBits(
2524 zero_bits + max_ulps + 1 - max_ulps/2);
2525
2526 // The bits that represent 1.0.
2527 const Bits one_bits = Floating(1).bits();
2528
2529 // Makes some numbers close to 1.0.
2530 values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps);
2531 values_.further_from_one = Floating::ReinterpretBits(
2532 one_bits + max_ulps + 1);
2533
2534 // +infinity.
2535 values_.infinity = Floating::Infinity();
2536
2537 // The bits that represent +infinity.
2538 const Bits infinity_bits = Floating(values_.infinity).bits();
2539
2540 // Makes some numbers close to infinity.
2541 values_.close_to_infinity = Floating::ReinterpretBits(
2542 infinity_bits - max_ulps);
2543 values_.further_from_infinity = Floating::ReinterpretBits(
2544 infinity_bits - max_ulps - 1);
2545
2546 // Makes some NAN's. Sets the most significant bit of the fraction so that
2547 // our NaN's are quiet; trying to process a signaling NaN would raise an
2548 // exception if our environment enables floating point exceptions.
2549 values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask
2550 | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1);
2551 values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask
2552 | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200);
2553 }
2554
TestSize()2555 void TestSize() {
2556 EXPECT_EQ(sizeof(RawType), sizeof(Bits));
2557 }
2558
2559 static TestValues values_;
2560 };
2561
2562 template <typename RawType>
2563 typename FloatingPointTest<RawType>::TestValues
2564 FloatingPointTest<RawType>::values_;
2565
2566 // Instantiates FloatingPointTest for testing *_FLOAT_EQ.
2567 typedef FloatingPointTest<float> FloatTest;
2568
2569 // Tests that the size of Float::Bits matches the size of float.
TEST_F(FloatTest,Size)2570 TEST_F(FloatTest, Size) {
2571 TestSize();
2572 }
2573
2574 // Tests comparing with +0 and -0.
TEST_F(FloatTest,Zeros)2575 TEST_F(FloatTest, Zeros) {
2576 EXPECT_FLOAT_EQ(0.0, -0.0);
2577 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0),
2578 "1.0");
2579 EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5),
2580 "1.5");
2581 }
2582
2583 // Tests comparing numbers close to 0.
2584 //
2585 // This ensures that *_FLOAT_EQ handles the sign correctly and no
2586 // overflow occurs when comparing numbers whose absolute value is very
2587 // small.
TEST_F(FloatTest,AlmostZeros)2588 TEST_F(FloatTest, AlmostZeros) {
2589 // In C++Builder, names within local classes (such as used by
2590 // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2591 // scoping class. Use a static local alias as a workaround.
2592 // We use the assignment syntax since some compilers, like Sun Studio,
2593 // don't allow initializing references using construction syntax
2594 // (parentheses).
2595 static const FloatTest::TestValues& v = this->values_;
2596
2597 EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero);
2598 EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero);
2599 EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
2600
2601 EXPECT_FATAL_FAILURE({ // NOLINT
2602 ASSERT_FLOAT_EQ(v.close_to_positive_zero,
2603 v.further_from_negative_zero);
2604 }, "v.further_from_negative_zero");
2605 }
2606
2607 // Tests comparing numbers close to each other.
TEST_F(FloatTest,SmallDiff)2608 TEST_F(FloatTest, SmallDiff) {
2609 EXPECT_FLOAT_EQ(1.0, values_.close_to_one);
2610 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one),
2611 "values_.further_from_one");
2612 }
2613
2614 // Tests comparing numbers far apart.
TEST_F(FloatTest,LargeDiff)2615 TEST_F(FloatTest, LargeDiff) {
2616 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0),
2617 "3.0");
2618 }
2619
2620 // Tests comparing with infinity.
2621 //
2622 // This ensures that no overflow occurs when comparing numbers whose
2623 // absolute value is very large.
TEST_F(FloatTest,Infinity)2624 TEST_F(FloatTest, Infinity) {
2625 EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
2626 EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
2627 #if !GTEST_OS_SYMBIAN
2628 // Nokia's STLport crashes if we try to output infinity or NaN.
2629 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
2630 "-values_.infinity");
2631
2632 // This is interesting as the representations of infinity and nan1
2633 // are only 1 DLP apart.
2634 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1),
2635 "values_.nan1");
2636 #endif // !GTEST_OS_SYMBIAN
2637 }
2638
2639 // Tests that comparing with NAN always returns false.
TEST_F(FloatTest,NaN)2640 TEST_F(FloatTest, NaN) {
2641 #if !GTEST_OS_SYMBIAN
2642 // Nokia's STLport crashes if we try to output infinity or NaN.
2643
2644 // In C++Builder, names within local classes (such as used by
2645 // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2646 // scoping class. Use a static local alias as a workaround.
2647 // We use the assignment syntax since some compilers, like Sun Studio,
2648 // don't allow initializing references using construction syntax
2649 // (parentheses).
2650 static const FloatTest::TestValues& v = this->values_;
2651
2652 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1),
2653 "v.nan1");
2654 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2),
2655 "v.nan2");
2656 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1),
2657 "v.nan1");
2658
2659 EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity),
2660 "v.infinity");
2661 #endif // !GTEST_OS_SYMBIAN
2662 }
2663
2664 // Tests that *_FLOAT_EQ are reflexive.
TEST_F(FloatTest,Reflexive)2665 TEST_F(FloatTest, Reflexive) {
2666 EXPECT_FLOAT_EQ(0.0, 0.0);
2667 EXPECT_FLOAT_EQ(1.0, 1.0);
2668 ASSERT_FLOAT_EQ(values_.infinity, values_.infinity);
2669 }
2670
2671 // Tests that *_FLOAT_EQ are commutative.
TEST_F(FloatTest,Commutative)2672 TEST_F(FloatTest, Commutative) {
2673 // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one).
2674 EXPECT_FLOAT_EQ(values_.close_to_one, 1.0);
2675
2676 // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one).
2677 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0),
2678 "1.0");
2679 }
2680
2681 // Tests EXPECT_NEAR.
TEST_F(FloatTest,EXPECT_NEAR)2682 TEST_F(FloatTest, EXPECT_NEAR) {
2683 EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
2684 EXPECT_NEAR(2.0f, 3.0f, 1.0f);
2685 EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f), // NOLINT
2686 "The difference between 1.0f and 1.5f is 0.5, "
2687 "which exceeds 0.25f");
2688 // To work around a bug in gcc 2.95.0, there is intentionally no
2689 // space after the first comma in the previous line.
2690 }
2691
2692 // Tests ASSERT_NEAR.
TEST_F(FloatTest,ASSERT_NEAR)2693 TEST_F(FloatTest, ASSERT_NEAR) {
2694 ASSERT_NEAR(-1.0f, -1.1f, 0.2f);
2695 ASSERT_NEAR(2.0f, 3.0f, 1.0f);
2696 EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f), // NOLINT
2697 "The difference between 1.0f and 1.5f is 0.5, "
2698 "which exceeds 0.25f");
2699 // To work around a bug in gcc 2.95.0, there is intentionally no
2700 // space after the first comma in the previous line.
2701 }
2702
2703 // Tests the cases where FloatLE() should succeed.
TEST_F(FloatTest,FloatLESucceeds)2704 TEST_F(FloatTest, FloatLESucceeds) {
2705 EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2,
2706 ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2,
2707
2708 // or when val1 is greater than, but almost equals to, val2.
2709 EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f);
2710 }
2711
2712 // Tests the cases where FloatLE() should fail.
TEST_F(FloatTest,FloatLEFails)2713 TEST_F(FloatTest, FloatLEFails) {
2714 // When val1 is greater than val2 by a large margin,
2715 EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f),
2716 "(2.0f) <= (1.0f)");
2717
2718 // or by a small yet non-negligible margin,
2719 EXPECT_NONFATAL_FAILURE({ // NOLINT
2720 EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f);
2721 }, "(values_.further_from_one) <= (1.0f)");
2722
2723 #if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2724 // Nokia's STLport crashes if we try to output infinity or NaN.
2725 // C++Builder gives bad results for ordered comparisons involving NaNs
2726 // due to compiler bugs.
2727 EXPECT_NONFATAL_FAILURE({ // NOLINT
2728 EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity);
2729 }, "(values_.nan1) <= (values_.infinity)");
2730 EXPECT_NONFATAL_FAILURE({ // NOLINT
2731 EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1);
2732 }, "(-values_.infinity) <= (values_.nan1)");
2733 EXPECT_FATAL_FAILURE({ // NOLINT
2734 ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1);
2735 }, "(values_.nan1) <= (values_.nan1)");
2736 #endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2737 }
2738
2739 // Instantiates FloatingPointTest for testing *_DOUBLE_EQ.
2740 typedef FloatingPointTest<double> DoubleTest;
2741
2742 // Tests that the size of Double::Bits matches the size of double.
TEST_F(DoubleTest,Size)2743 TEST_F(DoubleTest, Size) {
2744 TestSize();
2745 }
2746
2747 // Tests comparing with +0 and -0.
TEST_F(DoubleTest,Zeros)2748 TEST_F(DoubleTest, Zeros) {
2749 EXPECT_DOUBLE_EQ(0.0, -0.0);
2750 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0),
2751 "1.0");
2752 EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0),
2753 "1.0");
2754 }
2755
2756 // Tests comparing numbers close to 0.
2757 //
2758 // This ensures that *_DOUBLE_EQ handles the sign correctly and no
2759 // overflow occurs when comparing numbers whose absolute value is very
2760 // small.
TEST_F(DoubleTest,AlmostZeros)2761 TEST_F(DoubleTest, AlmostZeros) {
2762 // In C++Builder, names within local classes (such as used by
2763 // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2764 // scoping class. Use a static local alias as a workaround.
2765 // We use the assignment syntax since some compilers, like Sun Studio,
2766 // don't allow initializing references using construction syntax
2767 // (parentheses).
2768 static const DoubleTest::TestValues& v = this->values_;
2769
2770 EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero);
2771 EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero);
2772 EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero);
2773
2774 EXPECT_FATAL_FAILURE({ // NOLINT
2775 ASSERT_DOUBLE_EQ(v.close_to_positive_zero,
2776 v.further_from_negative_zero);
2777 }, "v.further_from_negative_zero");
2778 }
2779
2780 // Tests comparing numbers close to each other.
TEST_F(DoubleTest,SmallDiff)2781 TEST_F(DoubleTest, SmallDiff) {
2782 EXPECT_DOUBLE_EQ(1.0, values_.close_to_one);
2783 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one),
2784 "values_.further_from_one");
2785 }
2786
2787 // Tests comparing numbers far apart.
TEST_F(DoubleTest,LargeDiff)2788 TEST_F(DoubleTest, LargeDiff) {
2789 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0),
2790 "3.0");
2791 }
2792
2793 // Tests comparing with infinity.
2794 //
2795 // This ensures that no overflow occurs when comparing numbers whose
2796 // absolute value is very large.
TEST_F(DoubleTest,Infinity)2797 TEST_F(DoubleTest, Infinity) {
2798 EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
2799 EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
2800 #if !GTEST_OS_SYMBIAN
2801 // Nokia's STLport crashes if we try to output infinity or NaN.
2802 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
2803 "-values_.infinity");
2804
2805 // This is interesting as the representations of infinity_ and nan1_
2806 // are only 1 DLP apart.
2807 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1),
2808 "values_.nan1");
2809 #endif // !GTEST_OS_SYMBIAN
2810 }
2811
2812 // Tests that comparing with NAN always returns false.
TEST_F(DoubleTest,NaN)2813 TEST_F(DoubleTest, NaN) {
2814 #if !GTEST_OS_SYMBIAN
2815 // In C++Builder, names within local classes (such as used by
2816 // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the
2817 // scoping class. Use a static local alias as a workaround.
2818 // We use the assignment syntax since some compilers, like Sun Studio,
2819 // don't allow initializing references using construction syntax
2820 // (parentheses).
2821 static const DoubleTest::TestValues& v = this->values_;
2822
2823 // Nokia's STLport crashes if we try to output infinity or NaN.
2824 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1),
2825 "v.nan1");
2826 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
2827 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
2828 EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity),
2829 "v.infinity");
2830 #endif // !GTEST_OS_SYMBIAN
2831 }
2832
2833 // Tests that *_DOUBLE_EQ are reflexive.
TEST_F(DoubleTest,Reflexive)2834 TEST_F(DoubleTest, Reflexive) {
2835 EXPECT_DOUBLE_EQ(0.0, 0.0);
2836 EXPECT_DOUBLE_EQ(1.0, 1.0);
2837 #if !GTEST_OS_SYMBIAN
2838 // Nokia's STLport crashes if we try to output infinity or NaN.
2839 ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity);
2840 #endif // !GTEST_OS_SYMBIAN
2841 }
2842
2843 // Tests that *_DOUBLE_EQ are commutative.
TEST_F(DoubleTest,Commutative)2844 TEST_F(DoubleTest, Commutative) {
2845 // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one).
2846 EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0);
2847
2848 // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one).
2849 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0),
2850 "1.0");
2851 }
2852
2853 // Tests EXPECT_NEAR.
TEST_F(DoubleTest,EXPECT_NEAR)2854 TEST_F(DoubleTest, EXPECT_NEAR) {
2855 EXPECT_NEAR(-1.0, -1.1, 0.2);
2856 EXPECT_NEAR(2.0, 3.0, 1.0);
2857 EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25), // NOLINT
2858 "The difference between 1.0 and 1.5 is 0.5, "
2859 "which exceeds 0.25");
2860 // To work around a bug in gcc 2.95.0, there is intentionally no
2861 // space after the first comma in the previous statement.
2862 }
2863
2864 // Tests ASSERT_NEAR.
TEST_F(DoubleTest,ASSERT_NEAR)2865 TEST_F(DoubleTest, ASSERT_NEAR) {
2866 ASSERT_NEAR(-1.0, -1.1, 0.2);
2867 ASSERT_NEAR(2.0, 3.0, 1.0);
2868 EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25), // NOLINT
2869 "The difference between 1.0 and 1.5 is 0.5, "
2870 "which exceeds 0.25");
2871 // To work around a bug in gcc 2.95.0, there is intentionally no
2872 // space after the first comma in the previous statement.
2873 }
2874
2875 // Tests the cases where DoubleLE() should succeed.
TEST_F(DoubleTest,DoubleLESucceeds)2876 TEST_F(DoubleTest, DoubleLESucceeds) {
2877 EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2,
2878 ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2,
2879
2880 // or when val1 is greater than, but almost equals to, val2.
2881 EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0);
2882 }
2883
2884 // Tests the cases where DoubleLE() should fail.
TEST_F(DoubleTest,DoubleLEFails)2885 TEST_F(DoubleTest, DoubleLEFails) {
2886 // When val1 is greater than val2 by a large margin,
2887 EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0),
2888 "(2.0) <= (1.0)");
2889
2890 // or by a small yet non-negligible margin,
2891 EXPECT_NONFATAL_FAILURE({ // NOLINT
2892 EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0);
2893 }, "(values_.further_from_one) <= (1.0)");
2894
2895 #if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2896 // Nokia's STLport crashes if we try to output infinity or NaN.
2897 // C++Builder gives bad results for ordered comparisons involving NaNs
2898 // due to compiler bugs.
2899 EXPECT_NONFATAL_FAILURE({ // NOLINT
2900 EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity);
2901 }, "(values_.nan1) <= (values_.infinity)");
2902 EXPECT_NONFATAL_FAILURE({ // NOLINT
2903 EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1);
2904 }, " (-values_.infinity) <= (values_.nan1)");
2905 EXPECT_FATAL_FAILURE({ // NOLINT
2906 ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1);
2907 }, "(values_.nan1) <= (values_.nan1)");
2908 #endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__)
2909 }
2910
2911
2912 // Verifies that a test or test case whose name starts with DISABLED_ is
2913 // not run.
2914
2915 // A test whose name starts with DISABLED_.
2916 // Should not run.
TEST(DisabledTest,DISABLED_TestShouldNotRun)2917 TEST(DisabledTest, DISABLED_TestShouldNotRun) {
2918 FAIL() << "Unexpected failure: Disabled test should not be run.";
2919 }
2920
2921 // A test whose name does not start with DISABLED_.
2922 // Should run.
TEST(DisabledTest,NotDISABLED_TestShouldRun)2923 TEST(DisabledTest, NotDISABLED_TestShouldRun) {
2924 EXPECT_EQ(1, 1);
2925 }
2926
2927 // A test case whose name starts with DISABLED_.
2928 // Should not run.
TEST(DISABLED_TestCase,TestShouldNotRun)2929 TEST(DISABLED_TestCase, TestShouldNotRun) {
2930 FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
2931 }
2932
2933 // A test case and test whose names start with DISABLED_.
2934 // Should not run.
TEST(DISABLED_TestCase,DISABLED_TestShouldNotRun)2935 TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
2936 FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
2937 }
2938
2939 // Check that when all tests in a test case are disabled, SetupTestCase() and
2940 // TearDownTestCase() are not called.
2941 class DisabledTestsTest : public Test {
2942 protected:
SetUpTestCase()2943 static void SetUpTestCase() {
2944 FAIL() << "Unexpected failure: All tests disabled in test case. "
2945 "SetupTestCase() should not be called.";
2946 }
2947
TearDownTestCase()2948 static void TearDownTestCase() {
2949 FAIL() << "Unexpected failure: All tests disabled in test case. "
2950 "TearDownTestCase() should not be called.";
2951 }
2952 };
2953
TEST_F(DisabledTestsTest,DISABLED_TestShouldNotRun_1)2954 TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) {
2955 FAIL() << "Unexpected failure: Disabled test should not be run.";
2956 }
2957
TEST_F(DisabledTestsTest,DISABLED_TestShouldNotRun_2)2958 TEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) {
2959 FAIL() << "Unexpected failure: Disabled test should not be run.";
2960 }
2961
2962 // Tests that disabled typed tests aren't run.
2963
2964 #if GTEST_HAS_TYPED_TEST
2965
2966 template <typename T>
2967 class TypedTest : public Test {
2968 };
2969
2970 typedef testing::Types<int, double> NumericTypes;
2971 TYPED_TEST_CASE(TypedTest, NumericTypes);
2972
TYPED_TEST(TypedTest,DISABLED_ShouldNotRun)2973 TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) {
2974 FAIL() << "Unexpected failure: Disabled typed test should not run.";
2975 }
2976
2977 template <typename T>
2978 class DISABLED_TypedTest : public Test {
2979 };
2980
2981 TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes);
2982
TYPED_TEST(DISABLED_TypedTest,ShouldNotRun)2983 TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) {
2984 FAIL() << "Unexpected failure: Disabled typed test should not run.";
2985 }
2986
2987 #endif // GTEST_HAS_TYPED_TEST
2988
2989 // Tests that disabled type-parameterized tests aren't run.
2990
2991 #if GTEST_HAS_TYPED_TEST_P
2992
2993 template <typename T>
2994 class TypedTestP : public Test {
2995 };
2996
2997 TYPED_TEST_CASE_P(TypedTestP);
2998
TYPED_TEST_P(TypedTestP,DISABLED_ShouldNotRun)2999 TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) {
3000 FAIL() << "Unexpected failure: "
3001 << "Disabled type-parameterized test should not run.";
3002 }
3003
3004 REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun);
3005
3006 INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes);
3007
3008 template <typename T>
3009 class DISABLED_TypedTestP : public Test {
3010 };
3011
3012 TYPED_TEST_CASE_P(DISABLED_TypedTestP);
3013
TYPED_TEST_P(DISABLED_TypedTestP,ShouldNotRun)3014 TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) {
3015 FAIL() << "Unexpected failure: "
3016 << "Disabled type-parameterized test should not run.";
3017 }
3018
3019 REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun);
3020
3021 INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes);
3022
3023 #endif // GTEST_HAS_TYPED_TEST_P
3024
3025 // Tests that assertion macros evaluate their arguments exactly once.
3026
3027 class SingleEvaluationTest : public Test {
3028 public: // Must be public and not protected due to a bug in g++ 3.4.2.
3029 // This helper function is needed by the FailedASSERT_STREQ test
3030 // below. It's public to work around C++Builder's bug with scoping local
3031 // classes.
CompareAndIncrementCharPtrs()3032 static void CompareAndIncrementCharPtrs() {
3033 ASSERT_STREQ(p1_++, p2_++);
3034 }
3035
3036 // This helper function is needed by the FailedASSERT_NE test below. It's
3037 // public to work around C++Builder's bug with scoping local classes.
CompareAndIncrementInts()3038 static void CompareAndIncrementInts() {
3039 ASSERT_NE(a_++, b_++);
3040 }
3041
3042 protected:
SingleEvaluationTest()3043 SingleEvaluationTest() {
3044 p1_ = s1_;
3045 p2_ = s2_;
3046 a_ = 0;
3047 b_ = 0;
3048 }
3049
3050 static const char* const s1_;
3051 static const char* const s2_;
3052 static const char* p1_;
3053 static const char* p2_;
3054
3055 static int a_;
3056 static int b_;
3057 };
3058
3059 const char* const SingleEvaluationTest::s1_ = "01234";
3060 const char* const SingleEvaluationTest::s2_ = "abcde";
3061 const char* SingleEvaluationTest::p1_;
3062 const char* SingleEvaluationTest::p2_;
3063 int SingleEvaluationTest::a_;
3064 int SingleEvaluationTest::b_;
3065
3066 // Tests that when ASSERT_STREQ fails, it evaluates its arguments
3067 // exactly once.
TEST_F(SingleEvaluationTest,FailedASSERT_STREQ)3068 TEST_F(SingleEvaluationTest, FailedASSERT_STREQ) {
3069 EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(),
3070 "p2_++");
3071 EXPECT_EQ(s1_ + 1, p1_);
3072 EXPECT_EQ(s2_ + 1, p2_);
3073 }
3074
3075 // Tests that string assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest,ASSERT_STR)3076 TEST_F(SingleEvaluationTest, ASSERT_STR) {
3077 // successful EXPECT_STRNE
3078 EXPECT_STRNE(p1_++, p2_++);
3079 EXPECT_EQ(s1_ + 1, p1_);
3080 EXPECT_EQ(s2_ + 1, p2_);
3081
3082 // failed EXPECT_STRCASEEQ
3083 EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++),
3084 "ignoring case");
3085 EXPECT_EQ(s1_ + 2, p1_);
3086 EXPECT_EQ(s2_ + 2, p2_);
3087 }
3088
3089 // Tests that when ASSERT_NE fails, it evaluates its arguments exactly
3090 // once.
TEST_F(SingleEvaluationTest,FailedASSERT_NE)3091 TEST_F(SingleEvaluationTest, FailedASSERT_NE) {
3092 EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(),
3093 "(a_++) != (b_++)");
3094 EXPECT_EQ(1, a_);
3095 EXPECT_EQ(1, b_);
3096 }
3097
3098 // Tests that assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest,OtherCases)3099 TEST_F(SingleEvaluationTest, OtherCases) {
3100 // successful EXPECT_TRUE
3101 EXPECT_TRUE(0 == a_++); // NOLINT
3102 EXPECT_EQ(1, a_);
3103
3104 // failed EXPECT_TRUE
3105 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++");
3106 EXPECT_EQ(2, a_);
3107
3108 // successful EXPECT_GT
3109 EXPECT_GT(a_++, b_++);
3110 EXPECT_EQ(3, a_);
3111 EXPECT_EQ(1, b_);
3112
3113 // failed EXPECT_LT
3114 EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)");
3115 EXPECT_EQ(4, a_);
3116 EXPECT_EQ(2, b_);
3117
3118 // successful ASSERT_TRUE
3119 ASSERT_TRUE(0 < a_++); // NOLINT
3120 EXPECT_EQ(5, a_);
3121
3122 // successful ASSERT_GT
3123 ASSERT_GT(a_++, b_++);
3124 EXPECT_EQ(6, a_);
3125 EXPECT_EQ(3, b_);
3126 }
3127
3128 #if GTEST_HAS_EXCEPTIONS
3129
ThrowAnInteger()3130 void ThrowAnInteger() {
3131 throw 1;
3132 }
3133
3134 // Tests that assertion arguments are evaluated exactly once.
TEST_F(SingleEvaluationTest,ExceptionTests)3135 TEST_F(SingleEvaluationTest, ExceptionTests) {
3136 // successful EXPECT_THROW
3137 EXPECT_THROW({ // NOLINT
3138 a_++;
3139 ThrowAnInteger();
3140 }, int);
3141 EXPECT_EQ(1, a_);
3142
3143 // failed EXPECT_THROW, throws different
3144 EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT
3145 a_++;
3146 ThrowAnInteger();
3147 }, bool), "throws a different type");
3148 EXPECT_EQ(2, a_);
3149
3150 // failed EXPECT_THROW, throws nothing
3151 EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing");
3152 EXPECT_EQ(3, a_);
3153
3154 // successful EXPECT_NO_THROW
3155 EXPECT_NO_THROW(a_++);
3156 EXPECT_EQ(4, a_);
3157
3158 // failed EXPECT_NO_THROW
3159 EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT
3160 a_++;
3161 ThrowAnInteger();
3162 }), "it throws");
3163 EXPECT_EQ(5, a_);
3164
3165 // successful EXPECT_ANY_THROW
3166 EXPECT_ANY_THROW({ // NOLINT
3167 a_++;
3168 ThrowAnInteger();
3169 });
3170 EXPECT_EQ(6, a_);
3171
3172 // failed EXPECT_ANY_THROW
3173 EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't");
3174 EXPECT_EQ(7, a_);
3175 }
3176
3177 #endif // GTEST_HAS_EXCEPTIONS
3178
3179 // Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE.
3180 class NoFatalFailureTest : public Test {
3181 protected:
Succeeds()3182 void Succeeds() {}
FailsNonFatal()3183 void FailsNonFatal() {
3184 ADD_FAILURE() << "some non-fatal failure";
3185 }
Fails()3186 void Fails() {
3187 FAIL() << "some fatal failure";
3188 }
3189
DoAssertNoFatalFailureOnFails()3190 void DoAssertNoFatalFailureOnFails() {
3191 ASSERT_NO_FATAL_FAILURE(Fails());
3192 ADD_FAILURE() << "shold not reach here.";
3193 }
3194
DoExpectNoFatalFailureOnFails()3195 void DoExpectNoFatalFailureOnFails() {
3196 EXPECT_NO_FATAL_FAILURE(Fails());
3197 ADD_FAILURE() << "other failure";
3198 }
3199 };
3200
TEST_F(NoFatalFailureTest,NoFailure)3201 TEST_F(NoFatalFailureTest, NoFailure) {
3202 EXPECT_NO_FATAL_FAILURE(Succeeds());
3203 ASSERT_NO_FATAL_FAILURE(Succeeds());
3204 }
3205
TEST_F(NoFatalFailureTest,NonFatalIsNoFailure)3206 TEST_F(NoFatalFailureTest, NonFatalIsNoFailure) {
3207 EXPECT_NONFATAL_FAILURE(
3208 EXPECT_NO_FATAL_FAILURE(FailsNonFatal()),
3209 "some non-fatal failure");
3210 EXPECT_NONFATAL_FAILURE(
3211 ASSERT_NO_FATAL_FAILURE(FailsNonFatal()),
3212 "some non-fatal failure");
3213 }
3214
TEST_F(NoFatalFailureTest,AssertNoFatalFailureOnFatalFailure)3215 TEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) {
3216 TestPartResultArray gtest_failures;
3217 {
3218 ScopedFakeTestPartResultReporter gtest_reporter(>est_failures);
3219 DoAssertNoFatalFailureOnFails();
3220 }
3221 ASSERT_EQ(2, gtest_failures.size());
3222 EXPECT_EQ(TestPartResult::kFatalFailure,
3223 gtest_failures.GetTestPartResult(0).type());
3224 EXPECT_EQ(TestPartResult::kFatalFailure,
3225 gtest_failures.GetTestPartResult(1).type());
3226 EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
3227 gtest_failures.GetTestPartResult(0).message());
3228 EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
3229 gtest_failures.GetTestPartResult(1).message());
3230 }
3231
TEST_F(NoFatalFailureTest,ExpectNoFatalFailureOnFatalFailure)3232 TEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) {
3233 TestPartResultArray gtest_failures;
3234 {
3235 ScopedFakeTestPartResultReporter gtest_reporter(>est_failures);
3236 DoExpectNoFatalFailureOnFails();
3237 }
3238 ASSERT_EQ(3, gtest_failures.size());
3239 EXPECT_EQ(TestPartResult::kFatalFailure,
3240 gtest_failures.GetTestPartResult(0).type());
3241 EXPECT_EQ(TestPartResult::kNonFatalFailure,
3242 gtest_failures.GetTestPartResult(1).type());
3243 EXPECT_EQ(TestPartResult::kNonFatalFailure,
3244 gtest_failures.GetTestPartResult(2).type());
3245 EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure",
3246 gtest_failures.GetTestPartResult(0).message());
3247 EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does",
3248 gtest_failures.GetTestPartResult(1).message());
3249 EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure",
3250 gtest_failures.GetTestPartResult(2).message());
3251 }
3252
TEST_F(NoFatalFailureTest,MessageIsStreamable)3253 TEST_F(NoFatalFailureTest, MessageIsStreamable) {
3254 TestPartResultArray gtest_failures;
3255 {
3256 ScopedFakeTestPartResultReporter gtest_reporter(>est_failures);
3257 EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message";
3258 }
3259 ASSERT_EQ(2, gtest_failures.size());
3260 EXPECT_EQ(TestPartResult::kNonFatalFailure,
3261 gtest_failures.GetTestPartResult(0).type());
3262 EXPECT_EQ(TestPartResult::kNonFatalFailure,
3263 gtest_failures.GetTestPartResult(1).type());
3264 EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo",
3265 gtest_failures.GetTestPartResult(0).message());
3266 EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message",
3267 gtest_failures.GetTestPartResult(1).message());
3268 }
3269
3270 // Tests non-string assertions.
3271
3272 // Tests EqFailure(), used for implementing *EQ* assertions.
TEST(AssertionTest,EqFailure)3273 TEST(AssertionTest, EqFailure) {
3274 const std::string foo_val("5"), bar_val("6");
3275 const std::string msg1(
3276 EqFailure("foo", "bar", foo_val, bar_val, false)
3277 .failure_message());
3278 EXPECT_STREQ(
3279 "Value of: bar\n"
3280 " Actual: 6\n"
3281 "Expected: foo\n"
3282 "Which is: 5",
3283 msg1.c_str());
3284
3285 const std::string msg2(
3286 EqFailure("foo", "6", foo_val, bar_val, false)
3287 .failure_message());
3288 EXPECT_STREQ(
3289 "Value of: 6\n"
3290 "Expected: foo\n"
3291 "Which is: 5",
3292 msg2.c_str());
3293
3294 const std::string msg3(
3295 EqFailure("5", "bar", foo_val, bar_val, false)
3296 .failure_message());
3297 EXPECT_STREQ(
3298 "Value of: bar\n"
3299 " Actual: 6\n"
3300 "Expected: 5",
3301 msg3.c_str());
3302
3303 const std::string msg4(
3304 EqFailure("5", "6", foo_val, bar_val, false).failure_message());
3305 EXPECT_STREQ(
3306 "Value of: 6\n"
3307 "Expected: 5",
3308 msg4.c_str());
3309
3310 const std::string msg5(
3311 EqFailure("foo", "bar",
3312 std::string("\"x\""), std::string("\"y\""),
3313 true).failure_message());
3314 EXPECT_STREQ(
3315 "Value of: bar\n"
3316 " Actual: \"y\"\n"
3317 "Expected: foo (ignoring case)\n"
3318 "Which is: \"x\"",
3319 msg5.c_str());
3320 }
3321
3322 // Tests AppendUserMessage(), used for implementing the *EQ* macros.
TEST(AssertionTest,AppendUserMessage)3323 TEST(AssertionTest, AppendUserMessage) {
3324 const std::string foo("foo");
3325
3326 Message msg;
3327 EXPECT_STREQ("foo",
3328 AppendUserMessage(foo, msg).c_str());
3329
3330 msg << "bar";
3331 EXPECT_STREQ("foo\nbar",
3332 AppendUserMessage(foo, msg).c_str());
3333 }
3334
3335 #ifdef __BORLANDC__
3336 // Silences warnings: "Condition is always true", "Unreachable code"
3337 # pragma option push -w-ccc -w-rch
3338 #endif
3339
3340 // Tests ASSERT_TRUE.
TEST(AssertionTest,ASSERT_TRUE)3341 TEST(AssertionTest, ASSERT_TRUE) {
3342 ASSERT_TRUE(2 > 1); // NOLINT
3343 EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1),
3344 "2 < 1");
3345 }
3346
3347 // Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult.
TEST(AssertionTest,AssertTrueWithAssertionResult)3348 TEST(AssertionTest, AssertTrueWithAssertionResult) {
3349 ASSERT_TRUE(ResultIsEven(2));
3350 #ifndef __BORLANDC__
3351 // ICE's in C++Builder.
3352 EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)),
3353 "Value of: ResultIsEven(3)\n"
3354 " Actual: false (3 is odd)\n"
3355 "Expected: true");
3356 #endif
3357 ASSERT_TRUE(ResultIsEvenNoExplanation(2));
3358 EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)),
3359 "Value of: ResultIsEvenNoExplanation(3)\n"
3360 " Actual: false (3 is odd)\n"
3361 "Expected: true");
3362 }
3363
3364 // Tests ASSERT_FALSE.
TEST(AssertionTest,ASSERT_FALSE)3365 TEST(AssertionTest, ASSERT_FALSE) {
3366 ASSERT_FALSE(2 < 1); // NOLINT
3367 EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1),
3368 "Value of: 2 > 1\n"
3369 " Actual: true\n"
3370 "Expected: false");
3371 }
3372
3373 // Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult.
TEST(AssertionTest,AssertFalseWithAssertionResult)3374 TEST(AssertionTest, AssertFalseWithAssertionResult) {
3375 ASSERT_FALSE(ResultIsEven(3));
3376 #ifndef __BORLANDC__
3377 // ICE's in C++Builder.
3378 EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)),
3379 "Value of: ResultIsEven(2)\n"
3380 " Actual: true (2 is even)\n"
3381 "Expected: false");
3382 #endif
3383 ASSERT_FALSE(ResultIsEvenNoExplanation(3));
3384 EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)),
3385 "Value of: ResultIsEvenNoExplanation(2)\n"
3386 " Actual: true\n"
3387 "Expected: false");
3388 }
3389
3390 #ifdef __BORLANDC__
3391 // Restores warnings after previous "#pragma option push" supressed them
3392 # pragma option pop
3393 #endif
3394
3395 // Tests using ASSERT_EQ on double values. The purpose is to make
3396 // sure that the specialization we did for integer and anonymous enums
3397 // isn't used for double arguments.
TEST(ExpectTest,ASSERT_EQ_Double)3398 TEST(ExpectTest, ASSERT_EQ_Double) {
3399 // A success.
3400 ASSERT_EQ(5.6, 5.6);
3401
3402 // A failure.
3403 EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2),
3404 "5.1");
3405 }
3406
3407 // Tests ASSERT_EQ.
TEST(AssertionTest,ASSERT_EQ)3408 TEST(AssertionTest, ASSERT_EQ) {
3409 ASSERT_EQ(5, 2 + 3);
3410 EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
3411 "Value of: 2*3\n"
3412 " Actual: 6\n"
3413 "Expected: 5");
3414 }
3415
3416 // Tests ASSERT_EQ(NULL, pointer).
3417 #if GTEST_CAN_COMPARE_NULL
TEST(AssertionTest,ASSERT_EQ_NULL)3418 TEST(AssertionTest, ASSERT_EQ_NULL) {
3419 // A success.
3420 const char* p = NULL;
3421 // Some older GCC versions may issue a spurious waring in this or the next
3422 // assertion statement. This warning should not be suppressed with
3423 // static_cast since the test verifies the ability to use bare NULL as the
3424 // expected parameter to the macro.
3425 ASSERT_EQ(NULL, p);
3426
3427 // A failure.
3428 static int n = 0;
3429 EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
3430 "Value of: &n\n");
3431 }
3432 #endif // GTEST_CAN_COMPARE_NULL
3433
3434 // Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be
3435 // treated as a null pointer by the compiler, we need to make sure
3436 // that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as
3437 // ASSERT_EQ(static_cast<void*>(NULL), non_pointer).
TEST(ExpectTest,ASSERT_EQ_0)3438 TEST(ExpectTest, ASSERT_EQ_0) {
3439 int n = 0;
3440
3441 // A success.
3442 ASSERT_EQ(0, n);
3443
3444 // A failure.
3445 EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
3446 "Expected: 0");
3447 }
3448
3449 // Tests ASSERT_NE.
TEST(AssertionTest,ASSERT_NE)3450 TEST(AssertionTest, ASSERT_NE) {
3451 ASSERT_NE(6, 7);
3452 EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'),
3453 "Expected: ('a') != ('a'), "
3454 "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
3455 }
3456
3457 // Tests ASSERT_LE.
TEST(AssertionTest,ASSERT_LE)3458 TEST(AssertionTest, ASSERT_LE) {
3459 ASSERT_LE(2, 3);
3460 ASSERT_LE(2, 2);
3461 EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0),
3462 "Expected: (2) <= (0), actual: 2 vs 0");
3463 }
3464
3465 // Tests ASSERT_LT.
TEST(AssertionTest,ASSERT_LT)3466 TEST(AssertionTest, ASSERT_LT) {
3467 ASSERT_LT(2, 3);
3468 EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2),
3469 "Expected: (2) < (2), actual: 2 vs 2");
3470 }
3471
3472 // Tests ASSERT_GE.
TEST(AssertionTest,ASSERT_GE)3473 TEST(AssertionTest, ASSERT_GE) {
3474 ASSERT_GE(2, 1);
3475 ASSERT_GE(2, 2);
3476 EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3),
3477 "Expected: (2) >= (3), actual: 2 vs 3");
3478 }
3479
3480 // Tests ASSERT_GT.
TEST(AssertionTest,ASSERT_GT)3481 TEST(AssertionTest, ASSERT_GT) {
3482 ASSERT_GT(2, 1);
3483 EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2),
3484 "Expected: (2) > (2), actual: 2 vs 2");
3485 }
3486
3487 #if GTEST_HAS_EXCEPTIONS
3488
ThrowNothing()3489 void ThrowNothing() {}
3490
3491 // Tests ASSERT_THROW.
TEST(AssertionTest,ASSERT_THROW)3492 TEST(AssertionTest, ASSERT_THROW) {
3493 ASSERT_THROW(ThrowAnInteger(), int);
3494
3495 # ifndef __BORLANDC__
3496
3497 // ICE's in C++Builder 2007 and 2009.
3498 EXPECT_FATAL_FAILURE(
3499 ASSERT_THROW(ThrowAnInteger(), bool),
3500 "Expected: ThrowAnInteger() throws an exception of type bool.\n"
3501 " Actual: it throws a different type.");
3502 # endif
3503
3504 EXPECT_FATAL_FAILURE(
3505 ASSERT_THROW(ThrowNothing(), bool),
3506 "Expected: ThrowNothing() throws an exception of type bool.\n"
3507 " Actual: it throws nothing.");
3508 }
3509
3510 // Tests ASSERT_NO_THROW.
TEST(AssertionTest,ASSERT_NO_THROW)3511 TEST(AssertionTest, ASSERT_NO_THROW) {
3512 ASSERT_NO_THROW(ThrowNothing());
3513 EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()),
3514 "Expected: ThrowAnInteger() doesn't throw an exception."
3515 "\n Actual: it throws.");
3516 }
3517
3518 // Tests ASSERT_ANY_THROW.
TEST(AssertionTest,ASSERT_ANY_THROW)3519 TEST(AssertionTest, ASSERT_ANY_THROW) {
3520 ASSERT_ANY_THROW(ThrowAnInteger());
3521 EXPECT_FATAL_FAILURE(
3522 ASSERT_ANY_THROW(ThrowNothing()),
3523 "Expected: ThrowNothing() throws an exception.\n"
3524 " Actual: it doesn't.");
3525 }
3526
3527 #endif // GTEST_HAS_EXCEPTIONS
3528
3529 // Makes sure we deal with the precedence of <<. This test should
3530 // compile.
TEST(AssertionTest,AssertPrecedence)3531 TEST(AssertionTest, AssertPrecedence) {
3532 ASSERT_EQ(1 < 2, true);
3533 bool false_value = false;
3534 ASSERT_EQ(true && false_value, false);
3535 }
3536
3537 // A subroutine used by the following test.
TestEq1(int x)3538 void TestEq1(int x) {
3539 ASSERT_EQ(1, x);
3540 }
3541
3542 // Tests calling a test subroutine that's not part of a fixture.
TEST(AssertionTest,NonFixtureSubroutine)3543 TEST(AssertionTest, NonFixtureSubroutine) {
3544 EXPECT_FATAL_FAILURE(TestEq1(2),
3545 "Value of: x");
3546 }
3547
3548 // An uncopyable class.
3549 class Uncopyable {
3550 public:
Uncopyable(int a_value)3551 explicit Uncopyable(int a_value) : value_(a_value) {}
3552
value() const3553 int value() const { return value_; }
operator ==(const Uncopyable & rhs) const3554 bool operator==(const Uncopyable& rhs) const {
3555 return value() == rhs.value();
3556 }
3557 private:
3558 // This constructor deliberately has no implementation, as we don't
3559 // want this class to be copyable.
3560 Uncopyable(const Uncopyable&); // NOLINT
3561
3562 int value_;
3563 };
3564
operator <<(::std::ostream & os,const Uncopyable & value)3565 ::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) {
3566 return os << value.value();
3567 }
3568
3569
IsPositiveUncopyable(const Uncopyable & x)3570 bool IsPositiveUncopyable(const Uncopyable& x) {
3571 return x.value() > 0;
3572 }
3573
3574 // A subroutine used by the following test.
TestAssertNonPositive()3575 void TestAssertNonPositive() {
3576 Uncopyable y(-1);
3577 ASSERT_PRED1(IsPositiveUncopyable, y);
3578 }
3579 // A subroutine used by the following test.
TestAssertEqualsUncopyable()3580 void TestAssertEqualsUncopyable() {
3581 Uncopyable x(5);
3582 Uncopyable y(-1);
3583 ASSERT_EQ(x, y);
3584 }
3585
3586 // Tests that uncopyable objects can be used in assertions.
TEST(AssertionTest,AssertWorksWithUncopyableObject)3587 TEST(AssertionTest, AssertWorksWithUncopyableObject) {
3588 Uncopyable x(5);
3589 ASSERT_PRED1(IsPositiveUncopyable, x);
3590 ASSERT_EQ(x, x);
3591 EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
3592 "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
3593 EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
3594 "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5");
3595 }
3596
3597 // Tests that uncopyable objects can be used in expects.
TEST(AssertionTest,ExpectWorksWithUncopyableObject)3598 TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
3599 Uncopyable x(5);
3600 EXPECT_PRED1(IsPositiveUncopyable, x);
3601 Uncopyable y(-1);
3602 EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y),
3603 "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
3604 EXPECT_EQ(x, x);
3605 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
3606 "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5");
3607 }
3608
3609 enum NamedEnum {
3610 kE1 = 0,
3611 kE2 = 1
3612 };
3613
TEST(AssertionTest,NamedEnum)3614 TEST(AssertionTest, NamedEnum) {
3615 EXPECT_EQ(kE1, kE1);
3616 EXPECT_LT(kE1, kE2);
3617 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0");
3618 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1");
3619 }
3620
3621 // The version of gcc used in XCode 2.2 has a bug and doesn't allow
3622 // anonymous enums in assertions. Therefore the following test is not
3623 // done on Mac.
3624 // Sun Studio and HP aCC also reject this code.
3625 #if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC)
3626
3627 // Tests using assertions with anonymous enums.
3628 enum {
3629 kCaseA = -1,
3630
3631 # if GTEST_OS_LINUX
3632
3633 // We want to test the case where the size of the anonymous enum is
3634 // larger than sizeof(int), to make sure our implementation of the
3635 // assertions doesn't truncate the enums. However, MSVC
3636 // (incorrectly) doesn't allow an enum value to exceed the range of
3637 // an int, so this has to be conditionally compiled.
3638 //
3639 // On Linux, kCaseB and kCaseA have the same value when truncated to
3640 // int size. We want to test whether this will confuse the
3641 // assertions.
3642 kCaseB = testing::internal::kMaxBiggestInt,
3643
3644 # else
3645
3646 kCaseB = INT_MAX,
3647
3648 # endif // GTEST_OS_LINUX
3649
3650 kCaseC = 42
3651 };
3652
TEST(AssertionTest,AnonymousEnum)3653 TEST(AssertionTest, AnonymousEnum) {
3654 # if GTEST_OS_LINUX
3655
3656 EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
3657
3658 # endif // GTEST_OS_LINUX
3659
3660 EXPECT_EQ(kCaseA, kCaseA);
3661 EXPECT_NE(kCaseA, kCaseB);
3662 EXPECT_LT(kCaseA, kCaseB);
3663 EXPECT_LE(kCaseA, kCaseB);
3664 EXPECT_GT(kCaseB, kCaseA);
3665 EXPECT_GE(kCaseA, kCaseA);
3666 EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB),
3667 "(kCaseA) >= (kCaseB)");
3668 EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC),
3669 "-1 vs 42");
3670
3671 ASSERT_EQ(kCaseA, kCaseA);
3672 ASSERT_NE(kCaseA, kCaseB);
3673 ASSERT_LT(kCaseA, kCaseB);
3674 ASSERT_LE(kCaseA, kCaseB);
3675 ASSERT_GT(kCaseB, kCaseA);
3676 ASSERT_GE(kCaseA, kCaseA);
3677
3678 # ifndef __BORLANDC__
3679
3680 // ICE's in C++Builder.
3681 EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
3682 "Value of: kCaseB");
3683 EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
3684 "Actual: 42");
3685 # endif
3686
3687 EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
3688 "Which is: -1");
3689 }
3690
3691 #endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
3692
3693 #if GTEST_OS_WINDOWS
3694
UnexpectedHRESULTFailure()3695 static HRESULT UnexpectedHRESULTFailure() {
3696 return E_UNEXPECTED;
3697 }
3698
OkHRESULTSuccess()3699 static HRESULT OkHRESULTSuccess() {
3700 return S_OK;
3701 }
3702
FalseHRESULTSuccess()3703 static HRESULT FalseHRESULTSuccess() {
3704 return S_FALSE;
3705 }
3706
3707 // HRESULT assertion tests test both zero and non-zero
3708 // success codes as well as failure message for each.
3709 //
3710 // Windows CE doesn't support message texts.
TEST(HRESULTAssertionTest,EXPECT_HRESULT_SUCCEEDED)3711 TEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) {
3712 EXPECT_HRESULT_SUCCEEDED(S_OK);
3713 EXPECT_HRESULT_SUCCEEDED(S_FALSE);
3714
3715 EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
3716 "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
3717 " Actual: 0x8000FFFF");
3718 }
3719
TEST(HRESULTAssertionTest,ASSERT_HRESULT_SUCCEEDED)3720 TEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) {
3721 ASSERT_HRESULT_SUCCEEDED(S_OK);
3722 ASSERT_HRESULT_SUCCEEDED(S_FALSE);
3723
3724 EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()),
3725 "Expected: (UnexpectedHRESULTFailure()) succeeds.\n"
3726 " Actual: 0x8000FFFF");
3727 }
3728
TEST(HRESULTAssertionTest,EXPECT_HRESULT_FAILED)3729 TEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) {
3730 EXPECT_HRESULT_FAILED(E_UNEXPECTED);
3731
3732 EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()),
3733 "Expected: (OkHRESULTSuccess()) fails.\n"
3734 " Actual: 0x00000000");
3735 EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()),
3736 "Expected: (FalseHRESULTSuccess()) fails.\n"
3737 " Actual: 0x00000001");
3738 }
3739
TEST(HRESULTAssertionTest,ASSERT_HRESULT_FAILED)3740 TEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) {
3741 ASSERT_HRESULT_FAILED(E_UNEXPECTED);
3742
3743 # ifndef __BORLANDC__
3744
3745 // ICE's in C++Builder 2007 and 2009.
3746 EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()),
3747 "Expected: (OkHRESULTSuccess()) fails.\n"
3748 " Actual: 0x00000000");
3749 # endif
3750
3751 EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()),
3752 "Expected: (FalseHRESULTSuccess()) fails.\n"
3753 " Actual: 0x00000001");
3754 }
3755
3756 // Tests that streaming to the HRESULT macros works.
TEST(HRESULTAssertionTest,Streaming)3757 TEST(HRESULTAssertionTest, Streaming) {
3758 EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
3759 ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure";
3760 EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
3761 ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure";
3762
3763 EXPECT_NONFATAL_FAILURE(
3764 EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
3765 "expected failure");
3766
3767 # ifndef __BORLANDC__
3768
3769 // ICE's in C++Builder 2007 and 2009.
3770 EXPECT_FATAL_FAILURE(
3771 ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure",
3772 "expected failure");
3773 # endif
3774
3775 EXPECT_NONFATAL_FAILURE(
3776 EXPECT_HRESULT_FAILED(S_OK) << "expected failure",
3777 "expected failure");
3778
3779 EXPECT_FATAL_FAILURE(
3780 ASSERT_HRESULT_FAILED(S_OK) << "expected failure",
3781 "expected failure");
3782 }
3783
3784 #endif // GTEST_OS_WINDOWS
3785
3786 #ifdef __BORLANDC__
3787 // Silences warnings: "Condition is always true", "Unreachable code"
3788 # pragma option push -w-ccc -w-rch
3789 #endif
3790
3791 // Tests that the assertion macros behave like single statements.
TEST(AssertionSyntaxTest,BasicAssertionsBehavesLikeSingleStatement)3792 TEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) {
3793 if (AlwaysFalse())
3794 ASSERT_TRUE(false) << "This should never be executed; "
3795 "It's a compilation test only.";
3796
3797 if (AlwaysTrue())
3798 EXPECT_FALSE(false);
3799 else
3800 ; // NOLINT
3801
3802 if (AlwaysFalse())
3803 ASSERT_LT(1, 3);
3804
3805 if (AlwaysFalse())
3806 ; // NOLINT
3807 else
3808 EXPECT_GT(3, 2) << "";
3809 }
3810
3811 #if GTEST_HAS_EXCEPTIONS
3812 // Tests that the compiler will not complain about unreachable code in the
3813 // EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros.
TEST(ExpectThrowTest,DoesNotGenerateUnreachableCodeWarning)3814 TEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) {
3815 int n = 0;
3816
3817 EXPECT_THROW(throw 1, int);
3818 EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), "");
3819 EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), "");
3820 EXPECT_NO_THROW(n++);
3821 EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), "");
3822 EXPECT_ANY_THROW(throw 1);
3823 EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), "");
3824 }
3825
TEST(AssertionSyntaxTest,ExceptionAssertionsBehavesLikeSingleStatement)3826 TEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) {
3827 if (AlwaysFalse())
3828 EXPECT_THROW(ThrowNothing(), bool);
3829
3830 if (AlwaysTrue())
3831 EXPECT_THROW(ThrowAnInteger(), int);
3832 else
3833 ; // NOLINT
3834
3835 if (AlwaysFalse())
3836 EXPECT_NO_THROW(ThrowAnInteger());
3837
3838 if (AlwaysTrue())
3839 EXPECT_NO_THROW(ThrowNothing());
3840 else
3841 ; // NOLINT
3842
3843 if (AlwaysFalse())
3844 EXPECT_ANY_THROW(ThrowNothing());
3845
3846 if (AlwaysTrue())
3847 EXPECT_ANY_THROW(ThrowAnInteger());
3848 else
3849 ; // NOLINT
3850 }
3851 #endif // GTEST_HAS_EXCEPTIONS
3852
TEST(AssertionSyntaxTest,NoFatalFailureAssertionsBehavesLikeSingleStatement)3853 TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
3854 if (AlwaysFalse())
3855 EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
3856 << "It's a compilation test only.";
3857 else
3858 ; // NOLINT
3859
3860 if (AlwaysFalse())
3861 ASSERT_NO_FATAL_FAILURE(FAIL()) << "";
3862 else
3863 ; // NOLINT
3864
3865 if (AlwaysTrue())
3866 EXPECT_NO_FATAL_FAILURE(SUCCEED());
3867 else
3868 ; // NOLINT
3869
3870 if (AlwaysFalse())
3871 ; // NOLINT
3872 else
3873 ASSERT_NO_FATAL_FAILURE(SUCCEED());
3874 }
3875
3876 // Tests that the assertion macros work well with switch statements.
TEST(AssertionSyntaxTest,WorksWithSwitch)3877 TEST(AssertionSyntaxTest, WorksWithSwitch) {
3878 switch (0) {
3879 case 1:
3880 break;
3881 default:
3882 ASSERT_TRUE(true);
3883 }
3884
3885 switch (0)
3886 case 0:
3887 EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case";
3888
3889 // Binary assertions are implemented using a different code path
3890 // than the Boolean assertions. Hence we test them separately.
3891 switch (0) {
3892 case 1:
3893 default:
3894 ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler";
3895 }
3896
3897 switch (0)
3898 case 0:
3899 EXPECT_NE(1, 2);
3900 }
3901
3902 #if GTEST_HAS_EXCEPTIONS
3903
ThrowAString()3904 void ThrowAString() {
3905 throw "std::string";
3906 }
3907
3908 // Test that the exception assertion macros compile and work with const
3909 // type qualifier.
TEST(AssertionSyntaxTest,WorksWithConst)3910 TEST(AssertionSyntaxTest, WorksWithConst) {
3911 ASSERT_THROW(ThrowAString(), const char*);
3912
3913 EXPECT_THROW(ThrowAString(), const char*);
3914 }
3915
3916 #endif // GTEST_HAS_EXCEPTIONS
3917
3918 } // namespace
3919
3920 namespace testing {
3921
3922 // Tests that Google Test tracks SUCCEED*.
TEST(SuccessfulAssertionTest,SUCCEED)3923 TEST(SuccessfulAssertionTest, SUCCEED) {
3924 SUCCEED();
3925 SUCCEED() << "OK";
3926 EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count());
3927 }
3928
3929 // Tests that Google Test doesn't track successful EXPECT_*.
TEST(SuccessfulAssertionTest,EXPECT)3930 TEST(SuccessfulAssertionTest, EXPECT) {
3931 EXPECT_TRUE(true);
3932 EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
3933 }
3934
3935 // Tests that Google Test doesn't track successful EXPECT_STR*.
TEST(SuccessfulAssertionTest,EXPECT_STR)3936 TEST(SuccessfulAssertionTest, EXPECT_STR) {
3937 EXPECT_STREQ("", "");
3938 EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
3939 }
3940
3941 // Tests that Google Test doesn't track successful ASSERT_*.
TEST(SuccessfulAssertionTest,ASSERT)3942 TEST(SuccessfulAssertionTest, ASSERT) {
3943 ASSERT_TRUE(true);
3944 EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
3945 }
3946
3947 // Tests that Google Test doesn't track successful ASSERT_STR*.
TEST(SuccessfulAssertionTest,ASSERT_STR)3948 TEST(SuccessfulAssertionTest, ASSERT_STR) {
3949 ASSERT_STREQ("", "");
3950 EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
3951 }
3952
3953 } // namespace testing
3954
3955 namespace {
3956
3957 // Tests the message streaming variation of assertions.
3958
TEST(AssertionWithMessageTest,EXPECT)3959 TEST(AssertionWithMessageTest, EXPECT) {
3960 EXPECT_EQ(1, 1) << "This should succeed.";
3961 EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.",
3962 "Expected failure #1");
3963 EXPECT_LE(1, 2) << "This should succeed.";
3964 EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.",
3965 "Expected failure #2.");
3966 EXPECT_GE(1, 0) << "This should succeed.";
3967 EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.",
3968 "Expected failure #3.");
3969
3970 EXPECT_STREQ("1", "1") << "This should succeed.";
3971 EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.",
3972 "Expected failure #4.");
3973 EXPECT_STRCASEEQ("a", "A") << "This should succeed.";
3974 EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.",
3975 "Expected failure #5.");
3976
3977 EXPECT_FLOAT_EQ(1, 1) << "This should succeed.";
3978 EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.",
3979 "Expected failure #6.");
3980 EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed.";
3981 }
3982
TEST(AssertionWithMessageTest,ASSERT)3983 TEST(AssertionWithMessageTest, ASSERT) {
3984 ASSERT_EQ(1, 1) << "This should succeed.";
3985 ASSERT_NE(1, 2) << "This should succeed.";
3986 ASSERT_LE(1, 2) << "This should succeed.";
3987 ASSERT_LT(1, 2) << "This should succeed.";
3988 ASSERT_GE(1, 0) << "This should succeed.";
3989 EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.",
3990 "Expected failure.");
3991 }
3992
TEST(AssertionWithMessageTest,ASSERT_STR)3993 TEST(AssertionWithMessageTest, ASSERT_STR) {
3994 ASSERT_STREQ("1", "1") << "This should succeed.";
3995 ASSERT_STRNE("1", "2") << "This should succeed.";
3996 ASSERT_STRCASEEQ("a", "A") << "This should succeed.";
3997 EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.",
3998 "Expected failure.");
3999 }
4000
TEST(AssertionWithMessageTest,ASSERT_FLOATING)4001 TEST(AssertionWithMessageTest, ASSERT_FLOATING) {
4002 ASSERT_FLOAT_EQ(1, 1) << "This should succeed.";
4003 ASSERT_DOUBLE_EQ(1, 1) << "This should succeed.";
4004 EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.", // NOLINT
4005 "Expect failure.");
4006 // To work around a bug in gcc 2.95.0, there is intentionally no
4007 // space after the first comma in the previous statement.
4008 }
4009
4010 // Tests using ASSERT_FALSE with a streamed message.
TEST(AssertionWithMessageTest,ASSERT_FALSE)4011 TEST(AssertionWithMessageTest, ASSERT_FALSE) {
4012 ASSERT_FALSE(false) << "This shouldn't fail.";
4013 EXPECT_FATAL_FAILURE({ // NOLINT
4014 ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1
4015 << " evaluates to " << true;
4016 }, "Expected failure");
4017 }
4018
4019 // Tests using FAIL with a streamed message.
TEST(AssertionWithMessageTest,FAIL)4020 TEST(AssertionWithMessageTest, FAIL) {
4021 EXPECT_FATAL_FAILURE(FAIL() << 0,
4022 "0");
4023 }
4024
4025 // Tests using SUCCEED with a streamed message.
TEST(AssertionWithMessageTest,SUCCEED)4026 TEST(AssertionWithMessageTest, SUCCEED) {
4027 SUCCEED() << "Success == " << 1;
4028 }
4029
4030 // Tests using ASSERT_TRUE with a streamed message.
TEST(AssertionWithMessageTest,ASSERT_TRUE)4031 TEST(AssertionWithMessageTest, ASSERT_TRUE) {
4032 ASSERT_TRUE(true) << "This should succeed.";
4033 ASSERT_TRUE(true) << true;
4034 EXPECT_FATAL_FAILURE({ // NOLINT
4035 ASSERT_TRUE(false) << static_cast<const char *>(NULL)
4036 << static_cast<char *>(NULL);
4037 }, "(null)(null)");
4038 }
4039
4040 #if GTEST_OS_WINDOWS
4041 // Tests using wide strings in assertion messages.
TEST(AssertionWithMessageTest,WideStringMessage)4042 TEST(AssertionWithMessageTest, WideStringMessage) {
4043 EXPECT_NONFATAL_FAILURE({ // NOLINT
4044 EXPECT_TRUE(false) << L"This failure is expected.\x8119";
4045 }, "This failure is expected.");
4046 EXPECT_FATAL_FAILURE({ // NOLINT
4047 ASSERT_EQ(1, 2) << "This failure is "
4048 << L"expected too.\x8120";
4049 }, "This failure is expected too.");
4050 }
4051 #endif // GTEST_OS_WINDOWS
4052
4053 // Tests EXPECT_TRUE.
TEST(ExpectTest,EXPECT_TRUE)4054 TEST(ExpectTest, EXPECT_TRUE) {
4055 EXPECT_TRUE(true) << "Intentional success";
4056 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.",
4057 "Intentional failure #1.");
4058 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.",
4059 "Intentional failure #2.");
4060 EXPECT_TRUE(2 > 1); // NOLINT
4061 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1),
4062 "Value of: 2 < 1\n"
4063 " Actual: false\n"
4064 "Expected: true");
4065 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3),
4066 "2 > 3");
4067 }
4068
4069 // Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult.
TEST(ExpectTest,ExpectTrueWithAssertionResult)4070 TEST(ExpectTest, ExpectTrueWithAssertionResult) {
4071 EXPECT_TRUE(ResultIsEven(2));
4072 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)),
4073 "Value of: ResultIsEven(3)\n"
4074 " Actual: false (3 is odd)\n"
4075 "Expected: true");
4076 EXPECT_TRUE(ResultIsEvenNoExplanation(2));
4077 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)),
4078 "Value of: ResultIsEvenNoExplanation(3)\n"
4079 " Actual: false (3 is odd)\n"
4080 "Expected: true");
4081 }
4082
4083 // Tests EXPECT_FALSE with a streamed message.
TEST(ExpectTest,EXPECT_FALSE)4084 TEST(ExpectTest, EXPECT_FALSE) {
4085 EXPECT_FALSE(2 < 1); // NOLINT
4086 EXPECT_FALSE(false) << "Intentional success";
4087 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.",
4088 "Intentional failure #1.");
4089 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.",
4090 "Intentional failure #2.");
4091 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1),
4092 "Value of: 2 > 1\n"
4093 " Actual: true\n"
4094 "Expected: false");
4095 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3),
4096 "2 < 3");
4097 }
4098
4099 // Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult.
TEST(ExpectTest,ExpectFalseWithAssertionResult)4100 TEST(ExpectTest, ExpectFalseWithAssertionResult) {
4101 EXPECT_FALSE(ResultIsEven(3));
4102 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)),
4103 "Value of: ResultIsEven(2)\n"
4104 " Actual: true (2 is even)\n"
4105 "Expected: false");
4106 EXPECT_FALSE(ResultIsEvenNoExplanation(3));
4107 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)),
4108 "Value of: ResultIsEvenNoExplanation(2)\n"
4109 " Actual: true\n"
4110 "Expected: false");
4111 }
4112
4113 #ifdef __BORLANDC__
4114 // Restores warnings after previous "#pragma option push" supressed them
4115 # pragma option pop
4116 #endif
4117
4118 // Tests EXPECT_EQ.
TEST(ExpectTest,EXPECT_EQ)4119 TEST(ExpectTest, EXPECT_EQ) {
4120 EXPECT_EQ(5, 2 + 3);
4121 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
4122 "Value of: 2*3\n"
4123 " Actual: 6\n"
4124 "Expected: 5");
4125 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
4126 "2 - 3");
4127 }
4128
4129 // Tests using EXPECT_EQ on double values. The purpose is to make
4130 // sure that the specialization we did for integer and anonymous enums
4131 // isn't used for double arguments.
TEST(ExpectTest,EXPECT_EQ_Double)4132 TEST(ExpectTest, EXPECT_EQ_Double) {
4133 // A success.
4134 EXPECT_EQ(5.6, 5.6);
4135
4136 // A failure.
4137 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2),
4138 "5.1");
4139 }
4140
4141 #if GTEST_CAN_COMPARE_NULL
4142 // Tests EXPECT_EQ(NULL, pointer).
TEST(ExpectTest,EXPECT_EQ_NULL)4143 TEST(ExpectTest, EXPECT_EQ_NULL) {
4144 // A success.
4145 const char* p = NULL;
4146 // Some older GCC versions may issue a spurious warning in this or the next
4147 // assertion statement. This warning should not be suppressed with
4148 // static_cast since the test verifies the ability to use bare NULL as the
4149 // expected parameter to the macro.
4150 EXPECT_EQ(NULL, p);
4151
4152 // A failure.
4153 int n = 0;
4154 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
4155 "Value of: &n\n");
4156 }
4157 #endif // GTEST_CAN_COMPARE_NULL
4158
4159 // Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be
4160 // treated as a null pointer by the compiler, we need to make sure
4161 // that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as
4162 // EXPECT_EQ(static_cast<void*>(NULL), non_pointer).
TEST(ExpectTest,EXPECT_EQ_0)4163 TEST(ExpectTest, EXPECT_EQ_0) {
4164 int n = 0;
4165
4166 // A success.
4167 EXPECT_EQ(0, n);
4168
4169 // A failure.
4170 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
4171 "Expected: 0");
4172 }
4173
4174 // Tests EXPECT_NE.
TEST(ExpectTest,EXPECT_NE)4175 TEST(ExpectTest, EXPECT_NE) {
4176 EXPECT_NE(6, 7);
4177
4178 EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'),
4179 "Expected: ('a') != ('a'), "
4180 "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)");
4181 EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2),
4182 "2");
4183 char* const p0 = NULL;
4184 EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0),
4185 "p0");
4186 // Only way to get the Nokia compiler to compile the cast
4187 // is to have a separate void* variable first. Putting
4188 // the two casts on the same line doesn't work, neither does
4189 // a direct C-style to char*.
4190 void* pv1 = (void*)0x1234; // NOLINT
4191 char* const p1 = reinterpret_cast<char*>(pv1);
4192 EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1),
4193 "p1");
4194 }
4195
4196 // Tests EXPECT_LE.
TEST(ExpectTest,EXPECT_LE)4197 TEST(ExpectTest, EXPECT_LE) {
4198 EXPECT_LE(2, 3);
4199 EXPECT_LE(2, 2);
4200 EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0),
4201 "Expected: (2) <= (0), actual: 2 vs 0");
4202 EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9),
4203 "(1.1) <= (0.9)");
4204 }
4205
4206 // Tests EXPECT_LT.
TEST(ExpectTest,EXPECT_LT)4207 TEST(ExpectTest, EXPECT_LT) {
4208 EXPECT_LT(2, 3);
4209 EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2),
4210 "Expected: (2) < (2), actual: 2 vs 2");
4211 EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1),
4212 "(2) < (1)");
4213 }
4214
4215 // Tests EXPECT_GE.
TEST(ExpectTest,EXPECT_GE)4216 TEST(ExpectTest, EXPECT_GE) {
4217 EXPECT_GE(2, 1);
4218 EXPECT_GE(2, 2);
4219 EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3),
4220 "Expected: (2) >= (3), actual: 2 vs 3");
4221 EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1),
4222 "(0.9) >= (1.1)");
4223 }
4224
4225 // Tests EXPECT_GT.
TEST(ExpectTest,EXPECT_GT)4226 TEST(ExpectTest, EXPECT_GT) {
4227 EXPECT_GT(2, 1);
4228 EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2),
4229 "Expected: (2) > (2), actual: 2 vs 2");
4230 EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3),
4231 "(2) > (3)");
4232 }
4233
4234 #if GTEST_HAS_EXCEPTIONS
4235
4236 // Tests EXPECT_THROW.
TEST(ExpectTest,EXPECT_THROW)4237 TEST(ExpectTest, EXPECT_THROW) {
4238 EXPECT_THROW(ThrowAnInteger(), int);
4239 EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool),
4240 "Expected: ThrowAnInteger() throws an exception of "
4241 "type bool.\n Actual: it throws a different type.");
4242 EXPECT_NONFATAL_FAILURE(
4243 EXPECT_THROW(ThrowNothing(), bool),
4244 "Expected: ThrowNothing() throws an exception of type bool.\n"
4245 " Actual: it throws nothing.");
4246 }
4247
4248 // Tests EXPECT_NO_THROW.
TEST(ExpectTest,EXPECT_NO_THROW)4249 TEST(ExpectTest, EXPECT_NO_THROW) {
4250 EXPECT_NO_THROW(ThrowNothing());
4251 EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()),
4252 "Expected: ThrowAnInteger() doesn't throw an "
4253 "exception.\n Actual: it throws.");
4254 }
4255
4256 // Tests EXPECT_ANY_THROW.
TEST(ExpectTest,EXPECT_ANY_THROW)4257 TEST(ExpectTest, EXPECT_ANY_THROW) {
4258 EXPECT_ANY_THROW(ThrowAnInteger());
4259 EXPECT_NONFATAL_FAILURE(
4260 EXPECT_ANY_THROW(ThrowNothing()),
4261 "Expected: ThrowNothing() throws an exception.\n"
4262 " Actual: it doesn't.");
4263 }
4264
4265 #endif // GTEST_HAS_EXCEPTIONS
4266
4267 // Make sure we deal with the precedence of <<.
TEST(ExpectTest,ExpectPrecedence)4268 TEST(ExpectTest, ExpectPrecedence) {
4269 EXPECT_EQ(1 < 2, true);
4270 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
4271 "Value of: true && false");
4272 }
4273
4274
4275 // Tests the StreamableToString() function.
4276
4277 // Tests using StreamableToString() on a scalar.
TEST(StreamableToStringTest,Scalar)4278 TEST(StreamableToStringTest, Scalar) {
4279 EXPECT_STREQ("5", StreamableToString(5).c_str());
4280 }
4281
4282 // Tests using StreamableToString() on a non-char pointer.
TEST(StreamableToStringTest,Pointer)4283 TEST(StreamableToStringTest, Pointer) {
4284 int n = 0;
4285 int* p = &n;
4286 EXPECT_STRNE("(null)", StreamableToString(p).c_str());
4287 }
4288
4289 // Tests using StreamableToString() on a NULL non-char pointer.
TEST(StreamableToStringTest,NullPointer)4290 TEST(StreamableToStringTest, NullPointer) {
4291 int* p = NULL;
4292 EXPECT_STREQ("(null)", StreamableToString(p).c_str());
4293 }
4294
4295 // Tests using StreamableToString() on a C string.
TEST(StreamableToStringTest,CString)4296 TEST(StreamableToStringTest, CString) {
4297 EXPECT_STREQ("Foo", StreamableToString("Foo").c_str());
4298 }
4299
4300 // Tests using StreamableToString() on a NULL C string.
TEST(StreamableToStringTest,NullCString)4301 TEST(StreamableToStringTest, NullCString) {
4302 char* p = NULL;
4303 EXPECT_STREQ("(null)", StreamableToString(p).c_str());
4304 }
4305
4306 // Tests using streamable values as assertion messages.
4307
4308 // Tests using std::string as an assertion message.
TEST(StreamableTest,string)4309 TEST(StreamableTest, string) {
4310 static const std::string str(
4311 "This failure message is a std::string, and is expected.");
4312 EXPECT_FATAL_FAILURE(FAIL() << str,
4313 str.c_str());
4314 }
4315
4316 // Tests that we can output strings containing embedded NULs.
4317 // Limited to Linux because we can only do this with std::string's.
TEST(StreamableTest,stringWithEmbeddedNUL)4318 TEST(StreamableTest, stringWithEmbeddedNUL) {
4319 static const char char_array_with_nul[] =
4320 "Here's a NUL\0 and some more string";
4321 static const std::string string_with_nul(char_array_with_nul,
4322 sizeof(char_array_with_nul)
4323 - 1); // drops the trailing NUL
4324 EXPECT_FATAL_FAILURE(FAIL() << string_with_nul,
4325 "Here's a NUL\\0 and some more string");
4326 }
4327
4328 // Tests that we can output a NUL char.
TEST(StreamableTest,NULChar)4329 TEST(StreamableTest, NULChar) {
4330 EXPECT_FATAL_FAILURE({ // NOLINT
4331 FAIL() << "A NUL" << '\0' << " and some more string";
4332 }, "A NUL\\0 and some more string");
4333 }
4334
4335 // Tests using int as an assertion message.
TEST(StreamableTest,int)4336 TEST(StreamableTest, int) {
4337 EXPECT_FATAL_FAILURE(FAIL() << 900913,
4338 "900913");
4339 }
4340
4341 // Tests using NULL char pointer as an assertion message.
4342 //
4343 // In MSVC, streaming a NULL char * causes access violation. Google Test
4344 // implemented a workaround (substituting "(null)" for NULL). This
4345 // tests whether the workaround works.
TEST(StreamableTest,NullCharPtr)4346 TEST(StreamableTest, NullCharPtr) {
4347 EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL),
4348 "(null)");
4349 }
4350
4351 // Tests that basic IO manipulators (endl, ends, and flush) can be
4352 // streamed to testing::Message.
TEST(StreamableTest,BasicIoManip)4353 TEST(StreamableTest, BasicIoManip) {
4354 EXPECT_FATAL_FAILURE({ // NOLINT
4355 FAIL() << "Line 1." << std::endl
4356 << "A NUL char " << std::ends << std::flush << " in line 2.";
4357 }, "Line 1.\nA NUL char \\0 in line 2.");
4358 }
4359
4360 // Tests the macros that haven't been covered so far.
4361
AddFailureHelper(bool * aborted)4362 void AddFailureHelper(bool* aborted) {
4363 *aborted = true;
4364 ADD_FAILURE() << "Intentional failure.";
4365 *aborted = false;
4366 }
4367
4368 // Tests ADD_FAILURE.
TEST(MacroTest,ADD_FAILURE)4369 TEST(MacroTest, ADD_FAILURE) {
4370 bool aborted = true;
4371 EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted),
4372 "Intentional failure.");
4373 EXPECT_FALSE(aborted);
4374 }
4375
4376 // Tests ADD_FAILURE_AT.
TEST(MacroTest,ADD_FAILURE_AT)4377 TEST(MacroTest, ADD_FAILURE_AT) {
4378 // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and
4379 // the failure message contains the user-streamed part.
4380 EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!");
4381
4382 // Verifies that the user-streamed part is optional.
4383 EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed");
4384
4385 // Unfortunately, we cannot verify that the failure message contains
4386 // the right file path and line number the same way, as
4387 // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and
4388 // line number. Instead, we do that in gtest_output_test_.cc.
4389 }
4390
4391 // Tests FAIL.
TEST(MacroTest,FAIL)4392 TEST(MacroTest, FAIL) {
4393 EXPECT_FATAL_FAILURE(FAIL(),
4394 "Failed");
4395 EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.",
4396 "Intentional failure.");
4397 }
4398
4399 // Tests SUCCEED
TEST(MacroTest,SUCCEED)4400 TEST(MacroTest, SUCCEED) {
4401 SUCCEED();
4402 SUCCEED() << "Explicit success.";
4403 }
4404
4405 // Tests for EXPECT_EQ() and ASSERT_EQ().
4406 //
4407 // These tests fail *intentionally*, s.t. the failure messages can be
4408 // generated and tested.
4409 //
4410 // We have different tests for different argument types.
4411
4412 // Tests using bool values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,Bool)4413 TEST(EqAssertionTest, Bool) {
4414 EXPECT_EQ(true, true);
4415 EXPECT_FATAL_FAILURE({
4416 bool false_value = false;
4417 ASSERT_EQ(false_value, true);
4418 }, "Value of: true");
4419 }
4420
4421 // Tests using int values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,Int)4422 TEST(EqAssertionTest, Int) {
4423 ASSERT_EQ(32, 32);
4424 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33),
4425 "33");
4426 }
4427
4428 // Tests using time_t values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,Time_T)4429 TEST(EqAssertionTest, Time_T) {
4430 EXPECT_EQ(static_cast<time_t>(0),
4431 static_cast<time_t>(0));
4432 EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0),
4433 static_cast<time_t>(1234)),
4434 "1234");
4435 }
4436
4437 // Tests using char values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,Char)4438 TEST(EqAssertionTest, Char) {
4439 ASSERT_EQ('z', 'z');
4440 const char ch = 'b';
4441 EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch),
4442 "ch");
4443 EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch),
4444 "ch");
4445 }
4446
4447 // Tests using wchar_t values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,WideChar)4448 TEST(EqAssertionTest, WideChar) {
4449 EXPECT_EQ(L'b', L'b');
4450
4451 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
4452 "Value of: L'x'\n"
4453 " Actual: L'x' (120, 0x78)\n"
4454 "Expected: L'\0'\n"
4455 "Which is: L'\0' (0, 0x0)");
4456
4457 static wchar_t wchar;
4458 wchar = L'b';
4459 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar),
4460 "wchar");
4461 wchar = 0x8119;
4462 EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
4463 "Value of: wchar");
4464 }
4465
4466 // Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,StdString)4467 TEST(EqAssertionTest, StdString) {
4468 // Compares a const char* to an std::string that has identical
4469 // content.
4470 ASSERT_EQ("Test", ::std::string("Test"));
4471
4472 // Compares two identical std::strings.
4473 static const ::std::string str1("A * in the middle");
4474 static const ::std::string str2(str1);
4475 EXPECT_EQ(str1, str2);
4476
4477 // Compares a const char* to an std::string that has different
4478 // content
4479 EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")),
4480 "::std::string(\"test\")");
4481
4482 // Compares an std::string to a char* that has different content.
4483 char* const p1 = const_cast<char*>("foo");
4484 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1),
4485 "p1");
4486
4487 // Compares two std::strings that have different contents, one of
4488 // which having a NUL character in the middle. This should fail.
4489 static ::std::string str3(str1);
4490 str3.at(2) = '\0';
4491 EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
4492 "Value of: str3\n"
4493 " Actual: \"A \\0 in the middle\"");
4494 }
4495
4496 #if GTEST_HAS_STD_WSTRING
4497
4498 // Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,StdWideString)4499 TEST(EqAssertionTest, StdWideString) {
4500 // Compares two identical std::wstrings.
4501 const ::std::wstring wstr1(L"A * in the middle");
4502 const ::std::wstring wstr2(wstr1);
4503 ASSERT_EQ(wstr1, wstr2);
4504
4505 // Compares an std::wstring to a const wchar_t* that has identical
4506 // content.
4507 const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
4508 EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119);
4509
4510 // Compares an std::wstring to a const wchar_t* that has different
4511 // content.
4512 const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
4513 EXPECT_NONFATAL_FAILURE({ // NOLINT
4514 EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120);
4515 }, "kTestX8120");
4516
4517 // Compares two std::wstrings that have different contents, one of
4518 // which having a NUL character in the middle.
4519 ::std::wstring wstr3(wstr1);
4520 wstr3.at(2) = L'\0';
4521 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3),
4522 "wstr3");
4523
4524 // Compares a wchar_t* to an std::wstring that has different
4525 // content.
4526 EXPECT_FATAL_FAILURE({ // NOLINT
4527 ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar"));
4528 }, "");
4529 }
4530
4531 #endif // GTEST_HAS_STD_WSTRING
4532
4533 #if GTEST_HAS_GLOBAL_STRING
4534 // Tests using ::string values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,GlobalString)4535 TEST(EqAssertionTest, GlobalString) {
4536 // Compares a const char* to a ::string that has identical content.
4537 EXPECT_EQ("Test", ::string("Test"));
4538
4539 // Compares two identical ::strings.
4540 const ::string str1("A * in the middle");
4541 const ::string str2(str1);
4542 ASSERT_EQ(str1, str2);
4543
4544 // Compares a ::string to a const char* that has different content.
4545 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"),
4546 "test");
4547
4548 // Compares two ::strings that have different contents, one of which
4549 // having a NUL character in the middle.
4550 ::string str3(str1);
4551 str3.at(2) = '\0';
4552 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3),
4553 "str3");
4554
4555 // Compares a ::string to a char* that has different content.
4556 EXPECT_FATAL_FAILURE({ // NOLINT
4557 ASSERT_EQ(::string("bar"), const_cast<char*>("foo"));
4558 }, "");
4559 }
4560
4561 #endif // GTEST_HAS_GLOBAL_STRING
4562
4563 #if GTEST_HAS_GLOBAL_WSTRING
4564
4565 // Tests using ::wstring values in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,GlobalWideString)4566 TEST(EqAssertionTest, GlobalWideString) {
4567 // Compares two identical ::wstrings.
4568 static const ::wstring wstr1(L"A * in the middle");
4569 static const ::wstring wstr2(wstr1);
4570 EXPECT_EQ(wstr1, wstr2);
4571
4572 // Compares a const wchar_t* to a ::wstring that has identical content.
4573 const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' };
4574 ASSERT_EQ(kTestX8119, ::wstring(kTestX8119));
4575
4576 // Compares a const wchar_t* to a ::wstring that has different
4577 // content.
4578 const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' };
4579 EXPECT_NONFATAL_FAILURE({ // NOLINT
4580 EXPECT_EQ(kTestX8120, ::wstring(kTestX8119));
4581 }, "Test\\x8119");
4582
4583 // Compares a wchar_t* to a ::wstring that has different content.
4584 wchar_t* const p1 = const_cast<wchar_t*>(L"foo");
4585 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")),
4586 "bar");
4587
4588 // Compares two ::wstrings that have different contents, one of which
4589 // having a NUL character in the middle.
4590 static ::wstring wstr3;
4591 wstr3 = wstr1;
4592 wstr3.at(2) = L'\0';
4593 EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3),
4594 "wstr3");
4595 }
4596
4597 #endif // GTEST_HAS_GLOBAL_WSTRING
4598
4599 // Tests using char pointers in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,CharPointer)4600 TEST(EqAssertionTest, CharPointer) {
4601 char* const p0 = NULL;
4602 // Only way to get the Nokia compiler to compile the cast
4603 // is to have a separate void* variable first. Putting
4604 // the two casts on the same line doesn't work, neither does
4605 // a direct C-style to char*.
4606 void* pv1 = (void*)0x1234; // NOLINT
4607 void* pv2 = (void*)0xABC0; // NOLINT
4608 char* const p1 = reinterpret_cast<char*>(pv1);
4609 char* const p2 = reinterpret_cast<char*>(pv2);
4610 ASSERT_EQ(p1, p1);
4611
4612 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
4613 "Value of: p2");
4614 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
4615 "p2");
4616 EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
4617 reinterpret_cast<char*>(0xABC0)),
4618 "ABC0");
4619 }
4620
4621 // Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,WideCharPointer)4622 TEST(EqAssertionTest, WideCharPointer) {
4623 wchar_t* const p0 = NULL;
4624 // Only way to get the Nokia compiler to compile the cast
4625 // is to have a separate void* variable first. Putting
4626 // the two casts on the same line doesn't work, neither does
4627 // a direct C-style to char*.
4628 void* pv1 = (void*)0x1234; // NOLINT
4629 void* pv2 = (void*)0xABC0; // NOLINT
4630 wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1);
4631 wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2);
4632 EXPECT_EQ(p0, p0);
4633
4634 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
4635 "Value of: p2");
4636 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
4637 "p2");
4638 void* pv3 = (void*)0x1234; // NOLINT
4639 void* pv4 = (void*)0xABC0; // NOLINT
4640 const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3);
4641 const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4);
4642 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4),
4643 "p4");
4644 }
4645
4646 // Tests using other types of pointers in {EXPECT|ASSERT}_EQ.
TEST(EqAssertionTest,OtherPointer)4647 TEST(EqAssertionTest, OtherPointer) {
4648 ASSERT_EQ(static_cast<const int*>(NULL),
4649 static_cast<const int*>(NULL));
4650 EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL),
4651 reinterpret_cast<const int*>(0x1234)),
4652 "0x1234");
4653 }
4654
4655 // A class that supports binary comparison operators but not streaming.
4656 class UnprintableChar {
4657 public:
UnprintableChar(char ch)4658 explicit UnprintableChar(char ch) : char_(ch) {}
4659
operator ==(const UnprintableChar & rhs) const4660 bool operator==(const UnprintableChar& rhs) const {
4661 return char_ == rhs.char_;
4662 }
operator !=(const UnprintableChar & rhs) const4663 bool operator!=(const UnprintableChar& rhs) const {
4664 return char_ != rhs.char_;
4665 }
operator <(const UnprintableChar & rhs) const4666 bool operator<(const UnprintableChar& rhs) const {
4667 return char_ < rhs.char_;
4668 }
operator <=(const UnprintableChar & rhs) const4669 bool operator<=(const UnprintableChar& rhs) const {
4670 return char_ <= rhs.char_;
4671 }
operator >(const UnprintableChar & rhs) const4672 bool operator>(const UnprintableChar& rhs) const {
4673 return char_ > rhs.char_;
4674 }
operator >=(const UnprintableChar & rhs) const4675 bool operator>=(const UnprintableChar& rhs) const {
4676 return char_ >= rhs.char_;
4677 }
4678
4679 private:
4680 char char_;
4681 };
4682
4683 // Tests that ASSERT_EQ() and friends don't require the arguments to
4684 // be printable.
TEST(ComparisonAssertionTest,AcceptsUnprintableArgs)4685 TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
4686 const UnprintableChar x('x'), y('y');
4687 ASSERT_EQ(x, x);
4688 EXPECT_NE(x, y);
4689 ASSERT_LT(x, y);
4690 EXPECT_LE(x, y);
4691 ASSERT_GT(y, x);
4692 EXPECT_GE(x, x);
4693
4694 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>");
4695 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>");
4696 EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>");
4697 EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>");
4698 EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>");
4699
4700 // Code tested by EXPECT_FATAL_FAILURE cannot reference local
4701 // variables, so we have to write UnprintableChar('x') instead of x.
4702 #ifndef __BORLANDC__
4703 // ICE's in C++Builder.
4704 EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')),
4705 "1-byte object <78>");
4706 EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
4707 "1-byte object <78>");
4708 #endif
4709 EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')),
4710 "1-byte object <79>");
4711 EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
4712 "1-byte object <78>");
4713 EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')),
4714 "1-byte object <79>");
4715 }
4716
4717 // Tests the FRIEND_TEST macro.
4718
4719 // This class has a private member we want to test. We will test it
4720 // both in a TEST and in a TEST_F.
4721 class Foo {
4722 public:
Foo()4723 Foo() {}
4724
4725 private:
Bar() const4726 int Bar() const { return 1; }
4727
4728 // Declares the friend tests that can access the private member
4729 // Bar().
4730 FRIEND_TEST(FRIEND_TEST_Test, TEST);
4731 FRIEND_TEST(FRIEND_TEST_Test2, TEST_F);
4732 };
4733
4734 // Tests that the FRIEND_TEST declaration allows a TEST to access a
4735 // class's private members. This should compile.
TEST(FRIEND_TEST_Test,TEST)4736 TEST(FRIEND_TEST_Test, TEST) {
4737 ASSERT_EQ(1, Foo().Bar());
4738 }
4739
4740 // The fixture needed to test using FRIEND_TEST with TEST_F.
4741 class FRIEND_TEST_Test2 : public Test {
4742 protected:
4743 Foo foo;
4744 };
4745
4746 // Tests that the FRIEND_TEST declaration allows a TEST_F to access a
4747 // class's private members. This should compile.
TEST_F(FRIEND_TEST_Test2,TEST_F)4748 TEST_F(FRIEND_TEST_Test2, TEST_F) {
4749 ASSERT_EQ(1, foo.Bar());
4750 }
4751
4752 // Tests the life cycle of Test objects.
4753
4754 // The test fixture for testing the life cycle of Test objects.
4755 //
4756 // This class counts the number of live test objects that uses this
4757 // fixture.
4758 class TestLifeCycleTest : public Test {
4759 protected:
4760 // Constructor. Increments the number of test objects that uses
4761 // this fixture.
TestLifeCycleTest()4762 TestLifeCycleTest() { count_++; }
4763
4764 // Destructor. Decrements the number of test objects that uses this
4765 // fixture.
~TestLifeCycleTest()4766 ~TestLifeCycleTest() { count_--; }
4767
4768 // Returns the number of live test objects that uses this fixture.
count() const4769 int count() const { return count_; }
4770
4771 private:
4772 static int count_;
4773 };
4774
4775 int TestLifeCycleTest::count_ = 0;
4776
4777 // Tests the life cycle of test objects.
TEST_F(TestLifeCycleTest,Test1)4778 TEST_F(TestLifeCycleTest, Test1) {
4779 // There should be only one test object in this test case that's
4780 // currently alive.
4781 ASSERT_EQ(1, count());
4782 }
4783
4784 // Tests the life cycle of test objects.
TEST_F(TestLifeCycleTest,Test2)4785 TEST_F(TestLifeCycleTest, Test2) {
4786 // After Test1 is done and Test2 is started, there should still be
4787 // only one live test object, as the object for Test1 should've been
4788 // deleted.
4789 ASSERT_EQ(1, count());
4790 }
4791
4792 } // namespace
4793
4794 // Tests that the copy constructor works when it is NOT optimized away by
4795 // the compiler.
TEST(AssertionResultTest,CopyConstructorWorksWhenNotOptimied)4796 TEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) {
4797 // Checks that the copy constructor doesn't try to dereference NULL pointers
4798 // in the source object.
4799 AssertionResult r1 = AssertionSuccess();
4800 AssertionResult r2 = r1;
4801 // The following line is added to prevent the compiler from optimizing
4802 // away the constructor call.
4803 r1 << "abc";
4804
4805 AssertionResult r3 = r1;
4806 EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1));
4807 EXPECT_STREQ("abc", r1.message());
4808 }
4809
4810 // Tests that AssertionSuccess and AssertionFailure construct
4811 // AssertionResult objects as expected.
TEST(AssertionResultTest,ConstructionWorks)4812 TEST(AssertionResultTest, ConstructionWorks) {
4813 AssertionResult r1 = AssertionSuccess();
4814 EXPECT_TRUE(r1);
4815 EXPECT_STREQ("", r1.message());
4816
4817 AssertionResult r2 = AssertionSuccess() << "abc";
4818 EXPECT_TRUE(r2);
4819 EXPECT_STREQ("abc", r2.message());
4820
4821 AssertionResult r3 = AssertionFailure();
4822 EXPECT_FALSE(r3);
4823 EXPECT_STREQ("", r3.message());
4824
4825 AssertionResult r4 = AssertionFailure() << "def";
4826 EXPECT_FALSE(r4);
4827 EXPECT_STREQ("def", r4.message());
4828
4829 AssertionResult r5 = AssertionFailure(Message() << "ghi");
4830 EXPECT_FALSE(r5);
4831 EXPECT_STREQ("ghi", r5.message());
4832 }
4833
4834 // Tests that the negation flips the predicate result but keeps the message.
TEST(AssertionResultTest,NegationWorks)4835 TEST(AssertionResultTest, NegationWorks) {
4836 AssertionResult r1 = AssertionSuccess() << "abc";
4837 EXPECT_FALSE(!r1);
4838 EXPECT_STREQ("abc", (!r1).message());
4839
4840 AssertionResult r2 = AssertionFailure() << "def";
4841 EXPECT_TRUE(!r2);
4842 EXPECT_STREQ("def", (!r2).message());
4843 }
4844
TEST(AssertionResultTest,StreamingWorks)4845 TEST(AssertionResultTest, StreamingWorks) {
4846 AssertionResult r = AssertionSuccess();
4847 r << "abc" << 'd' << 0 << true;
4848 EXPECT_STREQ("abcd0true", r.message());
4849 }
4850
TEST(AssertionResultTest,CanStreamOstreamManipulators)4851 TEST(AssertionResultTest, CanStreamOstreamManipulators) {
4852 AssertionResult r = AssertionSuccess();
4853 r << "Data" << std::endl << std::flush << std::ends << "Will be visible";
4854 EXPECT_STREQ("Data\n\\0Will be visible", r.message());
4855 }
4856
4857 // Tests streaming a user type whose definition and operator << are
4858 // both in the global namespace.
4859 class Base {
4860 public:
Base(int an_x)4861 explicit Base(int an_x) : x_(an_x) {}
x() const4862 int x() const { return x_; }
4863 private:
4864 int x_;
4865 };
operator <<(std::ostream & os,const Base & val)4866 std::ostream& operator<<(std::ostream& os,
4867 const Base& val) {
4868 return os << val.x();
4869 }
operator <<(std::ostream & os,const Base * pointer)4870 std::ostream& operator<<(std::ostream& os,
4871 const Base* pointer) {
4872 return os << "(" << pointer->x() << ")";
4873 }
4874
TEST(MessageTest,CanStreamUserTypeInGlobalNameSpace)4875 TEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) {
4876 Message msg;
4877 Base a(1);
4878
4879 msg << a << &a; // Uses ::operator<<.
4880 EXPECT_STREQ("1(1)", msg.GetString().c_str());
4881 }
4882
4883 // Tests streaming a user type whose definition and operator<< are
4884 // both in an unnamed namespace.
4885 namespace {
4886 class MyTypeInUnnamedNameSpace : public Base {
4887 public:
MyTypeInUnnamedNameSpace(int an_x)4888 explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {}
4889 };
operator <<(std::ostream & os,const MyTypeInUnnamedNameSpace & val)4890 std::ostream& operator<<(std::ostream& os,
4891 const MyTypeInUnnamedNameSpace& val) {
4892 return os << val.x();
4893 }
operator <<(std::ostream & os,const MyTypeInUnnamedNameSpace * pointer)4894 std::ostream& operator<<(std::ostream& os,
4895 const MyTypeInUnnamedNameSpace* pointer) {
4896 return os << "(" << pointer->x() << ")";
4897 }
4898 } // namespace
4899
TEST(MessageTest,CanStreamUserTypeInUnnamedNameSpace)4900 TEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) {
4901 Message msg;
4902 MyTypeInUnnamedNameSpace a(1);
4903
4904 msg << a << &a; // Uses <unnamed_namespace>::operator<<.
4905 EXPECT_STREQ("1(1)", msg.GetString().c_str());
4906 }
4907
4908 // Tests streaming a user type whose definition and operator<< are
4909 // both in a user namespace.
4910 namespace namespace1 {
4911 class MyTypeInNameSpace1 : public Base {
4912 public:
MyTypeInNameSpace1(int an_x)4913 explicit MyTypeInNameSpace1(int an_x): Base(an_x) {}
4914 };
operator <<(std::ostream & os,const MyTypeInNameSpace1 & val)4915 std::ostream& operator<<(std::ostream& os,
4916 const MyTypeInNameSpace1& val) {
4917 return os << val.x();
4918 }
operator <<(std::ostream & os,const MyTypeInNameSpace1 * pointer)4919 std::ostream& operator<<(std::ostream& os,
4920 const MyTypeInNameSpace1* pointer) {
4921 return os << "(" << pointer->x() << ")";
4922 }
4923 } // namespace namespace1
4924
TEST(MessageTest,CanStreamUserTypeInUserNameSpace)4925 TEST(MessageTest, CanStreamUserTypeInUserNameSpace) {
4926 Message msg;
4927 namespace1::MyTypeInNameSpace1 a(1);
4928
4929 msg << a << &a; // Uses namespace1::operator<<.
4930 EXPECT_STREQ("1(1)", msg.GetString().c_str());
4931 }
4932
4933 // Tests streaming a user type whose definition is in a user namespace
4934 // but whose operator<< is in the global namespace.
4935 namespace namespace2 {
4936 class MyTypeInNameSpace2 : public ::Base {
4937 public:
MyTypeInNameSpace2(int an_x)4938 explicit MyTypeInNameSpace2(int an_x): Base(an_x) {}
4939 };
4940 } // namespace namespace2
operator <<(std::ostream & os,const namespace2::MyTypeInNameSpace2 & val)4941 std::ostream& operator<<(std::ostream& os,
4942 const namespace2::MyTypeInNameSpace2& val) {
4943 return os << val.x();
4944 }
operator <<(std::ostream & os,const namespace2::MyTypeInNameSpace2 * pointer)4945 std::ostream& operator<<(std::ostream& os,
4946 const namespace2::MyTypeInNameSpace2* pointer) {
4947 return os << "(" << pointer->x() << ")";
4948 }
4949
TEST(MessageTest,CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal)4950 TEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) {
4951 Message msg;
4952 namespace2::MyTypeInNameSpace2 a(1);
4953
4954 msg << a << &a; // Uses ::operator<<.
4955 EXPECT_STREQ("1(1)", msg.GetString().c_str());
4956 }
4957
4958 // Tests streaming NULL pointers to testing::Message.
TEST(MessageTest,NullPointers)4959 TEST(MessageTest, NullPointers) {
4960 Message msg;
4961 char* const p1 = NULL;
4962 unsigned char* const p2 = NULL;
4963 int* p3 = NULL;
4964 double* p4 = NULL;
4965 bool* p5 = NULL;
4966 Message* p6 = NULL;
4967
4968 msg << p1 << p2 << p3 << p4 << p5 << p6;
4969 ASSERT_STREQ("(null)(null)(null)(null)(null)(null)",
4970 msg.GetString().c_str());
4971 }
4972
4973 // Tests streaming wide strings to testing::Message.
TEST(MessageTest,WideStrings)4974 TEST(MessageTest, WideStrings) {
4975 // Streams a NULL of type const wchar_t*.
4976 const wchar_t* const_wstr = NULL;
4977 EXPECT_STREQ("(null)",
4978 (Message() << const_wstr).GetString().c_str());
4979
4980 // Streams a NULL of type wchar_t*.
4981 wchar_t* wstr = NULL;
4982 EXPECT_STREQ("(null)",
4983 (Message() << wstr).GetString().c_str());
4984
4985 // Streams a non-NULL of type const wchar_t*.
4986 const_wstr = L"abc\x8119";
4987 EXPECT_STREQ("abc\xe8\x84\x99",
4988 (Message() << const_wstr).GetString().c_str());
4989
4990 // Streams a non-NULL of type wchar_t*.
4991 wstr = const_cast<wchar_t*>(const_wstr);
4992 EXPECT_STREQ("abc\xe8\x84\x99",
4993 (Message() << wstr).GetString().c_str());
4994 }
4995
4996
4997 // This line tests that we can define tests in the testing namespace.
4998 namespace testing {
4999
5000 // Tests the TestInfo class.
5001
5002 class TestInfoTest : public Test {
5003 protected:
GetTestInfo(const char * test_name)5004 static const TestInfo* GetTestInfo(const char* test_name) {
5005 const TestCase* const test_case = GetUnitTestImpl()->
5006 GetTestCase("TestInfoTest", "", NULL, NULL);
5007
5008 for (int i = 0; i < test_case->total_test_count(); ++i) {
5009 const TestInfo* const test_info = test_case->GetTestInfo(i);
5010 if (strcmp(test_name, test_info->name()) == 0)
5011 return test_info;
5012 }
5013 return NULL;
5014 }
5015
GetTestResult(const TestInfo * test_info)5016 static const TestResult* GetTestResult(
5017 const TestInfo* test_info) {
5018 return test_info->result();
5019 }
5020 };
5021
5022 // Tests TestInfo::test_case_name() and TestInfo::name().
TEST_F(TestInfoTest,Names)5023 TEST_F(TestInfoTest, Names) {
5024 const TestInfo* const test_info = GetTestInfo("Names");
5025
5026 ASSERT_STREQ("TestInfoTest", test_info->test_case_name());
5027 ASSERT_STREQ("Names", test_info->name());
5028 }
5029
5030 // Tests TestInfo::result().
TEST_F(TestInfoTest,result)5031 TEST_F(TestInfoTest, result) {
5032 const TestInfo* const test_info = GetTestInfo("result");
5033
5034 // Initially, there is no TestPartResult for this test.
5035 ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
5036
5037 // After the previous assertion, there is still none.
5038 ASSERT_EQ(0, GetTestResult(test_info)->total_part_count());
5039 }
5040
5041 // Tests setting up and tearing down a test case.
5042
5043 class SetUpTestCaseTest : public Test {
5044 protected:
5045 // This will be called once before the first test in this test case
5046 // is run.
SetUpTestCase()5047 static void SetUpTestCase() {
5048 printf("Setting up the test case . . .\n");
5049
5050 // Initializes some shared resource. In this simple example, we
5051 // just create a C string. More complex stuff can be done if
5052 // desired.
5053 shared_resource_ = "123";
5054
5055 // Increments the number of test cases that have been set up.
5056 counter_++;
5057
5058 // SetUpTestCase() should be called only once.
5059 EXPECT_EQ(1, counter_);
5060 }
5061
5062 // This will be called once after the last test in this test case is
5063 // run.
TearDownTestCase()5064 static void TearDownTestCase() {
5065 printf("Tearing down the test case . . .\n");
5066
5067 // Decrements the number of test cases that have been set up.
5068 counter_--;
5069
5070 // TearDownTestCase() should be called only once.
5071 EXPECT_EQ(0, counter_);
5072
5073 // Cleans up the shared resource.
5074 shared_resource_ = NULL;
5075 }
5076
5077 // This will be called before each test in this test case.
SetUp()5078 virtual void SetUp() {
5079 // SetUpTestCase() should be called only once, so counter_ should
5080 // always be 1.
5081 EXPECT_EQ(1, counter_);
5082 }
5083
5084 // Number of test cases that have been set up.
5085 static int counter_;
5086
5087 // Some resource to be shared by all tests in this test case.
5088 static const char* shared_resource_;
5089 };
5090
5091 int SetUpTestCaseTest::counter_ = 0;
5092 const char* SetUpTestCaseTest::shared_resource_ = NULL;
5093
5094 // A test that uses the shared resource.
TEST_F(SetUpTestCaseTest,Test1)5095 TEST_F(SetUpTestCaseTest, Test1) {
5096 EXPECT_STRNE(NULL, shared_resource_);
5097 }
5098
5099 // Another test that uses the shared resource.
TEST_F(SetUpTestCaseTest,Test2)5100 TEST_F(SetUpTestCaseTest, Test2) {
5101 EXPECT_STREQ("123", shared_resource_);
5102 }
5103
5104 // The InitGoogleTestTest test case tests testing::InitGoogleTest().
5105
5106 // The Flags struct stores a copy of all Google Test flags.
5107 struct Flags {
5108 // Constructs a Flags struct where each flag has its default value.
Flagstesting::Flags5109 Flags() : also_run_disabled_tests(false),
5110 break_on_failure(false),
5111 catch_exceptions(false),
5112 death_test_use_fork(false),
5113 filter(""),
5114 list_tests(false),
5115 output(""),
5116 print_time(true),
5117 random_seed(0),
5118 repeat(1),
5119 shuffle(false),
5120 stack_trace_depth(kMaxStackTraceDepth),
5121 stream_result_to(""),
5122 throw_on_failure(false) {}
5123
5124 // Factory methods.
5125
5126 // Creates a Flags struct where the gtest_also_run_disabled_tests flag has
5127 // the given value.
AlsoRunDisabledTeststesting::Flags5128 static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) {
5129 Flags flags;
5130 flags.also_run_disabled_tests = also_run_disabled_tests;
5131 return flags;
5132 }
5133
5134 // Creates a Flags struct where the gtest_break_on_failure flag has
5135 // the given value.
BreakOnFailuretesting::Flags5136 static Flags BreakOnFailure(bool break_on_failure) {
5137 Flags flags;
5138 flags.break_on_failure = break_on_failure;
5139 return flags;
5140 }
5141
5142 // Creates a Flags struct where the gtest_catch_exceptions flag has
5143 // the given value.
CatchExceptionstesting::Flags5144 static Flags CatchExceptions(bool catch_exceptions) {
5145 Flags flags;
5146 flags.catch_exceptions = catch_exceptions;
5147 return flags;
5148 }
5149
5150 // Creates a Flags struct where the gtest_death_test_use_fork flag has
5151 // the given value.
DeathTestUseForktesting::Flags5152 static Flags DeathTestUseFork(bool death_test_use_fork) {
5153 Flags flags;
5154 flags.death_test_use_fork = death_test_use_fork;
5155 return flags;
5156 }
5157
5158 // Creates a Flags struct where the gtest_filter flag has the given
5159 // value.
Filtertesting::Flags5160 static Flags Filter(const char* filter) {
5161 Flags flags;
5162 flags.filter = filter;
5163 return flags;
5164 }
5165
5166 // Creates a Flags struct where the gtest_list_tests flag has the
5167 // given value.
ListTeststesting::Flags5168 static Flags ListTests(bool list_tests) {
5169 Flags flags;
5170 flags.list_tests = list_tests;
5171 return flags;
5172 }
5173
5174 // Creates a Flags struct where the gtest_output flag has the given
5175 // value.
Outputtesting::Flags5176 static Flags Output(const char* output) {
5177 Flags flags;
5178 flags.output = output;
5179 return flags;
5180 }
5181
5182 // Creates a Flags struct where the gtest_print_time flag has the given
5183 // value.
PrintTimetesting::Flags5184 static Flags PrintTime(bool print_time) {
5185 Flags flags;
5186 flags.print_time = print_time;
5187 return flags;
5188 }
5189
5190 // Creates a Flags struct where the gtest_random_seed flag has
5191 // the given value.
RandomSeedtesting::Flags5192 static Flags RandomSeed(Int32 random_seed) {
5193 Flags flags;
5194 flags.random_seed = random_seed;
5195 return flags;
5196 }
5197
5198 // Creates a Flags struct where the gtest_repeat flag has the given
5199 // value.
Repeattesting::Flags5200 static Flags Repeat(Int32 repeat) {
5201 Flags flags;
5202 flags.repeat = repeat;
5203 return flags;
5204 }
5205
5206 // Creates a Flags struct where the gtest_shuffle flag has
5207 // the given value.
Shuffletesting::Flags5208 static Flags Shuffle(bool shuffle) {
5209 Flags flags;
5210 flags.shuffle = shuffle;
5211 return flags;
5212 }
5213
5214 // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has
5215 // the given value.
StackTraceDepthtesting::Flags5216 static Flags StackTraceDepth(Int32 stack_trace_depth) {
5217 Flags flags;
5218 flags.stack_trace_depth = stack_trace_depth;
5219 return flags;
5220 }
5221
5222 // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has
5223 // the given value.
StreamResultTotesting::Flags5224 static Flags StreamResultTo(const char* stream_result_to) {
5225 Flags flags;
5226 flags.stream_result_to = stream_result_to;
5227 return flags;
5228 }
5229
5230 // Creates a Flags struct where the gtest_throw_on_failure flag has
5231 // the given value.
ThrowOnFailuretesting::Flags5232 static Flags ThrowOnFailure(bool throw_on_failure) {
5233 Flags flags;
5234 flags.throw_on_failure = throw_on_failure;
5235 return flags;
5236 }
5237
5238 // These fields store the flag values.
5239 bool also_run_disabled_tests;
5240 bool break_on_failure;
5241 bool catch_exceptions;
5242 bool death_test_use_fork;
5243 const char* filter;
5244 bool list_tests;
5245 const char* output;
5246 bool print_time;
5247 Int32 random_seed;
5248 Int32 repeat;
5249 bool shuffle;
5250 Int32 stack_trace_depth;
5251 const char* stream_result_to;
5252 bool throw_on_failure;
5253 };
5254
5255 // Fixture for testing InitGoogleTest().
5256 class InitGoogleTestTest : public Test {
5257 protected:
5258 // Clears the flags before each test.
SetUp()5259 virtual void SetUp() {
5260 GTEST_FLAG(also_run_disabled_tests) = false;
5261 GTEST_FLAG(break_on_failure) = false;
5262 GTEST_FLAG(catch_exceptions) = false;
5263 GTEST_FLAG(death_test_use_fork) = false;
5264 GTEST_FLAG(filter) = "";
5265 GTEST_FLAG(list_tests) = false;
5266 GTEST_FLAG(output) = "";
5267 GTEST_FLAG(print_time) = true;
5268 GTEST_FLAG(random_seed) = 0;
5269 GTEST_FLAG(repeat) = 1;
5270 GTEST_FLAG(shuffle) = false;
5271 GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth;
5272 GTEST_FLAG(stream_result_to) = "";
5273 GTEST_FLAG(throw_on_failure) = false;
5274 }
5275
5276 // Asserts that two narrow or wide string arrays are equal.
5277 template <typename CharType>
AssertStringArrayEq(size_t size1,CharType ** array1,size_t size2,CharType ** array2)5278 static void AssertStringArrayEq(size_t size1, CharType** array1,
5279 size_t size2, CharType** array2) {
5280 ASSERT_EQ(size1, size2) << " Array sizes different.";
5281
5282 for (size_t i = 0; i != size1; i++) {
5283 ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i;
5284 }
5285 }
5286
5287 // Verifies that the flag values match the expected values.
CheckFlags(const Flags & expected)5288 static void CheckFlags(const Flags& expected) {
5289 EXPECT_EQ(expected.also_run_disabled_tests,
5290 GTEST_FLAG(also_run_disabled_tests));
5291 EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
5292 EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
5293 EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
5294 EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
5295 EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
5296 EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
5297 EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time));
5298 EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed));
5299 EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat));
5300 EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle));
5301 EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth));
5302 EXPECT_STREQ(expected.stream_result_to,
5303 GTEST_FLAG(stream_result_to).c_str());
5304 EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure));
5305 }
5306
5307 // Parses a command line (specified by argc1 and argv1), then
5308 // verifies that the flag values are expected and that the
5309 // recognized flags are removed from the command line.
5310 template <typename CharType>
TestParsingFlags(int argc1,const CharType ** argv1,int argc2,const CharType ** argv2,const Flags & expected,bool should_print_help)5311 static void TestParsingFlags(int argc1, const CharType** argv1,
5312 int argc2, const CharType** argv2,
5313 const Flags& expected, bool should_print_help) {
5314 const bool saved_help_flag = ::testing::internal::g_help_flag;
5315 ::testing::internal::g_help_flag = false;
5316
5317 #if GTEST_HAS_STREAM_REDIRECTION
5318 CaptureStdout();
5319 #endif
5320
5321 // Parses the command line.
5322 internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1));
5323
5324 #if GTEST_HAS_STREAM_REDIRECTION
5325 const std::string captured_stdout = GetCapturedStdout();
5326 #endif
5327
5328 // Verifies the flag values.
5329 CheckFlags(expected);
5330
5331 // Verifies that the recognized flags are removed from the command
5332 // line.
5333 AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2);
5334
5335 // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the
5336 // help message for the flags it recognizes.
5337 EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag);
5338
5339 #if GTEST_HAS_STREAM_REDIRECTION
5340 const char* const expected_help_fragment =
5341 "This program contains tests written using";
5342 if (should_print_help) {
5343 EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout);
5344 } else {
5345 EXPECT_PRED_FORMAT2(IsNotSubstring,
5346 expected_help_fragment, captured_stdout);
5347 }
5348 #endif // GTEST_HAS_STREAM_REDIRECTION
5349
5350 ::testing::internal::g_help_flag = saved_help_flag;
5351 }
5352
5353 // This macro wraps TestParsingFlags s.t. the user doesn't need
5354 // to specify the array sizes.
5355
5356 #define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \
5357 TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \
5358 sizeof(argv2)/sizeof(*argv2) - 1, argv2, \
5359 expected, should_print_help)
5360 };
5361
5362 // Tests parsing an empty command line.
TEST_F(InitGoogleTestTest,Empty)5363 TEST_F(InitGoogleTestTest, Empty) {
5364 const char* argv[] = {
5365 NULL
5366 };
5367
5368 const char* argv2[] = {
5369 NULL
5370 };
5371
5372 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
5373 }
5374
5375 // Tests parsing a command line that has no flag.
TEST_F(InitGoogleTestTest,NoFlag)5376 TEST_F(InitGoogleTestTest, NoFlag) {
5377 const char* argv[] = {
5378 "foo.exe",
5379 NULL
5380 };
5381
5382 const char* argv2[] = {
5383 "foo.exe",
5384 NULL
5385 };
5386
5387 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
5388 }
5389
5390 // Tests parsing a bad --gtest_filter flag.
TEST_F(InitGoogleTestTest,FilterBad)5391 TEST_F(InitGoogleTestTest, FilterBad) {
5392 const char* argv[] = {
5393 "foo.exe",
5394 "--gtest_filter",
5395 NULL
5396 };
5397
5398 const char* argv2[] = {
5399 "foo.exe",
5400 "--gtest_filter",
5401 NULL
5402 };
5403
5404 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
5405 }
5406
5407 // Tests parsing an empty --gtest_filter flag.
TEST_F(InitGoogleTestTest,FilterEmpty)5408 TEST_F(InitGoogleTestTest, FilterEmpty) {
5409 const char* argv[] = {
5410 "foo.exe",
5411 "--gtest_filter=",
5412 NULL
5413 };
5414
5415 const char* argv2[] = {
5416 "foo.exe",
5417 NULL
5418 };
5419
5420 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false);
5421 }
5422
5423 // Tests parsing a non-empty --gtest_filter flag.
TEST_F(InitGoogleTestTest,FilterNonEmpty)5424 TEST_F(InitGoogleTestTest, FilterNonEmpty) {
5425 const char* argv[] = {
5426 "foo.exe",
5427 "--gtest_filter=abc",
5428 NULL
5429 };
5430
5431 const char* argv2[] = {
5432 "foo.exe",
5433 NULL
5434 };
5435
5436 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false);
5437 }
5438
5439 // Tests parsing --gtest_break_on_failure.
TEST_F(InitGoogleTestTest,BreakOnFailureWithoutValue)5440 TEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) {
5441 const char* argv[] = {
5442 "foo.exe",
5443 "--gtest_break_on_failure",
5444 NULL
5445 };
5446
5447 const char* argv2[] = {
5448 "foo.exe",
5449 NULL
5450 };
5451
5452 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
5453 }
5454
5455 // Tests parsing --gtest_break_on_failure=0.
TEST_F(InitGoogleTestTest,BreakOnFailureFalse_0)5456 TEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) {
5457 const char* argv[] = {
5458 "foo.exe",
5459 "--gtest_break_on_failure=0",
5460 NULL
5461 };
5462
5463 const char* argv2[] = {
5464 "foo.exe",
5465 NULL
5466 };
5467
5468 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5469 }
5470
5471 // Tests parsing --gtest_break_on_failure=f.
TEST_F(InitGoogleTestTest,BreakOnFailureFalse_f)5472 TEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) {
5473 const char* argv[] = {
5474 "foo.exe",
5475 "--gtest_break_on_failure=f",
5476 NULL
5477 };
5478
5479 const char* argv2[] = {
5480 "foo.exe",
5481 NULL
5482 };
5483
5484 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5485 }
5486
5487 // Tests parsing --gtest_break_on_failure=F.
TEST_F(InitGoogleTestTest,BreakOnFailureFalse_F)5488 TEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) {
5489 const char* argv[] = {
5490 "foo.exe",
5491 "--gtest_break_on_failure=F",
5492 NULL
5493 };
5494
5495 const char* argv2[] = {
5496 "foo.exe",
5497 NULL
5498 };
5499
5500 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false);
5501 }
5502
5503 // Tests parsing a --gtest_break_on_failure flag that has a "true"
5504 // definition.
TEST_F(InitGoogleTestTest,BreakOnFailureTrue)5505 TEST_F(InitGoogleTestTest, BreakOnFailureTrue) {
5506 const char* argv[] = {
5507 "foo.exe",
5508 "--gtest_break_on_failure=1",
5509 NULL
5510 };
5511
5512 const char* argv2[] = {
5513 "foo.exe",
5514 NULL
5515 };
5516
5517 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false);
5518 }
5519
5520 // Tests parsing --gtest_catch_exceptions.
TEST_F(InitGoogleTestTest,CatchExceptions)5521 TEST_F(InitGoogleTestTest, CatchExceptions) {
5522 const char* argv[] = {
5523 "foo.exe",
5524 "--gtest_catch_exceptions",
5525 NULL
5526 };
5527
5528 const char* argv2[] = {
5529 "foo.exe",
5530 NULL
5531 };
5532
5533 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false);
5534 }
5535
5536 // Tests parsing --gtest_death_test_use_fork.
TEST_F(InitGoogleTestTest,DeathTestUseFork)5537 TEST_F(InitGoogleTestTest, DeathTestUseFork) {
5538 const char* argv[] = {
5539 "foo.exe",
5540 "--gtest_death_test_use_fork",
5541 NULL
5542 };
5543
5544 const char* argv2[] = {
5545 "foo.exe",
5546 NULL
5547 };
5548
5549 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false);
5550 }
5551
5552 // Tests having the same flag twice with different values. The
5553 // expected behavior is that the one coming last takes precedence.
TEST_F(InitGoogleTestTest,DuplicatedFlags)5554 TEST_F(InitGoogleTestTest, DuplicatedFlags) {
5555 const char* argv[] = {
5556 "foo.exe",
5557 "--gtest_filter=a",
5558 "--gtest_filter=b",
5559 NULL
5560 };
5561
5562 const char* argv2[] = {
5563 "foo.exe",
5564 NULL
5565 };
5566
5567 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false);
5568 }
5569
5570 // Tests having an unrecognized flag on the command line.
TEST_F(InitGoogleTestTest,UnrecognizedFlag)5571 TEST_F(InitGoogleTestTest, UnrecognizedFlag) {
5572 const char* argv[] = {
5573 "foo.exe",
5574 "--gtest_break_on_failure",
5575 "bar", // Unrecognized by Google Test.
5576 "--gtest_filter=b",
5577 NULL
5578 };
5579
5580 const char* argv2[] = {
5581 "foo.exe",
5582 "bar",
5583 NULL
5584 };
5585
5586 Flags flags;
5587 flags.break_on_failure = true;
5588 flags.filter = "b";
5589 GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false);
5590 }
5591
5592 // Tests having a --gtest_list_tests flag
TEST_F(InitGoogleTestTest,ListTestsFlag)5593 TEST_F(InitGoogleTestTest, ListTestsFlag) {
5594 const char* argv[] = {
5595 "foo.exe",
5596 "--gtest_list_tests",
5597 NULL
5598 };
5599
5600 const char* argv2[] = {
5601 "foo.exe",
5602 NULL
5603 };
5604
5605 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
5606 }
5607
5608 // Tests having a --gtest_list_tests flag with a "true" value
TEST_F(InitGoogleTestTest,ListTestsTrue)5609 TEST_F(InitGoogleTestTest, ListTestsTrue) {
5610 const char* argv[] = {
5611 "foo.exe",
5612 "--gtest_list_tests=1",
5613 NULL
5614 };
5615
5616 const char* argv2[] = {
5617 "foo.exe",
5618 NULL
5619 };
5620
5621 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false);
5622 }
5623
5624 // Tests having a --gtest_list_tests flag with a "false" value
TEST_F(InitGoogleTestTest,ListTestsFalse)5625 TEST_F(InitGoogleTestTest, ListTestsFalse) {
5626 const char* argv[] = {
5627 "foo.exe",
5628 "--gtest_list_tests=0",
5629 NULL
5630 };
5631
5632 const char* argv2[] = {
5633 "foo.exe",
5634 NULL
5635 };
5636
5637 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
5638 }
5639
5640 // Tests parsing --gtest_list_tests=f.
TEST_F(InitGoogleTestTest,ListTestsFalse_f)5641 TEST_F(InitGoogleTestTest, ListTestsFalse_f) {
5642 const char* argv[] = {
5643 "foo.exe",
5644 "--gtest_list_tests=f",
5645 NULL
5646 };
5647
5648 const char* argv2[] = {
5649 "foo.exe",
5650 NULL
5651 };
5652
5653 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
5654 }
5655
5656 // Tests parsing --gtest_list_tests=F.
TEST_F(InitGoogleTestTest,ListTestsFalse_F)5657 TEST_F(InitGoogleTestTest, ListTestsFalse_F) {
5658 const char* argv[] = {
5659 "foo.exe",
5660 "--gtest_list_tests=F",
5661 NULL
5662 };
5663
5664 const char* argv2[] = {
5665 "foo.exe",
5666 NULL
5667 };
5668
5669 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false);
5670 }
5671
5672 // Tests parsing --gtest_output (invalid).
TEST_F(InitGoogleTestTest,OutputEmpty)5673 TEST_F(InitGoogleTestTest, OutputEmpty) {
5674 const char* argv[] = {
5675 "foo.exe",
5676 "--gtest_output",
5677 NULL
5678 };
5679
5680 const char* argv2[] = {
5681 "foo.exe",
5682 "--gtest_output",
5683 NULL
5684 };
5685
5686 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
5687 }
5688
5689 // Tests parsing --gtest_output=xml
TEST_F(InitGoogleTestTest,OutputXml)5690 TEST_F(InitGoogleTestTest, OutputXml) {
5691 const char* argv[] = {
5692 "foo.exe",
5693 "--gtest_output=xml",
5694 NULL
5695 };
5696
5697 const char* argv2[] = {
5698 "foo.exe",
5699 NULL
5700 };
5701
5702 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false);
5703 }
5704
5705 // Tests parsing --gtest_output=xml:file
TEST_F(InitGoogleTestTest,OutputXmlFile)5706 TEST_F(InitGoogleTestTest, OutputXmlFile) {
5707 const char* argv[] = {
5708 "foo.exe",
5709 "--gtest_output=xml:file",
5710 NULL
5711 };
5712
5713 const char* argv2[] = {
5714 "foo.exe",
5715 NULL
5716 };
5717
5718 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false);
5719 }
5720
5721 // Tests parsing --gtest_output=xml:directory/path/
TEST_F(InitGoogleTestTest,OutputXmlDirectory)5722 TEST_F(InitGoogleTestTest, OutputXmlDirectory) {
5723 const char* argv[] = {
5724 "foo.exe",
5725 "--gtest_output=xml:directory/path/",
5726 NULL
5727 };
5728
5729 const char* argv2[] = {
5730 "foo.exe",
5731 NULL
5732 };
5733
5734 GTEST_TEST_PARSING_FLAGS_(argv, argv2,
5735 Flags::Output("xml:directory/path/"), false);
5736 }
5737
5738 // Tests having a --gtest_print_time flag
TEST_F(InitGoogleTestTest,PrintTimeFlag)5739 TEST_F(InitGoogleTestTest, PrintTimeFlag) {
5740 const char* argv[] = {
5741 "foo.exe",
5742 "--gtest_print_time",
5743 NULL
5744 };
5745
5746 const char* argv2[] = {
5747 "foo.exe",
5748 NULL
5749 };
5750
5751 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
5752 }
5753
5754 // Tests having a --gtest_print_time flag with a "true" value
TEST_F(InitGoogleTestTest,PrintTimeTrue)5755 TEST_F(InitGoogleTestTest, PrintTimeTrue) {
5756 const char* argv[] = {
5757 "foo.exe",
5758 "--gtest_print_time=1",
5759 NULL
5760 };
5761
5762 const char* argv2[] = {
5763 "foo.exe",
5764 NULL
5765 };
5766
5767 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false);
5768 }
5769
5770 // Tests having a --gtest_print_time flag with a "false" value
TEST_F(InitGoogleTestTest,PrintTimeFalse)5771 TEST_F(InitGoogleTestTest, PrintTimeFalse) {
5772 const char* argv[] = {
5773 "foo.exe",
5774 "--gtest_print_time=0",
5775 NULL
5776 };
5777
5778 const char* argv2[] = {
5779 "foo.exe",
5780 NULL
5781 };
5782
5783 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
5784 }
5785
5786 // Tests parsing --gtest_print_time=f.
TEST_F(InitGoogleTestTest,PrintTimeFalse_f)5787 TEST_F(InitGoogleTestTest, PrintTimeFalse_f) {
5788 const char* argv[] = {
5789 "foo.exe",
5790 "--gtest_print_time=f",
5791 NULL
5792 };
5793
5794 const char* argv2[] = {
5795 "foo.exe",
5796 NULL
5797 };
5798
5799 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
5800 }
5801
5802 // Tests parsing --gtest_print_time=F.
TEST_F(InitGoogleTestTest,PrintTimeFalse_F)5803 TEST_F(InitGoogleTestTest, PrintTimeFalse_F) {
5804 const char* argv[] = {
5805 "foo.exe",
5806 "--gtest_print_time=F",
5807 NULL
5808 };
5809
5810 const char* argv2[] = {
5811 "foo.exe",
5812 NULL
5813 };
5814
5815 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false);
5816 }
5817
5818 // Tests parsing --gtest_random_seed=number
TEST_F(InitGoogleTestTest,RandomSeed)5819 TEST_F(InitGoogleTestTest, RandomSeed) {
5820 const char* argv[] = {
5821 "foo.exe",
5822 "--gtest_random_seed=1000",
5823 NULL
5824 };
5825
5826 const char* argv2[] = {
5827 "foo.exe",
5828 NULL
5829 };
5830
5831 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false);
5832 }
5833
5834 // Tests parsing --gtest_repeat=number
TEST_F(InitGoogleTestTest,Repeat)5835 TEST_F(InitGoogleTestTest, Repeat) {
5836 const char* argv[] = {
5837 "foo.exe",
5838 "--gtest_repeat=1000",
5839 NULL
5840 };
5841
5842 const char* argv2[] = {
5843 "foo.exe",
5844 NULL
5845 };
5846
5847 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false);
5848 }
5849
5850 // Tests having a --gtest_also_run_disabled_tests flag
TEST_F(InitGoogleTestTest,AlsoRunDisabledTestsFlag)5851 TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) {
5852 const char* argv[] = {
5853 "foo.exe",
5854 "--gtest_also_run_disabled_tests",
5855 NULL
5856 };
5857
5858 const char* argv2[] = {
5859 "foo.exe",
5860 NULL
5861 };
5862
5863 GTEST_TEST_PARSING_FLAGS_(argv, argv2,
5864 Flags::AlsoRunDisabledTests(true), false);
5865 }
5866
5867 // Tests having a --gtest_also_run_disabled_tests flag with a "true" value
TEST_F(InitGoogleTestTest,AlsoRunDisabledTestsTrue)5868 TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) {
5869 const char* argv[] = {
5870 "foo.exe",
5871 "--gtest_also_run_disabled_tests=1",
5872 NULL
5873 };
5874
5875 const char* argv2[] = {
5876 "foo.exe",
5877 NULL
5878 };
5879
5880 GTEST_TEST_PARSING_FLAGS_(argv, argv2,
5881 Flags::AlsoRunDisabledTests(true), false);
5882 }
5883
5884 // Tests having a --gtest_also_run_disabled_tests flag with a "false" value
TEST_F(InitGoogleTestTest,AlsoRunDisabledTestsFalse)5885 TEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) {
5886 const char* argv[] = {
5887 "foo.exe",
5888 "--gtest_also_run_disabled_tests=0",
5889 NULL
5890 };
5891
5892 const char* argv2[] = {
5893 "foo.exe",
5894 NULL
5895 };
5896
5897 GTEST_TEST_PARSING_FLAGS_(argv, argv2,
5898 Flags::AlsoRunDisabledTests(false), false);
5899 }
5900
5901 // Tests parsing --gtest_shuffle.
TEST_F(InitGoogleTestTest,ShuffleWithoutValue)5902 TEST_F(InitGoogleTestTest, ShuffleWithoutValue) {
5903 const char* argv[] = {
5904 "foo.exe",
5905 "--gtest_shuffle",
5906 NULL
5907 };
5908
5909 const char* argv2[] = {
5910 "foo.exe",
5911 NULL
5912 };
5913
5914 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
5915 }
5916
5917 // Tests parsing --gtest_shuffle=0.
TEST_F(InitGoogleTestTest,ShuffleFalse_0)5918 TEST_F(InitGoogleTestTest, ShuffleFalse_0) {
5919 const char* argv[] = {
5920 "foo.exe",
5921 "--gtest_shuffle=0",
5922 NULL
5923 };
5924
5925 const char* argv2[] = {
5926 "foo.exe",
5927 NULL
5928 };
5929
5930 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false);
5931 }
5932
5933 // Tests parsing a --gtest_shuffle flag that has a "true"
5934 // definition.
TEST_F(InitGoogleTestTest,ShuffleTrue)5935 TEST_F(InitGoogleTestTest, ShuffleTrue) {
5936 const char* argv[] = {
5937 "foo.exe",
5938 "--gtest_shuffle=1",
5939 NULL
5940 };
5941
5942 const char* argv2[] = {
5943 "foo.exe",
5944 NULL
5945 };
5946
5947 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false);
5948 }
5949
5950 // Tests parsing --gtest_stack_trace_depth=number.
TEST_F(InitGoogleTestTest,StackTraceDepth)5951 TEST_F(InitGoogleTestTest, StackTraceDepth) {
5952 const char* argv[] = {
5953 "foo.exe",
5954 "--gtest_stack_trace_depth=5",
5955 NULL
5956 };
5957
5958 const char* argv2[] = {
5959 "foo.exe",
5960 NULL
5961 };
5962
5963 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false);
5964 }
5965
TEST_F(InitGoogleTestTest,StreamResultTo)5966 TEST_F(InitGoogleTestTest, StreamResultTo) {
5967 const char* argv[] = {
5968 "foo.exe",
5969 "--gtest_stream_result_to=localhost:1234",
5970 NULL
5971 };
5972
5973 const char* argv2[] = {
5974 "foo.exe",
5975 NULL
5976 };
5977
5978 GTEST_TEST_PARSING_FLAGS_(
5979 argv, argv2, Flags::StreamResultTo("localhost:1234"), false);
5980 }
5981
5982 // Tests parsing --gtest_throw_on_failure.
TEST_F(InitGoogleTestTest,ThrowOnFailureWithoutValue)5983 TEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) {
5984 const char* argv[] = {
5985 "foo.exe",
5986 "--gtest_throw_on_failure",
5987 NULL
5988 };
5989
5990 const char* argv2[] = {
5991 "foo.exe",
5992 NULL
5993 };
5994
5995 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
5996 }
5997
5998 // Tests parsing --gtest_throw_on_failure=0.
TEST_F(InitGoogleTestTest,ThrowOnFailureFalse_0)5999 TEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) {
6000 const char* argv[] = {
6001 "foo.exe",
6002 "--gtest_throw_on_failure=0",
6003 NULL
6004 };
6005
6006 const char* argv2[] = {
6007 "foo.exe",
6008 NULL
6009 };
6010
6011 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false);
6012 }
6013
6014 // Tests parsing a --gtest_throw_on_failure flag that has a "true"
6015 // definition.
TEST_F(InitGoogleTestTest,ThrowOnFailureTrue)6016 TEST_F(InitGoogleTestTest, ThrowOnFailureTrue) {
6017 const char* argv[] = {
6018 "foo.exe",
6019 "--gtest_throw_on_failure=1",
6020 NULL
6021 };
6022
6023 const char* argv2[] = {
6024 "foo.exe",
6025 NULL
6026 };
6027
6028 GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false);
6029 }
6030
6031 #if GTEST_OS_WINDOWS
6032 // Tests parsing wide strings.
TEST_F(InitGoogleTestTest,WideStrings)6033 TEST_F(InitGoogleTestTest, WideStrings) {
6034 const wchar_t* argv[] = {
6035 L"foo.exe",
6036 L"--gtest_filter=Foo*",
6037 L"--gtest_list_tests=1",
6038 L"--gtest_break_on_failure",
6039 L"--non_gtest_flag",
6040 NULL
6041 };
6042
6043 const wchar_t* argv2[] = {
6044 L"foo.exe",
6045 L"--non_gtest_flag",
6046 NULL
6047 };
6048
6049 Flags expected_flags;
6050 expected_flags.break_on_failure = true;
6051 expected_flags.filter = "Foo*";
6052 expected_flags.list_tests = true;
6053
6054 GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false);
6055 }
6056 #endif // GTEST_OS_WINDOWS
6057
6058 // Tests current_test_info() in UnitTest.
6059 class CurrentTestInfoTest : public Test {
6060 protected:
6061 // Tests that current_test_info() returns NULL before the first test in
6062 // the test case is run.
SetUpTestCase()6063 static void SetUpTestCase() {
6064 // There should be no tests running at this point.
6065 const TestInfo* test_info =
6066 UnitTest::GetInstance()->current_test_info();
6067 EXPECT_TRUE(test_info == NULL)
6068 << "There should be no tests running at this point.";
6069 }
6070
6071 // Tests that current_test_info() returns NULL after the last test in
6072 // the test case has run.
TearDownTestCase()6073 static void TearDownTestCase() {
6074 const TestInfo* test_info =
6075 UnitTest::GetInstance()->current_test_info();
6076 EXPECT_TRUE(test_info == NULL)
6077 << "There should be no tests running at this point.";
6078 }
6079 };
6080
6081 // Tests that current_test_info() returns TestInfo for currently running
6082 // test by checking the expected test name against the actual one.
TEST_F(CurrentTestInfoTest,WorksForFirstTestInATestCase)6083 TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) {
6084 const TestInfo* test_info =
6085 UnitTest::GetInstance()->current_test_info();
6086 ASSERT_TRUE(NULL != test_info)
6087 << "There is a test running so we should have a valid TestInfo.";
6088 EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
6089 << "Expected the name of the currently running test case.";
6090 EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name())
6091 << "Expected the name of the currently running test.";
6092 }
6093
6094 // Tests that current_test_info() returns TestInfo for currently running
6095 // test by checking the expected test name against the actual one. We
6096 // use this test to see that the TestInfo object actually changed from
6097 // the previous invocation.
TEST_F(CurrentTestInfoTest,WorksForSecondTestInATestCase)6098 TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) {
6099 const TestInfo* test_info =
6100 UnitTest::GetInstance()->current_test_info();
6101 ASSERT_TRUE(NULL != test_info)
6102 << "There is a test running so we should have a valid TestInfo.";
6103 EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name())
6104 << "Expected the name of the currently running test case.";
6105 EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name())
6106 << "Expected the name of the currently running test.";
6107 }
6108
6109 } // namespace testing
6110
6111 // These two lines test that we can define tests in a namespace that
6112 // has the name "testing" and is nested in another namespace.
6113 namespace my_namespace {
6114 namespace testing {
6115
6116 // Makes sure that TEST knows to use ::testing::Test instead of
6117 // ::my_namespace::testing::Test.
6118 class Test {};
6119
6120 // Makes sure that an assertion knows to use ::testing::Message instead of
6121 // ::my_namespace::testing::Message.
6122 class Message {};
6123
6124 // Makes sure that an assertion knows to use
6125 // ::testing::AssertionResult instead of
6126 // ::my_namespace::testing::AssertionResult.
6127 class AssertionResult {};
6128
6129 // Tests that an assertion that should succeed works as expected.
TEST(NestedTestingNamespaceTest,Success)6130 TEST(NestedTestingNamespaceTest, Success) {
6131 EXPECT_EQ(1, 1) << "This shouldn't fail.";
6132 }
6133
6134 // Tests that an assertion that should fail works as expected.
TEST(NestedTestingNamespaceTest,Failure)6135 TEST(NestedTestingNamespaceTest, Failure) {
6136 EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.",
6137 "This failure is expected.");
6138 }
6139
6140 } // namespace testing
6141 } // namespace my_namespace
6142
6143 // Tests that one can call superclass SetUp and TearDown methods--
6144 // that is, that they are not private.
6145 // No tests are based on this fixture; the test "passes" if it compiles
6146 // successfully.
6147 class ProtectedFixtureMethodsTest : public Test {
6148 protected:
SetUp()6149 virtual void SetUp() {
6150 Test::SetUp();
6151 }
TearDown()6152 virtual void TearDown() {
6153 Test::TearDown();
6154 }
6155 };
6156
6157 // StreamingAssertionsTest tests the streaming versions of a representative
6158 // sample of assertions.
TEST(StreamingAssertionsTest,Unconditional)6159 TEST(StreamingAssertionsTest, Unconditional) {
6160 SUCCEED() << "expected success";
6161 EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure",
6162 "expected failure");
6163 EXPECT_FATAL_FAILURE(FAIL() << "expected failure",
6164 "expected failure");
6165 }
6166
6167 #ifdef __BORLANDC__
6168 // Silences warnings: "Condition is always true", "Unreachable code"
6169 # pragma option push -w-ccc -w-rch
6170 #endif
6171
TEST(StreamingAssertionsTest,Truth)6172 TEST(StreamingAssertionsTest, Truth) {
6173 EXPECT_TRUE(true) << "unexpected failure";
6174 ASSERT_TRUE(true) << "unexpected failure";
6175 EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure",
6176 "expected failure");
6177 EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure",
6178 "expected failure");
6179 }
6180
TEST(StreamingAssertionsTest,Truth2)6181 TEST(StreamingAssertionsTest, Truth2) {
6182 EXPECT_FALSE(false) << "unexpected failure";
6183 ASSERT_FALSE(false) << "unexpected failure";
6184 EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure",
6185 "expected failure");
6186 EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure",
6187 "expected failure");
6188 }
6189
6190 #ifdef __BORLANDC__
6191 // Restores warnings after previous "#pragma option push" supressed them
6192 # pragma option pop
6193 #endif
6194
TEST(StreamingAssertionsTest,IntegerEquals)6195 TEST(StreamingAssertionsTest, IntegerEquals) {
6196 EXPECT_EQ(1, 1) << "unexpected failure";
6197 ASSERT_EQ(1, 1) << "unexpected failure";
6198 EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure",
6199 "expected failure");
6200 EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure",
6201 "expected failure");
6202 }
6203
TEST(StreamingAssertionsTest,IntegerLessThan)6204 TEST(StreamingAssertionsTest, IntegerLessThan) {
6205 EXPECT_LT(1, 2) << "unexpected failure";
6206 ASSERT_LT(1, 2) << "unexpected failure";
6207 EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure",
6208 "expected failure");
6209 EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure",
6210 "expected failure");
6211 }
6212
TEST(StreamingAssertionsTest,StringsEqual)6213 TEST(StreamingAssertionsTest, StringsEqual) {
6214 EXPECT_STREQ("foo", "foo") << "unexpected failure";
6215 ASSERT_STREQ("foo", "foo") << "unexpected failure";
6216 EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure",
6217 "expected failure");
6218 EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure",
6219 "expected failure");
6220 }
6221
TEST(StreamingAssertionsTest,StringsNotEqual)6222 TEST(StreamingAssertionsTest, StringsNotEqual) {
6223 EXPECT_STRNE("foo", "bar") << "unexpected failure";
6224 ASSERT_STRNE("foo", "bar") << "unexpected failure";
6225 EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure",
6226 "expected failure");
6227 EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure",
6228 "expected failure");
6229 }
6230
TEST(StreamingAssertionsTest,StringsEqualIgnoringCase)6231 TEST(StreamingAssertionsTest, StringsEqualIgnoringCase) {
6232 EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure";
6233 ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure";
6234 EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure",
6235 "expected failure");
6236 EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure",
6237 "expected failure");
6238 }
6239
TEST(StreamingAssertionsTest,StringNotEqualIgnoringCase)6240 TEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) {
6241 EXPECT_STRCASENE("foo", "bar") << "unexpected failure";
6242 ASSERT_STRCASENE("foo", "bar") << "unexpected failure";
6243 EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure",
6244 "expected failure");
6245 EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure",
6246 "expected failure");
6247 }
6248
TEST(StreamingAssertionsTest,FloatingPointEquals)6249 TEST(StreamingAssertionsTest, FloatingPointEquals) {
6250 EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
6251 ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure";
6252 EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure",
6253 "expected failure");
6254 EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure",
6255 "expected failure");
6256 }
6257
6258 #if GTEST_HAS_EXCEPTIONS
6259
TEST(StreamingAssertionsTest,Throw)6260 TEST(StreamingAssertionsTest, Throw) {
6261 EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure";
6262 ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure";
6263 EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) <<
6264 "expected failure", "expected failure");
6265 EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) <<
6266 "expected failure", "expected failure");
6267 }
6268
TEST(StreamingAssertionsTest,NoThrow)6269 TEST(StreamingAssertionsTest, NoThrow) {
6270 EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure";
6271 ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure";
6272 EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) <<
6273 "expected failure", "expected failure");
6274 EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) <<
6275 "expected failure", "expected failure");
6276 }
6277
TEST(StreamingAssertionsTest,AnyThrow)6278 TEST(StreamingAssertionsTest, AnyThrow) {
6279 EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
6280 ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure";
6281 EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) <<
6282 "expected failure", "expected failure");
6283 EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) <<
6284 "expected failure", "expected failure");
6285 }
6286
6287 #endif // GTEST_HAS_EXCEPTIONS
6288
6289 // Tests that Google Test correctly decides whether to use colors in the output.
6290
TEST(ColoredOutputTest,UsesColorsWhenGTestColorFlagIsYes)6291 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) {
6292 GTEST_FLAG(color) = "yes";
6293
6294 SetEnv("TERM", "xterm"); // TERM supports colors.
6295 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6296 EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
6297
6298 SetEnv("TERM", "dumb"); // TERM doesn't support colors.
6299 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6300 EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
6301 }
6302
TEST(ColoredOutputTest,UsesColorsWhenGTestColorFlagIsAliasOfYes)6303 TEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) {
6304 SetEnv("TERM", "dumb"); // TERM doesn't support colors.
6305
6306 GTEST_FLAG(color) = "True";
6307 EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
6308
6309 GTEST_FLAG(color) = "t";
6310 EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
6311
6312 GTEST_FLAG(color) = "1";
6313 EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY.
6314 }
6315
TEST(ColoredOutputTest,UsesNoColorWhenGTestColorFlagIsNo)6316 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) {
6317 GTEST_FLAG(color) = "no";
6318
6319 SetEnv("TERM", "xterm"); // TERM supports colors.
6320 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6321 EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
6322
6323 SetEnv("TERM", "dumb"); // TERM doesn't support colors.
6324 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6325 EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
6326 }
6327
TEST(ColoredOutputTest,UsesNoColorWhenGTestColorFlagIsInvalid)6328 TEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) {
6329 SetEnv("TERM", "xterm"); // TERM supports colors.
6330
6331 GTEST_FLAG(color) = "F";
6332 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6333
6334 GTEST_FLAG(color) = "0";
6335 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6336
6337 GTEST_FLAG(color) = "unknown";
6338 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6339 }
6340
TEST(ColoredOutputTest,UsesColorsWhenStdoutIsTty)6341 TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
6342 GTEST_FLAG(color) = "auto";
6343
6344 SetEnv("TERM", "xterm"); // TERM supports colors.
6345 EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY.
6346 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6347 }
6348
TEST(ColoredOutputTest,UsesColorsWhenTermSupportsColors)6349 TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
6350 GTEST_FLAG(color) = "auto";
6351
6352 #if GTEST_OS_WINDOWS
6353 // On Windows, we ignore the TERM variable as it's usually not set.
6354
6355 SetEnv("TERM", "dumb");
6356 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6357
6358 SetEnv("TERM", "");
6359 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6360
6361 SetEnv("TERM", "xterm");
6362 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6363 #else
6364 // On non-Windows platforms, we rely on TERM to determine if the
6365 // terminal supports colors.
6366
6367 SetEnv("TERM", "dumb"); // TERM doesn't support colors.
6368 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6369
6370 SetEnv("TERM", "emacs"); // TERM doesn't support colors.
6371 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6372
6373 SetEnv("TERM", "vt100"); // TERM doesn't support colors.
6374 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6375
6376 SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors.
6377 EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY.
6378
6379 SetEnv("TERM", "xterm"); // TERM supports colors.
6380 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6381
6382 SetEnv("TERM", "xterm-color"); // TERM supports colors.
6383 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6384
6385 SetEnv("TERM", "xterm-256color"); // TERM supports colors.
6386 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6387
6388 SetEnv("TERM", "screen"); // TERM supports colors.
6389 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6390
6391 SetEnv("TERM", "linux"); // TERM supports colors.
6392 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6393
6394 SetEnv("TERM", "cygwin"); // TERM supports colors.
6395 EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
6396 #endif // GTEST_OS_WINDOWS
6397 }
6398
6399 // Verifies that StaticAssertTypeEq works in a namespace scope.
6400
6401 static bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
6402 static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
6403 StaticAssertTypeEq<const int, const int>();
6404
6405 // Verifies that StaticAssertTypeEq works in a class.
6406
6407 template <typename T>
6408 class StaticAssertTypeEqTestHelper {
6409 public:
StaticAssertTypeEqTestHelper()6410 StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); }
6411 };
6412
TEST(StaticAssertTypeEqTest,WorksInClass)6413 TEST(StaticAssertTypeEqTest, WorksInClass) {
6414 StaticAssertTypeEqTestHelper<bool>();
6415 }
6416
6417 // Verifies that StaticAssertTypeEq works inside a function.
6418
6419 typedef int IntAlias;
6420
TEST(StaticAssertTypeEqTest,CompilesForEqualTypes)6421 TEST(StaticAssertTypeEqTest, CompilesForEqualTypes) {
6422 StaticAssertTypeEq<int, IntAlias>();
6423 StaticAssertTypeEq<int*, IntAlias*>();
6424 }
6425
TEST(GetCurrentOsStackTraceExceptTopTest,ReturnsTheStackTrace)6426 TEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) {
6427 testing::UnitTest* const unit_test = testing::UnitTest::GetInstance();
6428
6429 // We don't have a stack walker in Google Test yet.
6430 EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str());
6431 EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str());
6432 }
6433
TEST(HasNonfatalFailureTest,ReturnsFalseWhenThereIsNoFailure)6434 TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) {
6435 EXPECT_FALSE(HasNonfatalFailure());
6436 }
6437
FailFatally()6438 static void FailFatally() { FAIL(); }
6439
TEST(HasNonfatalFailureTest,ReturnsFalseWhenThereIsOnlyFatalFailure)6440 TEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) {
6441 FailFatally();
6442 const bool has_nonfatal_failure = HasNonfatalFailure();
6443 ClearCurrentTestPartResults();
6444 EXPECT_FALSE(has_nonfatal_failure);
6445 }
6446
TEST(HasNonfatalFailureTest,ReturnsTrueWhenThereIsNonfatalFailure)6447 TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
6448 ADD_FAILURE();
6449 const bool has_nonfatal_failure = HasNonfatalFailure();
6450 ClearCurrentTestPartResults();
6451 EXPECT_TRUE(has_nonfatal_failure);
6452 }
6453
TEST(HasNonfatalFailureTest,ReturnsTrueWhenThereAreFatalAndNonfatalFailures)6454 TEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
6455 FailFatally();
6456 ADD_FAILURE();
6457 const bool has_nonfatal_failure = HasNonfatalFailure();
6458 ClearCurrentTestPartResults();
6459 EXPECT_TRUE(has_nonfatal_failure);
6460 }
6461
6462 // A wrapper for calling HasNonfatalFailure outside of a test body.
HasNonfatalFailureHelper()6463 static bool HasNonfatalFailureHelper() {
6464 return testing::Test::HasNonfatalFailure();
6465 }
6466
TEST(HasNonfatalFailureTest,WorksOutsideOfTestBody)6467 TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) {
6468 EXPECT_FALSE(HasNonfatalFailureHelper());
6469 }
6470
TEST(HasNonfatalFailureTest,WorksOutsideOfTestBody2)6471 TEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) {
6472 ADD_FAILURE();
6473 const bool has_nonfatal_failure = HasNonfatalFailureHelper();
6474 ClearCurrentTestPartResults();
6475 EXPECT_TRUE(has_nonfatal_failure);
6476 }
6477
TEST(HasFailureTest,ReturnsFalseWhenThereIsNoFailure)6478 TEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) {
6479 EXPECT_FALSE(HasFailure());
6480 }
6481
TEST(HasFailureTest,ReturnsTrueWhenThereIsFatalFailure)6482 TEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) {
6483 FailFatally();
6484 const bool has_failure = HasFailure();
6485 ClearCurrentTestPartResults();
6486 EXPECT_TRUE(has_failure);
6487 }
6488
TEST(HasFailureTest,ReturnsTrueWhenThereIsNonfatalFailure)6489 TEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) {
6490 ADD_FAILURE();
6491 const bool has_failure = HasFailure();
6492 ClearCurrentTestPartResults();
6493 EXPECT_TRUE(has_failure);
6494 }
6495
TEST(HasFailureTest,ReturnsTrueWhenThereAreFatalAndNonfatalFailures)6496 TEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) {
6497 FailFatally();
6498 ADD_FAILURE();
6499 const bool has_failure = HasFailure();
6500 ClearCurrentTestPartResults();
6501 EXPECT_TRUE(has_failure);
6502 }
6503
6504 // A wrapper for calling HasFailure outside of a test body.
HasFailureHelper()6505 static bool HasFailureHelper() { return testing::Test::HasFailure(); }
6506
TEST(HasFailureTest,WorksOutsideOfTestBody)6507 TEST(HasFailureTest, WorksOutsideOfTestBody) {
6508 EXPECT_FALSE(HasFailureHelper());
6509 }
6510
TEST(HasFailureTest,WorksOutsideOfTestBody2)6511 TEST(HasFailureTest, WorksOutsideOfTestBody2) {
6512 ADD_FAILURE();
6513 const bool has_failure = HasFailureHelper();
6514 ClearCurrentTestPartResults();
6515 EXPECT_TRUE(has_failure);
6516 }
6517
6518 class TestListener : public EmptyTestEventListener {
6519 public:
TestListener()6520 TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {}
TestListener(int * on_start_counter,bool * is_destroyed)6521 TestListener(int* on_start_counter, bool* is_destroyed)
6522 : on_start_counter_(on_start_counter),
6523 is_destroyed_(is_destroyed) {}
6524
~TestListener()6525 virtual ~TestListener() {
6526 if (is_destroyed_)
6527 *is_destroyed_ = true;
6528 }
6529
6530 protected:
OnTestProgramStart(const UnitTest &)6531 virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
6532 if (on_start_counter_ != NULL)
6533 (*on_start_counter_)++;
6534 }
6535
6536 private:
6537 int* on_start_counter_;
6538 bool* is_destroyed_;
6539 };
6540
6541 // Tests the constructor.
TEST(TestEventListenersTest,ConstructionWorks)6542 TEST(TestEventListenersTest, ConstructionWorks) {
6543 TestEventListeners listeners;
6544
6545 EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL);
6546 EXPECT_TRUE(listeners.default_result_printer() == NULL);
6547 EXPECT_TRUE(listeners.default_xml_generator() == NULL);
6548 }
6549
6550 // Tests that the TestEventListeners destructor deletes all the listeners it
6551 // owns.
TEST(TestEventListenersTest,DestructionWorks)6552 TEST(TestEventListenersTest, DestructionWorks) {
6553 bool default_result_printer_is_destroyed = false;
6554 bool default_xml_printer_is_destroyed = false;
6555 bool extra_listener_is_destroyed = false;
6556 TestListener* default_result_printer = new TestListener(
6557 NULL, &default_result_printer_is_destroyed);
6558 TestListener* default_xml_printer = new TestListener(
6559 NULL, &default_xml_printer_is_destroyed);
6560 TestListener* extra_listener = new TestListener(
6561 NULL, &extra_listener_is_destroyed);
6562
6563 {
6564 TestEventListeners listeners;
6565 TestEventListenersAccessor::SetDefaultResultPrinter(&listeners,
6566 default_result_printer);
6567 TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners,
6568 default_xml_printer);
6569 listeners.Append(extra_listener);
6570 }
6571 EXPECT_TRUE(default_result_printer_is_destroyed);
6572 EXPECT_TRUE(default_xml_printer_is_destroyed);
6573 EXPECT_TRUE(extra_listener_is_destroyed);
6574 }
6575
6576 // Tests that a listener Append'ed to a TestEventListeners list starts
6577 // receiving events.
TEST(TestEventListenersTest,Append)6578 TEST(TestEventListenersTest, Append) {
6579 int on_start_counter = 0;
6580 bool is_destroyed = false;
6581 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6582 {
6583 TestEventListeners listeners;
6584 listeners.Append(listener);
6585 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6586 *UnitTest::GetInstance());
6587 EXPECT_EQ(1, on_start_counter);
6588 }
6589 EXPECT_TRUE(is_destroyed);
6590 }
6591
6592 // Tests that listeners receive events in the order they were appended to
6593 // the list, except for *End requests, which must be received in the reverse
6594 // order.
6595 class SequenceTestingListener : public EmptyTestEventListener {
6596 public:
SequenceTestingListener(std::vector<std::string> * vector,const char * id)6597 SequenceTestingListener(std::vector<std::string>* vector, const char* id)
6598 : vector_(vector), id_(id) {}
6599
6600 protected:
OnTestProgramStart(const UnitTest &)6601 virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
6602 vector_->push_back(GetEventDescription("OnTestProgramStart"));
6603 }
6604
OnTestProgramEnd(const UnitTest &)6605 virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
6606 vector_->push_back(GetEventDescription("OnTestProgramEnd"));
6607 }
6608
OnTestIterationStart(const UnitTest &,int)6609 virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
6610 int /*iteration*/) {
6611 vector_->push_back(GetEventDescription("OnTestIterationStart"));
6612 }
6613
OnTestIterationEnd(const UnitTest &,int)6614 virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
6615 int /*iteration*/) {
6616 vector_->push_back(GetEventDescription("OnTestIterationEnd"));
6617 }
6618
6619 private:
GetEventDescription(const char * method)6620 std::string GetEventDescription(const char* method) {
6621 Message message;
6622 message << id_ << "." << method;
6623 return message.GetString();
6624 }
6625
6626 std::vector<std::string>* vector_;
6627 const char* const id_;
6628
6629 GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener);
6630 };
6631
TEST(EventListenerTest,AppendKeepsOrder)6632 TEST(EventListenerTest, AppendKeepsOrder) {
6633 std::vector<std::string> vec;
6634 TestEventListeners listeners;
6635 listeners.Append(new SequenceTestingListener(&vec, "1st"));
6636 listeners.Append(new SequenceTestingListener(&vec, "2nd"));
6637 listeners.Append(new SequenceTestingListener(&vec, "3rd"));
6638
6639 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6640 *UnitTest::GetInstance());
6641 ASSERT_EQ(3U, vec.size());
6642 EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str());
6643 EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str());
6644 EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str());
6645
6646 vec.clear();
6647 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd(
6648 *UnitTest::GetInstance());
6649 ASSERT_EQ(3U, vec.size());
6650 EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str());
6651 EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str());
6652 EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str());
6653
6654 vec.clear();
6655 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart(
6656 *UnitTest::GetInstance(), 0);
6657 ASSERT_EQ(3U, vec.size());
6658 EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str());
6659 EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str());
6660 EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str());
6661
6662 vec.clear();
6663 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd(
6664 *UnitTest::GetInstance(), 0);
6665 ASSERT_EQ(3U, vec.size());
6666 EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str());
6667 EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str());
6668 EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str());
6669 }
6670
6671 // Tests that a listener removed from a TestEventListeners list stops receiving
6672 // events and is not deleted when the list is destroyed.
TEST(TestEventListenersTest,Release)6673 TEST(TestEventListenersTest, Release) {
6674 int on_start_counter = 0;
6675 bool is_destroyed = false;
6676 // Although Append passes the ownership of this object to the list,
6677 // the following calls release it, and we need to delete it before the
6678 // test ends.
6679 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6680 {
6681 TestEventListeners listeners;
6682 listeners.Append(listener);
6683 EXPECT_EQ(listener, listeners.Release(listener));
6684 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6685 *UnitTest::GetInstance());
6686 EXPECT_TRUE(listeners.Release(listener) == NULL);
6687 }
6688 EXPECT_EQ(0, on_start_counter);
6689 EXPECT_FALSE(is_destroyed);
6690 delete listener;
6691 }
6692
6693 // Tests that no events are forwarded when event forwarding is disabled.
TEST(EventListenerTest,SuppressEventForwarding)6694 TEST(EventListenerTest, SuppressEventForwarding) {
6695 int on_start_counter = 0;
6696 TestListener* listener = new TestListener(&on_start_counter, NULL);
6697
6698 TestEventListeners listeners;
6699 listeners.Append(listener);
6700 ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
6701 TestEventListenersAccessor::SuppressEventForwarding(&listeners);
6702 ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners));
6703 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6704 *UnitTest::GetInstance());
6705 EXPECT_EQ(0, on_start_counter);
6706 }
6707
6708 // Tests that events generated by Google Test are not forwarded in
6709 // death test subprocesses.
TEST(EventListenerDeathTest,EventsNotForwardedInDeathTestSubprecesses)6710 TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) {
6711 EXPECT_DEATH_IF_SUPPORTED({
6712 GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(
6713 *GetUnitTestImpl()->listeners())) << "expected failure";},
6714 "expected failure");
6715 }
6716
6717 // Tests that a listener installed via SetDefaultResultPrinter() starts
6718 // receiving events and is returned via default_result_printer() and that
6719 // the previous default_result_printer is removed from the list and deleted.
TEST(EventListenerTest,default_result_printer)6720 TEST(EventListenerTest, default_result_printer) {
6721 int on_start_counter = 0;
6722 bool is_destroyed = false;
6723 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6724
6725 TestEventListeners listeners;
6726 TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
6727
6728 EXPECT_EQ(listener, listeners.default_result_printer());
6729
6730 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6731 *UnitTest::GetInstance());
6732
6733 EXPECT_EQ(1, on_start_counter);
6734
6735 // Replacing default_result_printer with something else should remove it
6736 // from the list and destroy it.
6737 TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL);
6738
6739 EXPECT_TRUE(listeners.default_result_printer() == NULL);
6740 EXPECT_TRUE(is_destroyed);
6741
6742 // After broadcasting an event the counter is still the same, indicating
6743 // the listener is not in the list anymore.
6744 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6745 *UnitTest::GetInstance());
6746 EXPECT_EQ(1, on_start_counter);
6747 }
6748
6749 // Tests that the default_result_printer listener stops receiving events
6750 // when removed via Release and that is not owned by the list anymore.
TEST(EventListenerTest,RemovingDefaultResultPrinterWorks)6751 TEST(EventListenerTest, RemovingDefaultResultPrinterWorks) {
6752 int on_start_counter = 0;
6753 bool is_destroyed = false;
6754 // Although Append passes the ownership of this object to the list,
6755 // the following calls release it, and we need to delete it before the
6756 // test ends.
6757 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6758 {
6759 TestEventListeners listeners;
6760 TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener);
6761
6762 EXPECT_EQ(listener, listeners.Release(listener));
6763 EXPECT_TRUE(listeners.default_result_printer() == NULL);
6764 EXPECT_FALSE(is_destroyed);
6765
6766 // Broadcasting events now should not affect default_result_printer.
6767 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6768 *UnitTest::GetInstance());
6769 EXPECT_EQ(0, on_start_counter);
6770 }
6771 // Destroying the list should not affect the listener now, too.
6772 EXPECT_FALSE(is_destroyed);
6773 delete listener;
6774 }
6775
6776 // Tests that a listener installed via SetDefaultXmlGenerator() starts
6777 // receiving events and is returned via default_xml_generator() and that
6778 // the previous default_xml_generator is removed from the list and deleted.
TEST(EventListenerTest,default_xml_generator)6779 TEST(EventListenerTest, default_xml_generator) {
6780 int on_start_counter = 0;
6781 bool is_destroyed = false;
6782 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6783
6784 TestEventListeners listeners;
6785 TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
6786
6787 EXPECT_EQ(listener, listeners.default_xml_generator());
6788
6789 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6790 *UnitTest::GetInstance());
6791
6792 EXPECT_EQ(1, on_start_counter);
6793
6794 // Replacing default_xml_generator with something else should remove it
6795 // from the list and destroy it.
6796 TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL);
6797
6798 EXPECT_TRUE(listeners.default_xml_generator() == NULL);
6799 EXPECT_TRUE(is_destroyed);
6800
6801 // After broadcasting an event the counter is still the same, indicating
6802 // the listener is not in the list anymore.
6803 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6804 *UnitTest::GetInstance());
6805 EXPECT_EQ(1, on_start_counter);
6806 }
6807
6808 // Tests that the default_xml_generator listener stops receiving events
6809 // when removed via Release and that is not owned by the list anymore.
TEST(EventListenerTest,RemovingDefaultXmlGeneratorWorks)6810 TEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) {
6811 int on_start_counter = 0;
6812 bool is_destroyed = false;
6813 // Although Append passes the ownership of this object to the list,
6814 // the following calls release it, and we need to delete it before the
6815 // test ends.
6816 TestListener* listener = new TestListener(&on_start_counter, &is_destroyed);
6817 {
6818 TestEventListeners listeners;
6819 TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener);
6820
6821 EXPECT_EQ(listener, listeners.Release(listener));
6822 EXPECT_TRUE(listeners.default_xml_generator() == NULL);
6823 EXPECT_FALSE(is_destroyed);
6824
6825 // Broadcasting events now should not affect default_xml_generator.
6826 TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart(
6827 *UnitTest::GetInstance());
6828 EXPECT_EQ(0, on_start_counter);
6829 }
6830 // Destroying the list should not affect the listener now, too.
6831 EXPECT_FALSE(is_destroyed);
6832 delete listener;
6833 }
6834
6835 // Sanity tests to ensure that the alternative, verbose spellings of
6836 // some of the macros work. We don't test them thoroughly as that
6837 // would be quite involved. Since their implementations are
6838 // straightforward, and they are rarely used, we'll just rely on the
6839 // users to tell us when they are broken.
GTEST_TEST(AlternativeNameTest,Works)6840 GTEST_TEST(AlternativeNameTest, Works) { // GTEST_TEST is the same as TEST.
6841 GTEST_SUCCEED() << "OK"; // GTEST_SUCCEED is the same as SUCCEED.
6842
6843 // GTEST_FAIL is the same as FAIL.
6844 EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure",
6845 "An expected failure");
6846
6847 // GTEST_ASSERT_XY is the same as ASSERT_XY.
6848
6849 GTEST_ASSERT_EQ(0, 0);
6850 EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure",
6851 "An expected failure");
6852 EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure",
6853 "An expected failure");
6854
6855 GTEST_ASSERT_NE(0, 1);
6856 GTEST_ASSERT_NE(1, 0);
6857 EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure",
6858 "An expected failure");
6859
6860 GTEST_ASSERT_LE(0, 0);
6861 GTEST_ASSERT_LE(0, 1);
6862 EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure",
6863 "An expected failure");
6864
6865 GTEST_ASSERT_LT(0, 1);
6866 EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure",
6867 "An expected failure");
6868 EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure",
6869 "An expected failure");
6870
6871 GTEST_ASSERT_GE(0, 0);
6872 GTEST_ASSERT_GE(1, 0);
6873 EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure",
6874 "An expected failure");
6875
6876 GTEST_ASSERT_GT(1, 0);
6877 EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure",
6878 "An expected failure");
6879 EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure",
6880 "An expected failure");
6881 }
6882
6883 // Tests for internal utilities necessary for implementation of the universal
6884 // printing.
6885 // TODO(vladl@google.com): Find a better home for them.
6886
6887 class ConversionHelperBase {};
6888 class ConversionHelperDerived : public ConversionHelperBase {};
6889
6890 // Tests that IsAProtocolMessage<T>::value is a compile-time constant.
TEST(IsAProtocolMessageTest,ValueIsCompileTimeConstant)6891 TEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) {
6892 GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value,
6893 const_true);
6894 GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false);
6895 }
6896
6897 // Tests that IsAProtocolMessage<T>::value is true when T is
6898 // proto2::Message or a sub-class of it.
TEST(IsAProtocolMessageTest,ValueIsTrueWhenTypeIsAProtocolMessage)6899 TEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) {
6900 EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value);
6901 EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value);
6902 }
6903
6904 // Tests that IsAProtocolMessage<T>::value is false when T is neither
6905 // ProtocolMessage nor a sub-class of it.
TEST(IsAProtocolMessageTest,ValueIsFalseWhenTypeIsNotAProtocolMessage)6906 TEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) {
6907 EXPECT_FALSE(IsAProtocolMessage<int>::value);
6908 EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value);
6909 }
6910
6911 // Tests that CompileAssertTypesEqual compiles when the type arguments are
6912 // equal.
TEST(CompileAssertTypesEqual,CompilesWhenTypesAreEqual)6913 TEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) {
6914 CompileAssertTypesEqual<void, void>();
6915 CompileAssertTypesEqual<int*, int*>();
6916 }
6917
6918 // Tests that RemoveReference does not affect non-reference types.
TEST(RemoveReferenceTest,DoesNotAffectNonReferenceType)6919 TEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) {
6920 CompileAssertTypesEqual<int, RemoveReference<int>::type>();
6921 CompileAssertTypesEqual<const char, RemoveReference<const char>::type>();
6922 }
6923
6924 // Tests that RemoveReference removes reference from reference types.
TEST(RemoveReferenceTest,RemovesReference)6925 TEST(RemoveReferenceTest, RemovesReference) {
6926 CompileAssertTypesEqual<int, RemoveReference<int&>::type>();
6927 CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>();
6928 }
6929
6930 // Tests GTEST_REMOVE_REFERENCE_.
6931
6932 template <typename T1, typename T2>
TestGTestRemoveReference()6933 void TestGTestRemoveReference() {
6934 CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>();
6935 }
6936
TEST(RemoveReferenceTest,MacroVersion)6937 TEST(RemoveReferenceTest, MacroVersion) {
6938 TestGTestRemoveReference<int, int>();
6939 TestGTestRemoveReference<const char, const char&>();
6940 }
6941
6942
6943 // Tests that RemoveConst does not affect non-const types.
TEST(RemoveConstTest,DoesNotAffectNonConstType)6944 TEST(RemoveConstTest, DoesNotAffectNonConstType) {
6945 CompileAssertTypesEqual<int, RemoveConst<int>::type>();
6946 CompileAssertTypesEqual<char&, RemoveConst<char&>::type>();
6947 }
6948
6949 // Tests that RemoveConst removes const from const types.
TEST(RemoveConstTest,RemovesConst)6950 TEST(RemoveConstTest, RemovesConst) {
6951 CompileAssertTypesEqual<int, RemoveConst<const int>::type>();
6952 CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>();
6953 CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>();
6954 }
6955
6956 // Tests GTEST_REMOVE_CONST_.
6957
6958 template <typename T1, typename T2>
TestGTestRemoveConst()6959 void TestGTestRemoveConst() {
6960 CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>();
6961 }
6962
TEST(RemoveConstTest,MacroVersion)6963 TEST(RemoveConstTest, MacroVersion) {
6964 TestGTestRemoveConst<int, int>();
6965 TestGTestRemoveConst<double&, double&>();
6966 TestGTestRemoveConst<char, const char>();
6967 }
6968
6969 // Tests GTEST_REMOVE_REFERENCE_AND_CONST_.
6970
6971 template <typename T1, typename T2>
TestGTestRemoveReferenceAndConst()6972 void TestGTestRemoveReferenceAndConst() {
6973 CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>();
6974 }
6975
TEST(RemoveReferenceToConstTest,Works)6976 TEST(RemoveReferenceToConstTest, Works) {
6977 TestGTestRemoveReferenceAndConst<int, int>();
6978 TestGTestRemoveReferenceAndConst<double, double&>();
6979 TestGTestRemoveReferenceAndConst<char, const char>();
6980 TestGTestRemoveReferenceAndConst<char, const char&>();
6981 TestGTestRemoveReferenceAndConst<const char*, const char*>();
6982 }
6983
6984 // Tests that AddReference does not affect reference types.
TEST(AddReferenceTest,DoesNotAffectReferenceType)6985 TEST(AddReferenceTest, DoesNotAffectReferenceType) {
6986 CompileAssertTypesEqual<int&, AddReference<int&>::type>();
6987 CompileAssertTypesEqual<const char&, AddReference<const char&>::type>();
6988 }
6989
6990 // Tests that AddReference adds reference to non-reference types.
TEST(AddReferenceTest,AddsReference)6991 TEST(AddReferenceTest, AddsReference) {
6992 CompileAssertTypesEqual<int&, AddReference<int>::type>();
6993 CompileAssertTypesEqual<const char&, AddReference<const char>::type>();
6994 }
6995
6996 // Tests GTEST_ADD_REFERENCE_.
6997
6998 template <typename T1, typename T2>
TestGTestAddReference()6999 void TestGTestAddReference() {
7000 CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>();
7001 }
7002
TEST(AddReferenceTest,MacroVersion)7003 TEST(AddReferenceTest, MacroVersion) {
7004 TestGTestAddReference<int&, int>();
7005 TestGTestAddReference<const char&, const char&>();
7006 }
7007
7008 // Tests GTEST_REFERENCE_TO_CONST_.
7009
7010 template <typename T1, typename T2>
TestGTestReferenceToConst()7011 void TestGTestReferenceToConst() {
7012 CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>();
7013 }
7014
TEST(GTestReferenceToConstTest,Works)7015 TEST(GTestReferenceToConstTest, Works) {
7016 TestGTestReferenceToConst<const char&, char>();
7017 TestGTestReferenceToConst<const int&, const int>();
7018 TestGTestReferenceToConst<const double&, double>();
7019 TestGTestReferenceToConst<const std::string&, const std::string&>();
7020 }
7021
7022 // Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant.
TEST(ImplicitlyConvertibleTest,ValueIsCompileTimeConstant)7023 TEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) {
7024 GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true);
7025 GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value),
7026 const_false);
7027 }
7028
7029 // Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can
7030 // be implicitly converted to T2.
TEST(ImplicitlyConvertibleTest,ValueIsTrueWhenConvertible)7031 TEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) {
7032 EXPECT_TRUE((ImplicitlyConvertible<int, double>::value));
7033 EXPECT_TRUE((ImplicitlyConvertible<double, int>::value));
7034 EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value));
7035 EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value));
7036 EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&,
7037 const ConversionHelperBase&>::value));
7038 EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase,
7039 ConversionHelperBase>::value));
7040 }
7041
7042 // Tests that ImplicitlyConvertible<T1, T2>::value is false when T1
7043 // cannot be implicitly converted to T2.
TEST(ImplicitlyConvertibleTest,ValueIsFalseWhenNotConvertible)7044 TEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) {
7045 EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value));
7046 EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value));
7047 EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value));
7048 EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&,
7049 ConversionHelperDerived&>::value));
7050 }
7051
7052 // Tests IsContainerTest.
7053
7054 class NonContainer {};
7055
TEST(IsContainerTestTest,WorksForNonContainer)7056 TEST(IsContainerTestTest, WorksForNonContainer) {
7057 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0)));
7058 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0)));
7059 EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0)));
7060 }
7061
TEST(IsContainerTestTest,WorksForContainer)7062 TEST(IsContainerTestTest, WorksForContainer) {
7063 EXPECT_EQ(sizeof(IsContainer),
7064 sizeof(IsContainerTest<std::vector<bool> >(0)));
7065 EXPECT_EQ(sizeof(IsContainer),
7066 sizeof(IsContainerTest<std::map<int, double> >(0)));
7067 }
7068
7069 // Tests ArrayEq().
7070
TEST(ArrayEqTest,WorksForDegeneratedArrays)7071 TEST(ArrayEqTest, WorksForDegeneratedArrays) {
7072 EXPECT_TRUE(ArrayEq(5, 5L));
7073 EXPECT_FALSE(ArrayEq('a', 0));
7074 }
7075
TEST(ArrayEqTest,WorksForOneDimensionalArrays)7076 TEST(ArrayEqTest, WorksForOneDimensionalArrays) {
7077 // Note that a and b are distinct but compatible types.
7078 const int a[] = { 0, 1 };
7079 long b[] = { 0, 1 };
7080 EXPECT_TRUE(ArrayEq(a, b));
7081 EXPECT_TRUE(ArrayEq(a, 2, b));
7082
7083 b[0] = 2;
7084 EXPECT_FALSE(ArrayEq(a, b));
7085 EXPECT_FALSE(ArrayEq(a, 1, b));
7086 }
7087
TEST(ArrayEqTest,WorksForTwoDimensionalArrays)7088 TEST(ArrayEqTest, WorksForTwoDimensionalArrays) {
7089 const char a[][3] = { "hi", "lo" };
7090 const char b[][3] = { "hi", "lo" };
7091 const char c[][3] = { "hi", "li" };
7092
7093 EXPECT_TRUE(ArrayEq(a, b));
7094 EXPECT_TRUE(ArrayEq(a, 2, b));
7095
7096 EXPECT_FALSE(ArrayEq(a, c));
7097 EXPECT_FALSE(ArrayEq(a, 2, c));
7098 }
7099
7100 // Tests ArrayAwareFind().
7101
TEST(ArrayAwareFindTest,WorksForOneDimensionalArray)7102 TEST(ArrayAwareFindTest, WorksForOneDimensionalArray) {
7103 const char a[] = "hello";
7104 EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o'));
7105 EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x'));
7106 }
7107
TEST(ArrayAwareFindTest,WorksForTwoDimensionalArray)7108 TEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) {
7109 int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
7110 const int b[2] = { 2, 3 };
7111 EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b));
7112
7113 const int c[2] = { 6, 7 };
7114 EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c));
7115 }
7116
7117 // Tests CopyArray().
7118
TEST(CopyArrayTest,WorksForDegeneratedArrays)7119 TEST(CopyArrayTest, WorksForDegeneratedArrays) {
7120 int n = 0;
7121 CopyArray('a', &n);
7122 EXPECT_EQ('a', n);
7123 }
7124
TEST(CopyArrayTest,WorksForOneDimensionalArrays)7125 TEST(CopyArrayTest, WorksForOneDimensionalArrays) {
7126 const char a[3] = "hi";
7127 int b[3];
7128 #ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions.
7129 CopyArray(a, &b);
7130 EXPECT_TRUE(ArrayEq(a, b));
7131 #endif
7132
7133 int c[3];
7134 CopyArray(a, 3, c);
7135 EXPECT_TRUE(ArrayEq(a, c));
7136 }
7137
TEST(CopyArrayTest,WorksForTwoDimensionalArrays)7138 TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
7139 const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } };
7140 int b[2][3];
7141 #ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions.
7142 CopyArray(a, &b);
7143 EXPECT_TRUE(ArrayEq(a, b));
7144 #endif
7145
7146 int c[2][3];
7147 CopyArray(a, 2, c);
7148 EXPECT_TRUE(ArrayEq(a, c));
7149 }
7150
7151 // Tests NativeArray.
7152
TEST(NativeArrayTest,ConstructorFromArrayWorks)7153 TEST(NativeArrayTest, ConstructorFromArrayWorks) {
7154 const int a[3] = { 0, 1, 2 };
7155 NativeArray<int> na(a, 3, kReference);
7156 EXPECT_EQ(3U, na.size());
7157 EXPECT_EQ(a, na.begin());
7158 }
7159
TEST(NativeArrayTest,CreatesAndDeletesCopyOfArrayWhenAskedTo)7160 TEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) {
7161 typedef int Array[2];
7162 Array* a = new Array[1];
7163 (*a)[0] = 0;
7164 (*a)[1] = 1;
7165 NativeArray<int> na(*a, 2, kCopy);
7166 EXPECT_NE(*a, na.begin());
7167 delete[] a;
7168 EXPECT_EQ(0, na.begin()[0]);
7169 EXPECT_EQ(1, na.begin()[1]);
7170
7171 // We rely on the heap checker to verify that na deletes the copy of
7172 // array.
7173 }
7174
TEST(NativeArrayTest,TypeMembersAreCorrect)7175 TEST(NativeArrayTest, TypeMembersAreCorrect) {
7176 StaticAssertTypeEq<char, NativeArray<char>::value_type>();
7177 StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>();
7178
7179 StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>();
7180 StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>();
7181 }
7182
TEST(NativeArrayTest,MethodsWork)7183 TEST(NativeArrayTest, MethodsWork) {
7184 const int a[3] = { 0, 1, 2 };
7185 NativeArray<int> na(a, 3, kCopy);
7186 ASSERT_EQ(3U, na.size());
7187 EXPECT_EQ(3, na.end() - na.begin());
7188
7189 NativeArray<int>::const_iterator it = na.begin();
7190 EXPECT_EQ(0, *it);
7191 ++it;
7192 EXPECT_EQ(1, *it);
7193 it++;
7194 EXPECT_EQ(2, *it);
7195 ++it;
7196 EXPECT_EQ(na.end(), it);
7197
7198 EXPECT_TRUE(na == na);
7199
7200 NativeArray<int> na2(a, 3, kReference);
7201 EXPECT_TRUE(na == na2);
7202
7203 const int b1[3] = { 0, 1, 1 };
7204 const int b2[4] = { 0, 1, 2, 3 };
7205 EXPECT_FALSE(na == NativeArray<int>(b1, 3, kReference));
7206 EXPECT_FALSE(na == NativeArray<int>(b2, 4, kCopy));
7207 }
7208
TEST(NativeArrayTest,WorksForTwoDimensionalArray)7209 TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
7210 const char a[2][3] = { "hi", "lo" };
7211 NativeArray<char[3]> na(a, 2, kReference);
7212 ASSERT_EQ(2U, na.size());
7213 EXPECT_EQ(a, na.begin());
7214 }
7215
7216 // Tests SkipPrefix().
7217
TEST(SkipPrefixTest,SkipsWhenPrefixMatches)7218 TEST(SkipPrefixTest, SkipsWhenPrefixMatches) {
7219 const char* const str = "hello";
7220
7221 const char* p = str;
7222 EXPECT_TRUE(SkipPrefix("", &p));
7223 EXPECT_EQ(str, p);
7224
7225 p = str;
7226 EXPECT_TRUE(SkipPrefix("hell", &p));
7227 EXPECT_EQ(str + 4, p);
7228 }
7229
TEST(SkipPrefixTest,DoesNotSkipWhenPrefixDoesNotMatch)7230 TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) {
7231 const char* const str = "world";
7232
7233 const char* p = str;
7234 EXPECT_FALSE(SkipPrefix("W", &p));
7235 EXPECT_EQ(str, p);
7236
7237 p = str;
7238 EXPECT_FALSE(SkipPrefix("world!", &p));
7239 EXPECT_EQ(str, p);
7240 }
7241