gtest_unittest.cc revision 8bdb31e0540c46de485b362178f60e8bb947ff43
1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc. 2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved. 3d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without 5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are 6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met: 7d201456903f3ecae1f7794edfab0d5678e64226shiqian// 8d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions of source code must retain the above copyright 9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer. 10d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions in binary form must reproduce the above 11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer 12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the 13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution. 14d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Neither the name of Google Inc. nor the names of its 15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from 16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission. 17d201456903f3ecae1f7794edfab0d5678e64226shiqian// 18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29d201456903f3ecae1f7794edfab0d5678e64226shiqian// 30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Author: wan@google.com (Zhanyong Wan) 31d201456903f3ecae1f7794edfab0d5678e64226shiqian// 32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for Google Test itself. This verifies that the basic constructs of 33d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test work. 34d201456903f3ecae1f7794edfab0d5678e64226shiqian 35d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <gtest/gtest.h> 36ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 37ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Verifies that the command line flag variables can be accessed 38ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// in code once <gtest/gtest.h> has been #included. 39ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Do not move it after other #includes. 40ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wanTEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { 41ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) 42ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(break_on_failure) 43ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(catch_exceptions) 44ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(color) != "unknown" 45ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(filter) != "unknown" 46ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(list_tests) 47ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(output) != "unknown" 48ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(print_time) 498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(random_seed) 50ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(repeat) > 0 51ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(show_internal_stack_frames) 528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(shuffle) 5340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(stack_trace_depth) > 0 5440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(throw_on_failure); 55ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. 56ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan} 57ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 58d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <gtest/gtest-spi.h> 59d201456903f3ecae1f7794edfab0d5678e64226shiqian 60d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 61d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 62d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 63d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 64d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_IMPLEMENTATION_ 1 66d201456903f3ecae1f7794edfab0d5678e64226shiqian#include "src/gtest-internal-inl.h" 670af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#undef GTEST_IMPLEMENTATION_ 68d201456903f3ecae1f7794edfab0d5678e64226shiqian 69ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan#include <limits.h> // For INT_MAX. 70d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 71c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <time.h> 72d201456903f3ecae1f7794edfab0d5678e64226shiqian 73e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_HAS_PTHREAD 74e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#include <pthread.h> 75e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_HAS_PTHREAD 76e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 77c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 78c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <map> 79c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 80c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 81600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan// GTEST_EXPECT_DEATH_IF_SUPPORTED_(statement, regex) expands to a 82600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan// real death test if death tests are supported; otherwise it expands 83600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan// to empty. 84600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#if GTEST_HAS_DEATH_TEST 85600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#define GTEST_EXPECT_DEATH_IF_SUPPORTED_(statement, regex) \ 86600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_DEATH(statement, regex) 87600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#else 88600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#define GTEST_EXPECT_DEATH_IF_SUPPORTED_(statement, regex) 89600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#endif 90600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 91d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 92d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 9364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianconst char* FormatTimeInMillisAsSeconds(TimeInMillis ms); 94b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 95d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32Flag(const char* str, const char* flag, Int32* value); 96b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 97b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// TestResult contains some private methods that should be hidden from 98b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Google Test user but are required for testing. This class allow our tests 99b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// to access them. 100b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanclass TestResultAccessor { 101b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan public: 102b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan static void RecordProperty(TestResult* test_result, 103b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestProperty& property) { 104b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan test_result->RecordProperty(property); 105b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 106b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 107b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan static void ClearTestPartResults(TestResult* test_result) { 108b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan test_result->ClearTestPartResults(); 109b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 110b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 11189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan static const Vector<testing::TestPartResult>& test_part_results( 112b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestResult& test_result) { 113b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return test_result.test_part_results(); 114b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 115b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan}; 116b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 117d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 118d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 119d201456903f3ecae1f7794edfab0d5678e64226shiqian 12064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianusing testing::internal::FormatTimeInMillisAsSeconds; 121d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ParseInt32Flag; 122d201456903f3ecae1f7794edfab0d5678e64226shiqian 123d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 124d201456903f3ecae1f7794edfab0d5678e64226shiqian 125e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianGTEST_DECLARE_string_(output); 126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianGTEST_DECLARE_string_(color); 127d201456903f3ecae1f7794edfab0d5678e64226shiqian 128d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 129d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ShouldUseColor(bool stdout_is_tty); 130d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 131d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 132d201456903f3ecae1f7794edfab0d5678e64226shiqian 1339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionFailure; 1349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionResult; 1359b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionSuccess; 1369b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::DoubleLE; 1379b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::FloatLE; 138fe186c382905dcf57014985ccea8e067275e9f5fshiqianusing testing::GTEST_FLAG(also_run_disabled_tests); 1399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(break_on_failure); 1409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(catch_exceptions); 14153e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::GTEST_FLAG(death_test_use_fork); 142d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::GTEST_FLAG(color); 1439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(filter); 1449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(list_tests); 1459b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(output); 1469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(print_time); 1478bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(random_seed); 1489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(repeat); 1499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(show_internal_stack_frames); 1508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(shuffle); 1519b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(stack_trace_depth); 15240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanusing testing::GTEST_FLAG(throw_on_failure); 1539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsNotSubstring; 1549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsSubstring; 1559b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Message; 156d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::ScopedFakeTestPartResultReporter; 15753e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::StaticAssertTypeEq; 1589b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Test; 159d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResult; 160d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResultArray; 1619b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_FATAL_FAILURE; 1629b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_NONFATAL_FAILURE; 1639b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_SUCCESS; 164d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::UnitTest; 1658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::kMaxRandomSeed; 166c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::kTestTypeIdInGoogleTest; 167d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::AppendUserMessage; 1680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::CodePointToUtf8; 169d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::EqFailure; 1709b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::FloatingPoint; 1713d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetCurrentOsStackTraceExceptTop; 1723d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetFailedPartCount; 1738bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetNextRandomSeed; 1748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetRandomSeedFromFlag; 175c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTestTypeId; 176c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTypeId; 177aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wanusing testing::internal::GetUnitTestImpl; 1789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::GTestFlagSaver; 179d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::Int32; 180cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::Int32FromEnvOrDie; 181cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldRunTestOnShard; 182cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldShard; 183d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ShouldUseColor; 184d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::StreamableToString; 185d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::String; 186b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanusing testing::internal::TestCase; 187d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestProperty; 188d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestResult; 189b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanusing testing::internal::TestResultAccessor; 190e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianusing testing::internal::ThreadLocal; 19189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanusing testing::internal::Vector; 1920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::WideStringToUtf8; 193d201456903f3ecae1f7794edfab0d5678e64226shiqian 194d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in an unnamed namespace. 195d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 196d201456903f3ecae1f7794edfab0d5678e64226shiqian 1978bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, HandlesZero) { 1988bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed = GetRandomSeedFromFlag(0); 1998bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed); 2008bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed)); 2018bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2028bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2038bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, PreservesValidSeed) { 2048bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetRandomSeedFromFlag(1)); 2058bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetRandomSeedFromFlag(2)); 2068bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1)); 2078bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 2088bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetRandomSeedFromFlag(kMaxRandomSeed)); 2098bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2108bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2118bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) { 2128bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed1 = GetRandomSeedFromFlag(-1); 2138bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed1); 2148bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed)); 2158bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2168bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1); 2178bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed2); 2188bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed)); 2198bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2208bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2218bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetNextRandomSeedTest, WorksForValidInput) { 2228bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetNextRandomSeed(1)); 2238bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(3, GetNextRandomSeed(2)); 2248bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 2258bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetNextRandomSeed(kMaxRandomSeed - 1)); 2268bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed)); 2278bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2288bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // We deliberately don't test GetNextRandomSeed() with invalid 2298bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // inputs, as that requires death tests, which are expensive. This 2308bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // is fine as GetNextRandomSeed() is internal and has a 2318bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // straightforward definition. 2328bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2338bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 234b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanstatic void ClearCurrentTestPartResults() { 235b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::ClearTestPartResults( 236b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetUnitTestImpl()->current_test_result()); 237b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan} 238b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 239c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Tests GetTypeId. 240c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 241c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsSameValueForSameType) { 242c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>()); 243c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>()); 244c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 245c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 246c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass SubClassOfTest : public Test {}; 247c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass AnotherSubClassOfTest : public Test {}; 248c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 249c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) { 250c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>()); 251c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<char>()); 252c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTestTypeId()); 253c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId()); 254c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId()); 255c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>()); 256c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 257c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 258c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Verifies that GetTestTypeId() returns the same value, no matter it 259c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// is called from inside Google Test or outside of it. 260c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) { 261c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId()); 262c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 263c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 26464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Tests FormatTimeInMillisAsSeconds(). 26564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 26664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsZero) { 26764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0", FormatTimeInMillisAsSeconds(0)); 26864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 26964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 27064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) { 27164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.003", FormatTimeInMillisAsSeconds(3)); 27264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.01", FormatTimeInMillisAsSeconds(10)); 27364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.2", FormatTimeInMillisAsSeconds(200)); 27464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("1.2", FormatTimeInMillisAsSeconds(1200)); 27564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("3", FormatTimeInMillisAsSeconds(3000)); 27664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 27764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 27864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) { 27964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.003", FormatTimeInMillisAsSeconds(-3)); 28064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.01", FormatTimeInMillisAsSeconds(-10)); 28164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.2", FormatTimeInMillisAsSeconds(-200)); 28264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-1.2", FormatTimeInMillisAsSeconds(-1200)); 28364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-3", FormatTimeInMillisAsSeconds(-3000)); 28464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 28564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 2860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 287d201456903f3ecae1f7794edfab0d5678e64226shiqian// NULL testing does not work with Symbian compilers. 288d201456903f3ecae1f7794edfab0d5678e64226shiqian 289c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 290c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 291c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 292c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 293c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 294e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null 295d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 296d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsTrueForNullLiterals) { 297e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL)); 298e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0)); 299e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U)); 300e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L)); 301e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(false)); 302c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 303c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Some compilers may fail to detect some null pointer literals; 304c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // as long as users of the framework don't use such literals, this 305c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // is harmless. 306c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1)); 307e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(true && false)); 308c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 309d201456903f3ecae1f7794edfab0d5678e64226shiqian} 310d201456903f3ecae1f7794edfab0d5678e64226shiqian 311e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null 312d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 313d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 314e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1)); 315e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0)); 316e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a')); 317e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL))); 318d201456903f3ecae1f7794edfab0d5678e64226shiqian} 319d201456903f3ecae1f7794edfab0d5678e64226shiqian 320c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 321c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 322c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 323c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 324c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 3270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests CodePointToUtf8(). 328d201456903f3ecae1f7794edfab0d5678e64226shiqian 329d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the NUL character L'\0' is encoded correctly. 3300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeNul) { 3310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 3320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer)); 333d201456903f3ecae1f7794edfab0d5678e64226shiqian} 334d201456903f3ecae1f7794edfab0d5678e64226shiqian 335d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASCII characters are encoded correctly. 3360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeAscii) { 3370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 3380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer)); 3390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer)); 3400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer)); 3410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer)); 342d201456903f3ecae1f7794edfab0d5678e64226shiqian} 343d201456903f3ecae1f7794edfab0d5678e64226shiqian 344d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 8 to 11 bits are encoded 345d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 110xxxxx 10xxxxxx. 3460c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 3470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 348d201456903f3ecae1f7794edfab0d5678e64226shiqian // 000 1101 0011 => 110-00011 10-010011 3490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer)); 350d201456903f3ecae1f7794edfab0d5678e64226shiqian 351d201456903f3ecae1f7794edfab0d5678e64226shiqian // 101 0111 0110 => 110-10101 10-110110 3520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", CodePointToUtf8(L'\x576', buffer)); 353d201456903f3ecae1f7794edfab0d5678e64226shiqian} 354d201456903f3ecae1f7794edfab0d5678e64226shiqian 355d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 12 to 16 bits are encoded 356d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 1110xxxx 10xxxxxx 10xxxxxx. 3570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 3580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 359d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 3600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", CodePointToUtf8(L'\x8D3', buffer)); 361d201456903f3ecae1f7794edfab0d5678e64226shiqian 362d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 3630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer)); 364d201456903f3ecae1f7794edfab0d5678e64226shiqian} 365d201456903f3ecae1f7794edfab0d5678e64226shiqian 3660af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 367d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests in this group require a wchar_t to hold > 16 bits, and thus 368e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 3690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 16-bit wide. This code may not compile on those systems. 370d201456903f3ecae1f7794edfab0d5678e64226shiqian 371d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 17 to 21 bits are encoded 372d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 3730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 3740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 375d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 3760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer)); 3770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 3790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer)); 380d201456903f3ecae1f7794edfab0d5678e64226shiqian 3810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 3820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer)); 383d201456903f3ecae1f7794edfab0d5678e64226shiqian} 384d201456903f3ecae1f7794edfab0d5678e64226shiqian 385d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that encoding an invalid code-point generates the expected result. 3860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 3870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 388d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)", 3890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev CodePointToUtf8(L'\x1234ABCD', buffer)); 3900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3920af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 3930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests WideStringToUtf8(). 3950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the NUL character L'\0' is encoded correctly. 3970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeNul) { 3980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 3990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 4000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that ASCII strings are encoded correctly. 4030c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeAscii) { 4040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 4050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 4060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 4070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 4080c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 8 to 11 bits are encoded 4110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 110xxxxx 10xxxxxx. 4120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 4130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 000 1101 0011 => 110-00011 10-010011 4140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 4150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 4160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 101 0111 0110 => 110-10101 10-110110 4180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", 1).c_str()); 4190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", -1).c_str()); 4200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 12 to 16 bits are encoded 4230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 1110xxxx 10xxxxxx 10xxxxxx. 4240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 4250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 4260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", 1).c_str()); 4270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", -1).c_str()); 4280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 4300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", 1).c_str()); 4310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", -1).c_str()); 432d201456903f3ecae1f7794edfab0d5678e64226shiqian} 433d201456903f3ecae1f7794edfab0d5678e64226shiqian 4340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function encounters \0 character. 4350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 4360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 4370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function reaches the limit 4400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// specified by the 'length' parameter. 4410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 4420c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 4430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4460af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 4470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 17 to 21 bits are encoded 4480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 4490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// on the systems using UTF-16 encoding. 4500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 4510c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 4520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 4530c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 4540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4550c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 4560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 4570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 4580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid code-point generates the expected result. 4610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 4620c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 4630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xABCDFF", -1).c_str()); 4640c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#else // !GTEST_WIDE_STRING_USES_UTF16_ 4660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that surrogate pairs are encoded correctly on the systems using 4670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// UTF-16 encoding in the wide strings. 4680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 4690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", 4700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xD801\xDC00", -1).c_str()); 4710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid UTF-16 surrogate pair 4740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// generates the expected result. 4750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 4760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is at the end of the string. 4770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(L"\xD800", -1).c_str()); 4780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is not followed by the trailing surrogate. 4790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80$", WideStringToUtf8(L"\xD800$", -1).c_str()); 4800c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Trailing surrogate appearas without a leading surrogate. 4810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str()); 4820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 4840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that codepoint concatenation works correctly. 4860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 4870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 4880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 4890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4" 4900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" 4910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\n" 4920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xD5\xB6" 4930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xE0\xA3\x93" 4940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4", 4950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\x108634\xC74D\n\x576\x8D3\x108634", -1).c_str()); 4960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 4980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 4990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 5000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 5010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str()); 5020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5030af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 504d201456903f3ecae1f7794edfab0d5678e64226shiqian 50589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests the Vector class template. 506600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 50789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::Clear(). 50889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, Clear) { 50989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 510600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack(1); 511600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Clear(); 512600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, a.size()); 513600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 514600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack(2); 515600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack(3); 516600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Clear(); 517600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, a.size()); 518600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan} 519600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 52089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::PushBack(). 52189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, PushBack) { 52289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<char> a; 523600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack('a'); 524600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(1, a.size()); 525600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('a', a.GetElement(0)); 526600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 527600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack('b'); 528600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(2, a.size()); 529600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('a', a.GetElement(0)); 530600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('b', a.GetElement(1)); 531600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan} 532d201456903f3ecae1f7794edfab0d5678e64226shiqian 53389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::PushFront(). 53489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, PushFront) { 53589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 536600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(0, a.size()); 537d201456903f3ecae1f7794edfab0d5678e64226shiqian 53889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Calls PushFront() on an empty Vector. 539d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(1); 540600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(1, a.size()); 541600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(0)); 542d201456903f3ecae1f7794edfab0d5678e64226shiqian 54389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Calls PushFront() on a singleton Vector. 544d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 545600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(2, a.size()); 546600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(0)); 547600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(1)); 548d201456903f3ecae1f7794edfab0d5678e64226shiqian 54989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Calls PushFront() on a Vector with more than one elements. 550d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 551600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(3, a.size()); 552600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(3, a.GetElement(0)); 553600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(1)); 554600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(2)); 555d201456903f3ecae1f7794edfab0d5678e64226shiqian} 556d201456903f3ecae1f7794edfab0d5678e64226shiqian 55789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::PopFront(). 55889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, PopFront) { 55989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 560d201456903f3ecae1f7794edfab0d5678e64226shiqian 56189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Popping on an empty Vector should fail. 562d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(NULL)); 563d201456903f3ecae1f7794edfab0d5678e64226shiqian 56489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Popping again on an empty Vector should fail, and the result element 565d201456903f3ecae1f7794edfab0d5678e64226shiqian // shouldn't be overwritten. 566d201456903f3ecae1f7794edfab0d5678e64226shiqian int element = 1; 567d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(&element)); 568d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, element); 569d201456903f3ecae1f7794edfab0d5678e64226shiqian 570d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 571d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 572d201456903f3ecae1f7794edfab0d5678e64226shiqian 57389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // PopFront() should pop the element in the front of the Vector. 574d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(&element)); 575d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, element); 576d201456903f3ecae1f7794edfab0d5678e64226shiqian 57789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // After popping the last element, the Vector should be empty. 578d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(NULL)); 579600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, a.size()); 580d201456903f3ecae1f7794edfab0d5678e64226shiqian} 581d201456903f3ecae1f7794edfab0d5678e64226shiqian 58289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests inserting at the beginning using Vector::Insert(). 58389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, InsertAtBeginning) { 58489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 585600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(0, a.size()); 586d201456903f3ecae1f7794edfab0d5678e64226shiqian 58789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts into an empty Vector. 588600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(1, 0); 589600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(1, a.size()); 590600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(0)); 591d201456903f3ecae1f7794edfab0d5678e64226shiqian 59289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts at the beginning of a singleton Vector. 593600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(2, 0); 594600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(2, a.size()); 595600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(0)); 596600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(1)); 597d201456903f3ecae1f7794edfab0d5678e64226shiqian 59889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts at the beginning of a Vector with more than one elements. 599600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(3, 0); 600600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(3, a.size()); 601600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(3, a.GetElement(0)); 602600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(1)); 603600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(2)); 604d201456903f3ecae1f7794edfab0d5678e64226shiqian} 605d201456903f3ecae1f7794edfab0d5678e64226shiqian 606d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests inserting at a location other than the beginning using 60789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Vector::Insert(). 60889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, InsertNotAtBeginning) { 60989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Prepares a singleton Vector. 61089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 611d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushBack(1); 612d201456903f3ecae1f7794edfab0d5678e64226shiqian 61389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts at the end of a singleton Vector. 614600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(2, a.size()); 615600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(2, a.size()); 616600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(0)); 617600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(1)); 618d201456903f3ecae1f7794edfab0d5678e64226shiqian 61989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts at the end of a Vector with more than one elements. 620600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(3, a.size()); 621600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(3, a.size()); 622600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(0)); 623600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(1)); 624600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(3, a.GetElement(2)); 625d201456903f3ecae1f7794edfab0d5678e64226shiqian 62689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Inserts in the middle of a Vector. 627600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.Insert(4, 1); 628600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ASSERT_EQ(4, a.size()); 629600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(0)); 630600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(4, a.GetElement(1)); 631600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(2)); 632600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(3, a.GetElement(3)); 633600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan} 634600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 63589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::GetElementOr(). 63689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorTest, GetElementOr) { 63789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<char> a; 638600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('x', a.GetElementOr(0, 'x')); 639600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 640600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack('a'); 641600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.PushBack('b'); 642600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('a', a.GetElementOr(0, 'x')); 643600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('b', a.GetElementOr(1, 'x')); 644600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('x', a.GetElementOr(-2, 'x')); 645600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ('x', a.GetElementOr(2, 'x')); 646d201456903f3ecae1f7794edfab0d5678e64226shiqian} 647d201456903f3ecae1f7794edfab0d5678e64226shiqian 64889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan// Tests Vector::Erase(). 64989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wanTEST(VectorDeathTest, Erase) { 65089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 65189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 65289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests erasing from an empty vector. 65389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 65489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a.Erase(0), 65589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index 0: must be in range \\[0, -1\\]\\."); 65689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 65789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests erasing from a singleton vector. 65889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a.PushBack(0); 65989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 66089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a.Erase(0); 66189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(0, a.size()); 66289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 66389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests Erase parameters beyond the bounds of the vector. 66489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a1; 66589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a1.PushBack(0); 66689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a1.PushBack(1); 66789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a1.PushBack(2); 66889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 66989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 67089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a1.Erase(3), 67189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index 3: must be in range \\[0, 2\\]\\."); 67289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 67389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a1.Erase(-1), 67489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index -1: must be in range \\[0, 2\\]\\."); 67589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 67689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests erasing at the end of the vector. 67789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a2; 67889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a2.PushBack(0); 67989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a2.PushBack(1); 68089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a2.PushBack(2); 68189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 68289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a2.Erase(2); 68389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan ASSERT_EQ(2, a2.size()); 68489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(0, a2.GetElement(0)); 68589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(1, a2.GetElement(1)); 68689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 68789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests erasing in the middle of the vector. 68889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a3; 68989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a3.PushBack(0); 69089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a3.PushBack(1); 69189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a3.PushBack(2); 69289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 69389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a3.Erase(1); 69489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan ASSERT_EQ(2, a3.size()); 69589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(0, a3.GetElement(0)); 69689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(2, a3.GetElement(1)); 69789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 69889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // Tests erasing at the beginning of the vector. 69989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a4; 70089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a4.PushBack(0); 70189080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a4.PushBack(1); 70289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a4.PushBack(2); 70389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 70489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan a4.Erase(0); 70589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan ASSERT_EQ(2, a4.size()); 70689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(1, a4.GetElement(0)); 70789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_EQ(2, a4.GetElement(1)); 70889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan} 70989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 710e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests the GetElement accessor. 711600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST(ListDeathTest, GetElement) { 71289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan Vector<int> a; 713e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan a.PushBack(0); 714e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan a.PushBack(1); 715e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan a.PushBack(2); 716e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 717600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, a.GetElement(0)); 718600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(1, a.GetElement(1)); 719600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, a.GetElement(2)); 720600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 721600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.GetElement(3), 72289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index 3: must be in range \\[0, 2\\]\\."); 723600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 724600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan a.GetElement(-1), 72589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index -1: must be in range \\[0, 2\\]\\."); 726e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 727d201456903f3ecae1f7794edfab0d5678e64226shiqian 728d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the String class. 729d201456903f3ecae1f7794edfab0d5678e64226shiqian 730d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String's constructors. 731d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Constructors) { 732d201456903f3ecae1f7794edfab0d5678e64226shiqian // Default ctor. 733d201456903f3ecae1f7794edfab0d5678e64226shiqian String s1; 734bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing 735bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // pointers with NULL isn't supported on all platforms. 736bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(NULL == s1.c_str()); 737d201456903f3ecae1f7794edfab0d5678e64226shiqian 738d201456903f3ecae1f7794edfab0d5678e64226shiqian // Implicitly constructs from a C-string. 739d201456903f3ecae1f7794edfab0d5678e64226shiqian String s2 = "Hi"; 740d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Hi", s2.c_str()); 741d201456903f3ecae1f7794edfab0d5678e64226shiqian 742d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs from a C-string and a length. 743d201456903f3ecae1f7794edfab0d5678e64226shiqian String s3("hello", 3); 744d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s3.c_str()); 745d201456903f3ecae1f7794edfab0d5678e64226shiqian 746d201456903f3ecae1f7794edfab0d5678e64226shiqian // Copy ctor. 747d201456903f3ecae1f7794edfab0d5678e64226shiqian String s4 = s3; 748d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s4.c_str()); 749d201456903f3ecae1f7794edfab0d5678e64226shiqian} 750d201456903f3ecae1f7794edfab0d5678e64226shiqian 7511998cf5d32a19aaffe8652545802744d9133022dvladlosev#if GTEST_HAS_STD_STRING 7521998cf5d32a19aaffe8652545802744d9133022dvladlosev 7531998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromStdString) { 7541998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty std::string. 7551998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src1(""); 7561998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 7571998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 7581998cf5d32a19aaffe8652545802744d9133022dvladlosev 7591998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal std::string. 7601998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src2("Hi"); 7611998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 7621998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 7631998cf5d32a19aaffe8652545802744d9133022dvladlosev 7641998cf5d32a19aaffe8652545802744d9133022dvladlosev // An std::string with an embedded NUL character. 7651998cf5d32a19aaffe8652545802744d9133022dvladlosev const char src3[] = "Hello\0world."; 7661998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = std::string(src3, sizeof(src3)); 7671998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hello", dest3.c_str()); 7681998cf5d32a19aaffe8652545802744d9133022dvladlosev} 7691998cf5d32a19aaffe8652545802744d9133022dvladlosev 7701998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToStdString) { 7711998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 7721998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 7731998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest1 = src1; 7741998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 7751998cf5d32a19aaffe8652545802744d9133022dvladlosev 7761998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 7771998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 7781998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest2 = src2; 7791998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 7801998cf5d32a19aaffe8652545802744d9133022dvladlosev} 7811998cf5d32a19aaffe8652545802744d9133022dvladlosev 7821998cf5d32a19aaffe8652545802744d9133022dvladlosev#endif // GTEST_HAS_STD_STRING 7831998cf5d32a19aaffe8652545802744d9133022dvladlosev 7841998cf5d32a19aaffe8652545802744d9133022dvladlosev#if GTEST_HAS_GLOBAL_STRING 7851998cf5d32a19aaffe8652545802744d9133022dvladlosev 7861998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromGlobalString) { 7871998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty ::string. 7881998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src1(""); 7891998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 7901998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 7911998cf5d32a19aaffe8652545802744d9133022dvladlosev 7921998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal ::string. 7931998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src2("Hi"); 7941998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 7951998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 7961998cf5d32a19aaffe8652545802744d9133022dvladlosev 7971998cf5d32a19aaffe8652545802744d9133022dvladlosev // An ::string with an embedded NUL character. 7981998cf5d32a19aaffe8652545802744d9133022dvladlosev const char src3[] = "Hello\0world."; 7991998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = ::string(src3, sizeof(src3)); 8001998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hello", dest3.c_str()); 8011998cf5d32a19aaffe8652545802744d9133022dvladlosev} 8021998cf5d32a19aaffe8652545802744d9133022dvladlosev 8031998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToGlobalString) { 8041998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 8051998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 8061998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest1 = src1; 8071998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 8081998cf5d32a19aaffe8652545802744d9133022dvladlosev 8091998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 8101998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 8111998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest2 = src2; 8121998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 8131998cf5d32a19aaffe8652545802744d9133022dvladlosev} 8141998cf5d32a19aaffe8652545802744d9133022dvladlosev 8151998cf5d32a19aaffe8652545802744d9133022dvladlosev#endif // GTEST_HAS_GLOBAL_STRING 8161998cf5d32a19aaffe8652545802744d9133022dvladlosev 817d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCString(). 818d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCString) { 819d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", String::ShowCString(NULL)); 820d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowCString("")); 821d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowCString("foo")); 822d201456903f3ecae1f7794edfab0d5678e64226shiqian} 823d201456903f3ecae1f7794edfab0d5678e64226shiqian 824d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCStringQuoted(). 825d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCStringQuoted) { 826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 827d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted(NULL).c_str()); 828d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"\"", 829d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("").c_str()); 830d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"foo\"", 831d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("foo").c_str()); 832d201456903f3ecae1f7794edfab0d5678e64226shiqian} 833d201456903f3ecae1f7794edfab0d5678e64226shiqian 834d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator==(). 835d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Equals) { 836d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null == NULL); // NOLINT 838d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == ""); // NOLINT 839d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == "bar"); // NOLINT 840d201456903f3ecae1f7794edfab0d5678e64226shiqian 841d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 842d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == NULL); // NOLINT 843d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty == ""); // NOLINT 844d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == "bar"); // NOLINT 845d201456903f3ecae1f7794edfab0d5678e64226shiqian 846d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 847d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == NULL); // NOLINT 848d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == ""); // NOLINT 849d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == "bar"); // NOLINT 850d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo == "foo"); // NOLINT 851d201456903f3ecae1f7794edfab0d5678e64226shiqian} 852d201456903f3ecae1f7794edfab0d5678e64226shiqian 853d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator!=(). 854d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, NotEquals) { 855d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 856d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null != NULL); // NOLINT 857d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != ""); // NOLINT 858d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != "bar"); // NOLINT 859d201456903f3ecae1f7794edfab0d5678e64226shiqian 860d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 861d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != NULL); // NOLINT 862d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty != ""); // NOLINT 863d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != "bar"); // NOLINT 864d201456903f3ecae1f7794edfab0d5678e64226shiqian 865d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 866d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != NULL); // NOLINT 867d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != ""); // NOLINT 868d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != "bar"); // NOLINT 869d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo != "foo"); // NOLINT 870d201456903f3ecae1f7794edfab0d5678e64226shiqian} 871d201456903f3ecae1f7794edfab0d5678e64226shiqian 872d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWith(). 873d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWith) { 874d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("bar")); 875d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("")); 876d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWith("")); 877d201456903f3ecae1f7794edfab0d5678e64226shiqian 878d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWith("foo")); 879d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWith("foo")); 880d201456903f3ecae1f7794edfab0d5678e64226shiqian} 881d201456903f3ecae1f7794edfab0d5678e64226shiqian 882d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWithCaseInsensitive(). 883d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWithCaseInsensitive) { 884d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR")); 885d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar")); 886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("")); 887d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWithCaseInsensitive("")); 888d201456903f3ecae1f7794edfab0d5678e64226shiqian 889d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo")); 890d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo")); 891d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo")); 892d201456903f3ecae1f7794edfab0d5678e64226shiqian} 893d201456903f3ecae1f7794edfab0d5678e64226shiqian 894c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// C++Builder's preprocessor is buggy; it fails to expand macros that 895c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// appear in macro parameters after wide char literals. Provide an alias 896c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// for NULL as a workaround. 897c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic const wchar_t* const kNull = NULL; 898c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 899a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests String::CaseInsensitiveWideCStringEquals 900a2b1a8556ea64014606d78b09333d9c522430a25shiqianTEST(StringTest, CaseInsensitiveWideCStringEquals) { 901a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 902c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"")); 903c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull)); 904c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar")); 905c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull)); 906a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 907a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 908a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 909a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 910a2b1a8556ea64014606d78b09333d9c522430a25shiqian 911d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that NULL can be assigned to a String. 912d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNULL) { 913d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(NULL); 914d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 915d201456903f3ecae1f7794edfab0d5678e64226shiqian 916d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 917d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(NULL, dest.c_str()); 918d201456903f3ecae1f7794edfab0d5678e64226shiqian} 919d201456903f3ecae1f7794edfab0d5678e64226shiqian 920d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the empty string "" can be assigned to a String. 921d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedEmpty) { 922d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(""); 923d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 924d201456903f3ecae1f7794edfab0d5678e64226shiqian 925d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 926d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", dest.c_str()); 927d201456903f3ecae1f7794edfab0d5678e64226shiqian} 928d201456903f3ecae1f7794edfab0d5678e64226shiqian 929d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a non-empty string can be assigned to a String. 930d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNonEmpty) { 931d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src("hello"); 932d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 933d201456903f3ecae1f7794edfab0d5678e64226shiqian 934d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 935d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 936d201456903f3ecae1f7794edfab0d5678e64226shiqian} 937d201456903f3ecae1f7794edfab0d5678e64226shiqian 938d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a String can be assigned to itself. 939d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedSelf) { 940d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest("hello"); 941d201456903f3ecae1f7794edfab0d5678e64226shiqian 942d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = dest; 943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 944d201456903f3ecae1f7794edfab0d5678e64226shiqian} 945d201456903f3ecae1f7794edfab0d5678e64226shiqian 9460af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 947d201456903f3ecae1f7794edfab0d5678e64226shiqian 948d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCString(). 949d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCString) { 950d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 951d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCString(NULL).c_str()); 952d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 953d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 954d201456903f3ecae1f7794edfab0d5678e64226shiqian} 955d201456903f3ecae1f7794edfab0d5678e64226shiqian 956d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCStringQuoted(). 957d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCStringQuoted) { 958d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 959d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(NULL).c_str()); 960d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"\"", 961d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"").c_str()); 962d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"foo\"", 963d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"foo").c_str()); 964d201456903f3ecae1f7794edfab0d5678e64226shiqian} 965d201456903f3ecae1f7794edfab0d5678e64226shiqian 966bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#ifdef _WIN32_WCE 967bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16Null) { 968bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 969bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 970bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 971bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 972bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertBasic) { 973bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L"str"); 974bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ("str", ansi); 975bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 976bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16("str"); 977ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L"str", utf16, 3)); 978bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 979bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 980bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 981bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 982bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 983bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ(".:\\ \"*?", ansi); 984bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 985bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 986ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3)); 987bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 988bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 989bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#endif // _WIN32_WCE 990bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 991d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 992d201456903f3ecae1f7794edfab0d5678e64226shiqian 993d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty construction. 994d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, StringValue) { 995d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 996d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key", property.key()); 997d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 998d201456903f3ecae1f7794edfab0d5678e64226shiqian} 999d201456903f3ecae1f7794edfab0d5678e64226shiqian 1000d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty replacing a value. 1001d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, ReplaceStringValue) { 1002d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 1003d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 1004d201456903f3ecae1f7794edfab0d5678e64226shiqian property.SetValue("2"); 1005d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", property.value()); 1006d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1007d201456903f3ecae1f7794edfab0d5678e64226shiqian 1008c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// AddFatalFailure() and AddNonfatalFailure() must be stand-alone 1009c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// functions (i.e. their definitions cannot be inlined at the call 1010c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// sites), or C++Builder won't compile the code. 1011c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddFatalFailure() { 1012c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FAIL() << "Expected fatal failure."; 1013c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1014c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1015c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddNonfatalFailure() { 1016c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ADD_FAILURE() << "Expected non-fatal failure."; 1017c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1018c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1019e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterTest : public Test { 10208de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 1021e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian enum FailureMode { 1022e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FATAL_FAILURE, 1023e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NONFATAL_FAILURE 1024e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }; 1025e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailure(FailureMode failure) { 1026e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (failure == FATAL_FAILURE) { 1027c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1028e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } else { 1029c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1030e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1031e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1032d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian 1034e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that ScopedFakeTestPartResultReporter intercepts test 1035e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// failures. 1036e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 1037e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1038e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1039e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1040e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 1041e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &results); 1042e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1043e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1044e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1045d201456903f3ecae1f7794edfab0d5678e64226shiqian 1046e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(2, results.size()); 1047e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1048e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1050d201456903f3ecae1f7794edfab0d5678e64226shiqian 1051e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) { 1052e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1053e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1054e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Tests, that the deprecated constructor still works. 1055e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter(&results); 1056e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1057e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1058e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(1, results.size()); 1059d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1060d201456903f3ecae1f7794edfab0d5678e64226shiqian 1061e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1062e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1063e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterWithThreadsTest 1064e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian : public ScopedFakeTestPartResultReporterTest { 1065e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 1066e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailureInOtherThread(FailureMode failure) { 1067e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_t tid; 1068e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_create(&tid, 1069e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NULL, 1070e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporterWithThreadsTest:: 1071e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FailureThread, 1072e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &failure); 1073e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_join(tid, NULL); 1074e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1075e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian private: 1076e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void* FailureThread(void* attr) { 1077e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FailureMode* failure = static_cast<FailureMode*>(attr); 1078e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(*failure); 1079e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian return NULL; 1080e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1081e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 1082e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1083e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterWithThreadsTest, 1084e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian InterceptsTestFailuresInAllThreads) { 1085e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1086e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1087e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1088e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results); 1089e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1090e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1091e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE); 1092e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(FATAL_FAILURE); 1093e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1094e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1095e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(4, results.size()); 1096e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1097e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1098e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed()); 1099e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed()); 1100d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1101d201456903f3ecae1f7794edfab0d5678e64226shiqian 1102e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1103e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1104c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they 1105c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// work even if the failure is generated in a called function rather than 1106c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// the current context. 1107e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 110837504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest; 1109e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 111037504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) { 1111c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure."); 1112d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1113d201456903f3ecae1f7794edfab0d5678e64226shiqian 111437504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) { 111537504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches fatal 111637504994338c114247519331237831f88a9a7c40zhanyong.wan // failures generated on another thread. 1117c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(), 1118e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1119d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1120d201456903f3ecae1f7794edfab0d5678e64226shiqian 1121c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1122c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true" 1123c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc 1124c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1125c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 112637504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void 112737504994338c114247519331237831f88a9a7c40zhanyong.wan// function even when the statement in it contains ASSERT_*. 112837504994338c114247519331237831f88a9a7c40zhanyong.wan 112937504994338c114247519331237831f88a9a7c40zhanyong.wanint NonVoidFunction() { 113037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 113137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 113237504994338c114247519331237831f88a9a7c40zhanyong.wan return 0; 113337504994338c114247519331237831f88a9a7c40zhanyong.wan} 113437504994338c114247519331237831f88a9a7c40zhanyong.wan 113537504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) { 113637504994338c114247519331237831f88a9a7c40zhanyong.wan NonVoidFunction(); 113737504994338c114247519331237831f88a9a7c40zhanyong.wan} 113837504994338c114247519331237831f88a9a7c40zhanyong.wan 113937504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the 114037504994338c114247519331237831f88a9a7c40zhanyong.wan// current function even though 'statement' generates a fatal failure. 114137504994338c114247519331237831f88a9a7c40zhanyong.wan 114237504994338c114247519331237831f88a9a7c40zhanyong.wanvoid DoesNotAbortHelper(bool* aborted) { 114337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 114437504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 114537504994338c114247519331237831f88a9a7c40zhanyong.wan 114637504994338c114247519331237831f88a9a7c40zhanyong.wan *aborted = false; 114737504994338c114247519331237831f88a9a7c40zhanyong.wan} 114837504994338c114247519331237831f88a9a7c40zhanyong.wan 1149c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1150c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 1151c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 1152c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1153c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 115437504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, DoesNotAbort) { 115537504994338c114247519331237831f88a9a7c40zhanyong.wan bool aborted = true; 115637504994338c114247519331237831f88a9a7c40zhanyong.wan DoesNotAbortHelper(&aborted); 115737504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FALSE(aborted); 1158d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1159d201456903f3ecae1f7794edfab0d5678e64226shiqian 116037504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a 116137504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 116237504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 1163d201456903f3ecae1f7794edfab0d5678e64226shiqian 1164e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianstatic int global_var = 0; 1165e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++ 1166d201456903f3ecae1f7794edfab0d5678e64226shiqian 116737504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1168c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 1169c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007. 1170e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE({ 1171e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1172c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1173e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1174c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1175d201456903f3ecae1f7794edfab0d5678e64226shiqian 1176e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS({ 1177e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1178c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1179e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 118037504994338c114247519331237831f88a9a7c40zhanyong.wan} 118137504994338c114247519331237831f88a9a7c40zhanyong.wan 118237504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}. 118337504994338c114247519331237831f88a9a7c40zhanyong.wan 118437504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest; 118537504994338c114247519331237831f88a9a7c40zhanyong.wan 118637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) { 1187c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 118837504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 118937504994338c114247519331237831f88a9a7c40zhanyong.wan} 1190d201456903f3ecae1f7794edfab0d5678e64226shiqian 119137504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) { 119237504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches 119337504994338c114247519331237831f88a9a7c40zhanyong.wan // non-fatal failures generated on another thread. 1194c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(), 119537504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 119637504994338c114247519331237831f88a9a7c40zhanyong.wan} 119737504994338c114247519331237831f88a9a7c40zhanyong.wan 119837504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a 119937504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 120037504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 120137504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1202e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE({ 1203e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1204c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1205e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1206d201456903f3ecae1f7794edfab0d5678e64226shiqian 1207e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({ 1208e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1209c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1210e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1211d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1212d201456903f3ecae1f7794edfab0d5678e64226shiqian 1213e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1214d201456903f3ecae1f7794edfab0d5678e64226shiqian 1215e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqiantypedef ScopedFakeTestPartResultReporterWithThreadsTest 1216e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ExpectFailureWithThreadsTest; 1217d201456903f3ecae1f7794edfab0d5678e64226shiqian 1218e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) { 1219e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE), 1220e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1221e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 1222e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1223e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) { 1224e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS( 1225e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure."); 1226d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1227d201456903f3ecae1f7794edfab0d5678e64226shiqian 1228e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1229e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1230d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestResult class 1231d201456903f3ecae1f7794edfab0d5678e64226shiqian 1232d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestResult. 12339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestResultTest : public Test { 1234d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 123589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan typedef Vector<TestPartResult> TPRVector; 1236d201456903f3ecae1f7794edfab0d5678e64226shiqian 1237d201456903f3ecae1f7794edfab0d5678e64226shiqian // We make use of 2 TestPartResult objects, 1238d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult * pr1, * pr2; 1239d201456903f3ecae1f7794edfab0d5678e64226shiqian 1240d201456903f3ecae1f7794edfab0d5678e64226shiqian // ... and 3 TestResult objects. 1241d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult * r0, * r1, * r2; 1242d201456903f3ecae1f7794edfab0d5678e64226shiqian 1243d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 1244d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr1 is for success. 12459b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr1 = new TestPartResult(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"); 1246d201456903f3ecae1f7794edfab0d5678e64226shiqian 1247d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr2 is for fatal failure. 12489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr2 = new TestPartResult(TPRT_FATAL_FAILURE, "foo/bar.cc", 12499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian -1, // This line number means "unknown" 12509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "Failure!"); 1251d201456903f3ecae1f7794edfab0d5678e64226shiqian 1252d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates the TestResult objects. 1253d201456903f3ecae1f7794edfab0d5678e64226shiqian r0 = new TestResult(); 1254d201456903f3ecae1f7794edfab0d5678e64226shiqian r1 = new TestResult(); 1255d201456903f3ecae1f7794edfab0d5678e64226shiqian r2 = new TestResult(); 1256d201456903f3ecae1f7794edfab0d5678e64226shiqian 1257d201456903f3ecae1f7794edfab0d5678e64226shiqian // In order to test TestResult, we need to modify its internal 125889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // state, in particular the TestPartResult Vector it holds. 125989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan // test_part_results() returns a const reference to this Vector. 1260d201456903f3ecae1f7794edfab0d5678e64226shiqian // We cast it to a non-const object s.t. it can be modified (yes, 1261d201456903f3ecae1f7794edfab0d5678e64226shiqian // this is a hack). 126289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan TPRVector* results1 = const_cast<Vector<TestPartResult> *>( 1263b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r1)); 126489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan TPRVector* results2 = const_cast<Vector<TestPartResult> *>( 1265b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r2)); 1266d201456903f3ecae1f7794edfab0d5678e64226shiqian 1267d201456903f3ecae1f7794edfab0d5678e64226shiqian // r0 is an empty TestResult. 1268d201456903f3ecae1f7794edfab0d5678e64226shiqian 1269d201456903f3ecae1f7794edfab0d5678e64226shiqian // r1 contains a single SUCCESS TestPartResult. 127089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan results1->PushBack(*pr1); 1271d201456903f3ecae1f7794edfab0d5678e64226shiqian 1272d201456903f3ecae1f7794edfab0d5678e64226shiqian // r2 contains a SUCCESS, and a FAILURE. 127389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan results2->PushBack(*pr1); 127489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan results2->PushBack(*pr2); 1275d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1276d201456903f3ecae1f7794edfab0d5678e64226shiqian 1277d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 1278d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr1; 1279d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr2; 1280d201456903f3ecae1f7794edfab0d5678e64226shiqian 1281d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r0; 1282d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r1; 1283d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r2; 1284d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1285e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1286e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Helper that compares two two TestPartResults. 1287600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan static void CompareTestPartResult(const TestPartResult& expected, 1288600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestPartResult& actual) { 1289600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.type(), actual.type()); 1290600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.file_name(), actual.file_name()); 1291600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.line_number(), actual.line_number()); 1292600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.summary(), actual.summary()); 1293600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.message(), actual.message()); 1294600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.passed(), actual.passed()); 1295600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.failed(), actual.failed()); 1296600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed()); 1297600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed()); 1298e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan } 1299d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1300d201456903f3ecae1f7794edfab0d5678e64226shiqian 1301b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::total_part_count(). 1302d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, test_part_results) { 1303b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->total_part_count()); 1304b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r1->total_part_count()); 1305b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, r2->total_part_count()); 1306d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1307d201456903f3ecae1f7794edfab0d5678e64226shiqian 1308e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::successful_part_count(). 1309d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, successful_part_count) { 1310b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->successful_part_count()); 1311b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r1->successful_part_count()); 1312b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r2->successful_part_count()); 1313d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1314d201456903f3ecae1f7794edfab0d5678e64226shiqian 1315e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::failed_part_count(). 1316d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, failed_part_count) { 1317b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->failed_part_count()); 1318b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r1->failed_part_count()); 1319b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r2->failed_part_count()); 1320d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1321d201456903f3ecae1f7794edfab0d5678e64226shiqian 13223d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Tests testing::internal::GetFailedPartCount(). 13233d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST_F(TestResultTest, GetFailedPartCount) { 1324b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetFailedPartCount(r0)); 1325b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetFailedPartCount(r1)); 1326b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, GetFailedPartCount(r2)); 13273d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 13283d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 1329e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::total_part_count(). 1330d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, total_part_count) { 1331b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->total_part_count()); 1332b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r1->total_part_count()); 1333b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, r2->total_part_count()); 1334d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1335d201456903f3ecae1f7794edfab0d5678e64226shiqian 1336e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Passed(). 1337d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Passed) { 1338d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r0->Passed()); 1339d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r1->Passed()); 1340d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r2->Passed()); 1341d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1342d201456903f3ecae1f7794edfab0d5678e64226shiqian 1343e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Failed(). 1344d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Failed) { 1345d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r0->Failed()); 1346d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r1->Failed()); 1347d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r2->Failed()); 1348d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1349d201456903f3ecae1f7794edfab0d5678e64226shiqian 1350e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestPartResult(). 1351600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1352600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef TestResultTest TestResultDeathTest; 1353600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1354600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(TestResultDeathTest, GetTestPartResult) { 1355600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr1, r2->GetTestPartResult(0)); 1356600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr2, r2->GetTestPartResult(1)); 1357600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1358600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan r2->GetTestPartResult(2), 135989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index 2: must be in range \\[0, 1\\]\\."); 1360600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1361600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan r2->GetTestPartResult(-1), 136289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index -1: must be in range \\[0, 1\\]\\."); 1363e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1364e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1365b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has no properties when none are added. 1366d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 1367d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1368b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, test_result.test_property_count()); 1369d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1370d201456903f3ecae1f7794edfab0d5678e64226shiqian 1371b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has the expected property when added. 1372d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 1373d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1374d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key_1", "1"); 1375b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property); 1376b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, test_result.test_property_count()); 1377600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property = test_result.GetTestProperty(0); 1378600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property.key()); 1379600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property.value()); 1380d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1381d201456903f3ecae1f7794edfab0d5678e64226shiqian 1382b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has multiple properties when added. 1383d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 1384d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1385d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1("key_1", "1"); 1386d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2("key_2", "2"); 1387b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1); 1388b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2); 1389b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1390600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1391600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1392600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property_1.value()); 1393d201456903f3ecae1f7794edfab0d5678e64226shiqian 1394600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1395600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1396600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", actual_property_2.value()); 1397d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1398d201456903f3ecae1f7794edfab0d5678e64226shiqian 1399b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::RecordProperty() overrides values for duplicate keys. 1400d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 1401d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1402d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_1("key_1", "1"); 1403d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_1("key_2", "2"); 1404d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_2("key_1", "12"); 1405d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_2("key_2", "22"); 1406b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1_1); 1407b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2_1); 1408b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1_2); 1409b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2_2); 1410e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1411e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1412600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1413600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1414600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("12", actual_property_1.value()); 1415b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 1416600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1417600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1418600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("22", actual_property_2.value()); 1419e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1420e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1421e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestProperty(). 1422600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST(TestResultPropertyDeathTest, GetTestProperty) { 1423e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestResult test_result; 1424e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_1("key_1", "1"); 1425e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_2("key_2", "2"); 1426e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_3("key_3", "3"); 1427b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1); 1428b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2); 1429b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_3); 1430e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1431600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_1 = test_result.GetTestProperty(0); 1432600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_2 = test_result.GetTestProperty(1); 1433600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_3 = test_result.GetTestProperty(2); 1434e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1435600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", fetched_property_1.key()); 1436600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", fetched_property_1.value()); 1437e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1438600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", fetched_property_2.key()); 1439600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", fetched_property_2.value()); 1440e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1441600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_3", fetched_property_3.key()); 1442600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("3", fetched_property_3.value()); 1443e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1444600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1445600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan test_result.GetTestProperty(3), 144689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index 3: must be in range \\[0, 2\\]\\."); 1447600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1448600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan test_result.GetTestProperty(-1), 144989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan "Invalid Vector index -1: must be in range \\[0, 2\\]\\."); 1450e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1451e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1452d201456903f3ecae1f7794edfab0d5678e64226shiqian// When a property using a reserved key is supplied to this function, it tests 1453d201456903f3ecae1f7794edfab0d5678e64226shiqian// that a non-fatal failure is added, a fatal failure is not added, and that the 1454d201456903f3ecae1f7794edfab0d5678e64226shiqian// property is not recorded. 1455d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) { 1456d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 14574b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan TestProperty property(key, "1"); 1458b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan EXPECT_NONFATAL_FAILURE( 1459b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property), 1460b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan "Reserved key"); 1461b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, test_result.test_property_count()) << "Not recorded"; 1462d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1463d201456903f3ecae1f7794edfab0d5678e64226shiqian 1464d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "name" 1465d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1466d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) { 1467d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("name"); 1468d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1469d201456903f3ecae1f7794edfab0d5678e64226shiqian 1470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "status" 1471d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1472d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) { 1473d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("status"); 1474d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1475d201456903f3ecae1f7794edfab0d5678e64226shiqian 1476d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "time" 1477d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1478d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) { 1479d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("time"); 1480d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1481d201456903f3ecae1f7794edfab0d5678e64226shiqian 1482d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "classname" 1483d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1484d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) { 1485d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname"); 1486d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1487d201456903f3ecae1f7794edfab0d5678e64226shiqian 1488d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTestFlagSaver works on Windows and Mac. 1489d201456903f3ecae1f7794edfab0d5678e64226shiqian 14909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass GTestFlagSaverTest : public Test { 1491d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1492d201456903f3ecae1f7794edfab0d5678e64226shiqian // Saves the Google Test flags such that we can restore them later, and 1493d201456903f3ecae1f7794edfab0d5678e64226shiqian // then sets them to their default values. This will be called 1494d201456903f3ecae1f7794edfab0d5678e64226shiqian // before the first test in this test case is run. 1495d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 14969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian saver_ = new GTestFlagSaver; 14979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1498fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 14999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = false; 15009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = false; 150153e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 15029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "auto"; 15039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = ""; 15049b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = false; 15059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = ""; 1506f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 15078bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 15089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 1; 15098bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 151040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 1511d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1512d201456903f3ecae1f7794edfab0d5678e64226shiqian 1513d201456903f3ecae1f7794edfab0d5678e64226shiqian // Restores the Google Test flags that the tests have modified. This will 1514d201456903f3ecae1f7794edfab0d5678e64226shiqian // be called after the last test in this test case is run. 1515d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 1516d201456903f3ecae1f7794edfab0d5678e64226shiqian delete saver_; 1517d201456903f3ecae1f7794edfab0d5678e64226shiqian saver_ = NULL; 1518d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1519d201456903f3ecae1f7794edfab0d5678e64226shiqian 1520d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the Google Test flags have their default values, and then 1521d201456903f3ecae1f7794edfab0d5678e64226shiqian // modifies each of them. 1522d201456903f3ecae1f7794edfab0d5678e64226shiqian void VerifyAndModifyFlags() { 1523fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests)); 15249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 15259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 15269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 152753e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_FALSE(GTEST_FLAG(death_test_use_fork)); 15289b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 15299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(list_tests)); 15309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 1531f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan EXPECT_TRUE(GTEST_FLAG(print_time)); 15328bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(0, GTEST_FLAG(random_seed)); 15339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(1, GTEST_FLAG(repeat)); 15348bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_FALSE(GTEST_FLAG(shuffle)); 153540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_FALSE(GTEST_FLAG(throw_on_failure)); 15369b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1537fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = true; 15389b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = true; 15399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = true; 15409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "no"; 154153e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = true; 15429b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = "abc"; 15439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = true; 15449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = "xml:foo.xml"; 1545f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = false; 15468bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 1; 15479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 100; 15488bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = true; 154940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = true; 1550d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1551d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1552d201456903f3ecae1f7794edfab0d5678e64226shiqian // For saving Google Test flags during this test case. 15539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian static GTestFlagSaver* saver_; 1554d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1555d201456903f3ecae1f7794edfab0d5678e64226shiqian 15569b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 1557d201456903f3ecae1f7794edfab0d5678e64226shiqian 1558d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test doesn't guarantee the order of tests. The following two 1559d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests are designed to work regardless of their order. 1560d201456903f3ecae1f7794edfab0d5678e64226shiqian 1561d201456903f3ecae1f7794edfab0d5678e64226shiqian// Modifies the Google Test flags in the test body. 1562d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 1563d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1564d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1565d201456903f3ecae1f7794edfab0d5678e64226shiqian 1566d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that the Google Test flags in the body of the previous test were 1567d201456903f3ecae1f7794edfab0d5678e64226shiqian// restored to their original values. 1568d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 1569d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1570d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1571d201456903f3ecae1f7794edfab0d5678e64226shiqian 1572d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets an environment variable with the given name to the given 1573d201456903f3ecae1f7794edfab0d5678e64226shiqian// value. If the value argument is "", unsets the environment 1574d201456903f3ecae1f7794edfab0d5678e64226shiqian// variable. The caller must ensure that both arguments are not NULL. 1575d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic void SetEnv(const char* name, const char* value) { 1576d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef _WIN32_WCE 1577d201456903f3ecae1f7794edfab0d5678e64226shiqian // Environment variables are not supported on Windows CE. 1578d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1579c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#elif defined(__BORLANDC__) 1580c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder's putenv only stores a pointer to its parameter; we have to 1581c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ensure that the string remains valid as long as it might be needed. 1582c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We use an std::map to do so. 1583c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static std::map<String, String*> added_env; 1584c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1585c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Because putenv stores a pointer to the string buffer, we can't delete the 1586c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // previous string (if present) until after it's replaced. 1587c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan String *prev_env = NULL; 1588c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan if (added_env.find(name) != added_env.end()) { 1589c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan prev_env = added_env[name]; 1590c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 1591c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan added_env[name] = new String((Message() << name << "=" << value).GetString()); 1592c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan putenv(added_env[name]->c_str()); 1593c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan delete prev_env; 1594c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 15950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#elif GTEST_OS_WINDOWS // If we are on Windows proper. 15969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian _putenv((Message() << name << "=" << value).GetString().c_str()); 1597d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1598d201456903f3ecae1f7794edfab0d5678e64226shiqian if (*value == '\0') { 1599d201456903f3ecae1f7794edfab0d5678e64226shiqian unsetenv(name); 1600d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1601d201456903f3ecae1f7794edfab0d5678e64226shiqian setenv(name, value, 1); 1602d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1603d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 1604d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1605d201456903f3ecae1f7794edfab0d5678e64226shiqian 1606d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef _WIN32_WCE 1607d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variables are not supported on Windows CE. 1608d201456903f3ecae1f7794edfab0d5678e64226shiqian 16099b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::Int32FromGTestEnv; 1610d201456903f3ecae1f7794edfab0d5678e64226shiqian 1611d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests Int32FromGTestEnv(). 1612d201456903f3ecae1f7794edfab0d5678e64226shiqian 1613d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1614d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable is not set. 1615d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 16160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", ""); 1617d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 1618d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1619d201456903f3ecae1f7794edfab0d5678e64226shiqian 1620d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1621d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable overflows as an Int32. 1622d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 1623d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1624d201456903f3ecae1f7794edfab0d5678e64226shiqian 16250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321"); 1626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 1627d201456903f3ecae1f7794edfab0d5678e64226shiqian 16280af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321"); 1629d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 1630d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1631d201456903f3ecae1f7794edfab0d5678e64226shiqian 1632d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1633d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable does not represent a valid decimal integer. 1634d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 1635d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1636d201456903f3ecae1f7794edfab0d5678e64226shiqian 16370af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1"); 1638d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 1639d201456903f3ecae1f7794edfab0d5678e64226shiqian 16400af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X"); 1641d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 1642d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1643d201456903f3ecae1f7794edfab0d5678e64226shiqian 1644d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() parses and returns the value of the 1645d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable when it represents a valid decimal integer in 1646d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1647d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 16480af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123"); 1649d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 1650d201456903f3ecae1f7794edfab0d5678e64226shiqian 16510af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321"); 1652d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 1653d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1654d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // !defined(_WIN32_WCE) 1655d201456903f3ecae1f7794edfab0d5678e64226shiqian 1656d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ParseInt32Flag(). 1657d201456903f3ecae1f7794edfab0d5678e64226shiqian 1658d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1659d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag has wrong format 1660d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 1661d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1662d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 1663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1664d201456903f3ecae1f7794edfab0d5678e64226shiqian 1665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 1666d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1667d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1668d201456903f3ecae1f7794edfab0d5678e64226shiqian 1669d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1670d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag overflows as an Int32. 1671d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 1672d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1673d201456903f3ecae1f7794edfab0d5678e64226shiqian 1674d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1675d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 1676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1677d201456903f3ecae1f7794edfab0d5678e64226shiqian 1678d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 1679d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1680d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1681d201456903f3ecae1f7794edfab0d5678e64226shiqian 1682d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1683d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag does not represent a valid decimal 1684d201456903f3ecae1f7794edfab0d5678e64226shiqian// integer. 1685d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 1686d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1687d201456903f3ecae1f7794edfab0d5678e64226shiqian 1688d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1689d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 1690d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1691d201456903f3ecae1f7794edfab0d5678e64226shiqian 1692d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 1693d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1694d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1695d201456903f3ecae1f7794edfab0d5678e64226shiqian 1696d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() parses the value of the flag and 1697d201456903f3ecae1f7794edfab0d5678e64226shiqian// returns true when the flag represents a valid decimal integer in 1698d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 1700d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 17010af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value)); 1702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(456, value); 1703d201456903f3ecae1f7794edfab0d5678e64226shiqian 1704c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", 1705c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "abc", &value)); 1706d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-789, value); 1707d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1708d201456903f3ecae1f7794edfab0d5678e64226shiqian 1709cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() parses the value of the var or 1710cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// returns the correct default. 17114853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 17124853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1713cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { 17140af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 17150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); 17160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 17170af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123"); 17180af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 1719cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1720600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#endif // _WIN32_WCE 1721cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1722cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1723cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable is not an Int32. 1724cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) { 17250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx"); 1726600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1727600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1728600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1729cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1730cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1731cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1732cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable cannot be represnted by an Int32. 1733cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) { 17340af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234"); 1735600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_( 1736600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1737600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1738cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1739cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1740cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard() selects all tests 1741cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// where there is 1 shard. 1742cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) { 1743cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0)); 1744cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1)); 1745cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2)); 1746cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3)); 1747cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4)); 1748cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1749cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1750cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanclass ShouldShardTest : public testing::Test { 1751cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan protected: 1752cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void SetUp() { 17530af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX"; 17540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL"; 1755cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1756cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1757cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void TearDown() { 1758cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1759cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1760cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1761cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1762cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* index_var_; 1763cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* total_var_; 1764cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan}; 1765cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1766cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is disabled if neither of the environment variables 1767cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// are set. 1768cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) { 1769cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1770cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1771cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1772cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1773cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1774cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1775cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1776cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is not enabled if total_shards == 1. 1777cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) { 1778cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1779cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "1"); 1780cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1781cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1782cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1783cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1784cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is enabled if total_shards > 1 and 1785cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// we are not in a death test subprocess. 17864853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 17874853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1788cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { 1789cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1790cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "22"); 1791cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1792cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1793cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1794cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "8"); 1795cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1796cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1797cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1798cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1799cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1800cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1801cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1802cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1803cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1804600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan#endif // _WIN32_WCE 1805cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1806cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that we exit in error if the sharding values are not valid. 1807600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1808600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef ShouldShardTest ShouldShardDeathTest; 1809600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1810600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) { 1811cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1812cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "4"); 1813600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_(ShouldShard(total_var_, index_var_, false), 1814600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1815cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1816cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1817cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "-2"); 1818600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_(ShouldShard(total_var_, index_var_, false), 1819600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1820cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1821cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "5"); 1822cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1823600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_(ShouldShard(total_var_, index_var_, false), 1824600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1825cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1826cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1827cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "5"); 1828600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan GTEST_EXPECT_DEATH_IF_SUPPORTED_(ShouldShard(total_var_, index_var_, false), 1829600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1830cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1831cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1832cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard is a partition when 5 1833cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// shards are used. 1834cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { 1835cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Choose an arbitrary number of tests and shards. 1836cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_tests = 17; 1837cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_shards = 5; 1838cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1839cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check partitioning: each test should be on exactly 1 shard. 1840cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1841cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int prev_selected_shard_index = -1; 1842cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1843cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) { 1844cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (prev_selected_shard_index < 0) { 1845cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan prev_selected_shard_index = shard_index; 1846cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } else { 1847cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and " 1848cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan << shard_index << " are both selected to run test " << test_id; 1849cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1850cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1851cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1852cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1853cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1854cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check balance: This is not required by the sharding protocol, but is a 1855cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // desirable property for performance. 1856cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1857cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int num_tests_on_shard = 0; 1858cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1859cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan num_tests_on_shard += 1860cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ShouldRunTestOnShard(num_shards, shard_index, test_id); 1861cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1862cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_GE(num_tests_on_shard, num_tests / num_shards); 1863cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1864cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1865cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1866d201456903f3ecae1f7794edfab0d5678e64226shiqian// For the same reason we are not explicitly testing everything in the 1867019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Test class, there are no separate tests for the following classes 1868019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// (except for some trivial cases): 1869d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1870d201456903f3ecae1f7794edfab0d5678e64226shiqian// TestCase, UnitTest, UnitTestResultPrinter. 1871d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1872d201456903f3ecae1f7794edfab0d5678e64226shiqian// Similarly, there are no separate tests for the following macros: 1873d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1874d201456903f3ecae1f7794edfab0d5678e64226shiqian// TEST, TEST_F, RUN_ALL_TESTS 1875d201456903f3ecae1f7794edfab0d5678e64226shiqian 1876019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST(UnitTestTest, CanGetOriginalWorkingDir) { 1877019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 1878019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 1879019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 1880019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 1881d201456903f3ecae1f7794edfab0d5678e64226shiqian// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 1882d201456903f3ecae1f7794edfab0d5678e64226shiqian// of various arities. They do not attempt to be exhaustive. Rather, 1883d201456903f3ecae1f7794edfab0d5678e64226shiqian// view them as smoke tests that can be easily reviewed and verified. 1884d201456903f3ecae1f7794edfab0d5678e64226shiqian// A more complete set of tests for predicate assertions can be found 1885d201456903f3ecae1f7794edfab0d5678e64226shiqian// in gtest_pred_impl_unittest.cc. 1886d201456903f3ecae1f7794edfab0d5678e64226shiqian 1887d201456903f3ecae1f7794edfab0d5678e64226shiqian// First, some predicates and predicate-formatters needed by the tests. 1888d201456903f3ecae1f7794edfab0d5678e64226shiqian 1889d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the argument is an even number. 1890d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsEven(int n) { 1891d201456903f3ecae1f7794edfab0d5678e64226shiqian return (n % 2) == 0; 1892d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1893d201456903f3ecae1f7794edfab0d5678e64226shiqian 1894d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the argument is an even number. 1895d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct IsEvenFunctor { 1896d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n) { return IsEven(n); } 1897d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1898d201456903f3ecae1f7794edfab0d5678e64226shiqian 1899d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the argument is an even 1900d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 19019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertIsEven(const char* expr, int n) { 1902d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(n)) { 19039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1904d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1905d201456903f3ecae1f7794edfab0d5678e64226shiqian 19069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1907d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << expr << " evaluates to " << n << ", which is not even."; 19089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1909d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1910d201456903f3ecae1f7794edfab0d5678e64226shiqian 1911d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the argument is an even 1912d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1913d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertIsEvenFunctor { 19149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()(const char* expr, int n) { 1915d201456903f3ecae1f7794edfab0d5678e64226shiqian return AssertIsEven(expr, n); 1916d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1917d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1918d201456903f3ecae1f7794edfab0d5678e64226shiqian 1919d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the sum of the arguments is an even number. 1920d201456903f3ecae1f7794edfab0d5678e64226shiqianbool SumIsEven2(int n1, int n2) { 1921d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2); 1922d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1923d201456903f3ecae1f7794edfab0d5678e64226shiqian 1924d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the sum of the arguments is an even 1925d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1926d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct SumIsEven3Functor { 1927d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n1, int n2, int n3) { 1928d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2 + n3); 1929d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1930d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1931d201456903f3ecae1f7794edfab0d5678e64226shiqian 1932d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the sum of the 1933d201456903f3ecae1f7794edfab0d5678e64226shiqian// arguments is an even number. 19349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertSumIsEven4( 19359b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 19369b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian int n1, int n2, int n3, int n4) { 1937d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4; 1938d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 19399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1940d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1941d201456903f3ecae1f7794edfab0d5678e64226shiqian 19429b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1943d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 1944d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 1945d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 19469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1947d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1948d201456903f3ecae1f7794edfab0d5678e64226shiqian 1949d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the sum of the arguments 1950d201456903f3ecae1f7794edfab0d5678e64226shiqian// is an even number. 1951d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertSumIsEven5Functor { 19529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()( 19539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 19549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e5, int n1, int n2, int n3, int n4, int n5) { 1955d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4 + n5; 1956d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 19579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1958d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1959d201456903f3ecae1f7794edfab0d5678e64226shiqian 19609b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1961d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 1962d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" 1963d201456903f3ecae1f7794edfab0d5678e64226shiqian << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 1964d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 19659b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1966d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1967d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1968d201456903f3ecae1f7794edfab0d5678e64226shiqian 1969d201456903f3ecae1f7794edfab0d5678e64226shiqian 1970d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions. 1971d201456903f3ecae1f7794edfab0d5678e64226shiqian 1972d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that don't use a custom formatter. 1973d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithoutFormat) { 1974d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1975d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 1976d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsEven, 4); 1977d201456903f3ecae1f7794edfab0d5678e64226shiqian 1978d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1979d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1980d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 1981d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1982d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 1983d201456903f3ecae1f7794edfab0d5678e64226shiqian "evaluates to false"); 1984d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1985d201456903f3ecae1f7794edfab0d5678e64226shiqian 1986d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that use a custom formatter. 1987d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithFormat) { 1988d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1989d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(AssertIsEven, 2); 1990d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 1991d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 1992d201456903f3ecae1f7794edfab0d5678e64226shiqian 1993d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1994d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n = 5; 1995d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 1996d201456903f3ecae1f7794edfab0d5678e64226shiqian "n evaluates to 5, which is not even."); 1997d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1998d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 1999d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2000d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2001d201456903f3ecae1f7794edfab0d5678e64226shiqian 2002d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that unary predicate assertions evaluates their arguments 2003d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2004d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, SingleEvaluationOnFailure) { 2005d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2006d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 2007d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, n++); 2008d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 2009d201456903f3ecae1f7794edfab0d5678e64226shiqian 2010d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2012d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 2013d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2014d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2015d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 2016d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2017d201456903f3ecae1f7794edfab0d5678e64226shiqian 2018d201456903f3ecae1f7794edfab0d5678e64226shiqian 2019d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions whose arity is >= 2. 2020d201456903f3ecae1f7794edfab0d5678e64226shiqian 2021d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that don't use a custom formatter. 2022d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithoutFormat) { 2023d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2024d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 2025d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 2026d201456903f3ecae1f7794edfab0d5678e64226shiqian 2027d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2028d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2029d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2030d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2031d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 2032d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2033d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2034d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 2035d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to false"); 2036d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2037d201456903f3ecae1f7794edfab0d5678e64226shiqian 2038d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that use a custom formatter. 2039d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithFormat) { 2040d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2041d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 2042d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is UNEXPECTED!"; 2043d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 2044d201456903f3ecae1f7794edfab0d5678e64226shiqian 2045d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2046d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2047d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2048d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n3 = 4; 2049d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n4 = 6; 2050d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2051d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 2052d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 13, which is not even."); 2053d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2054d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 2055d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2056d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2057d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2058d201456903f3ecae1f7794edfab0d5678e64226shiqian 2059d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that predicate assertions evaluates their arguments 2060d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2061d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, SingleEvaluationOnFailure) { 2062d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2063d201456903f3ecae1f7794edfab0d5678e64226shiqian int n1 = 0; 2064d201456903f3ecae1f7794edfab0d5678e64226shiqian int n2 = 0; 2065d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1++, n2++); 2066d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2067d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2068d201456903f3ecae1f7794edfab0d5678e64226shiqian 2069d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another success case. 2070d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = 0; 2071d201456903f3ecae1f7794edfab0d5678e64226shiqian int n3 = 0; 2072d201456903f3ecae1f7794edfab0d5678e64226shiqian int n4 = 0; 2073d201456903f3ecae1f7794edfab0d5678e64226shiqian int n5 = 0; 2074d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2075d201456903f3ecae1f7794edfab0d5678e64226shiqian n1++, n2++, n3++, n4++, n5++) 2076d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 2077d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2078d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2079d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2080d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2081d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 2082d201456903f3ecae1f7794edfab0d5678e64226shiqian 2083d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2084d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = 0; 2085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2086d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 2087d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2088d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2089d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2090d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2091d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2092d201456903f3ecae1f7794edfab0d5678e64226shiqian 2093d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another failure case. 2094d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = n4 = 0; 2095d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2096d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 2097d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 1, which is not even."); 2098d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2099d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2100d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2101d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2102d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2103d201456903f3ecae1f7794edfab0d5678e64226shiqian 2104d201456903f3ecae1f7794edfab0d5678e64226shiqian 2105d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2106d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PREDn and EXPECT_PREDn. 2107d201456903f3ecae1f7794edfab0d5678e64226shiqian 2108d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(int n) { 2109d201456903f3ecae1f7794edfab0d5678e64226shiqian return n > 0; 2110d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2111d201456903f3ecae1f7794edfab0d5678e64226shiqian 2112d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(double x) { 2113d201456903f3ecae1f7794edfab0d5678e64226shiqian return x > 0; 2114d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2115d201456903f3ecae1f7794edfab0d5678e64226shiqian 2116d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 2117d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsNegative(T x) { 2118d201456903f3ecae1f7794edfab0d5678e64226shiqian return x < 0; 2119d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2120d201456903f3ecae1f7794edfab0d5678e64226shiqian 2121d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 2122d201456903f3ecae1f7794edfab0d5678e64226shiqianbool GreaterThan(T1 x1, T2 x2) { 2123d201456903f3ecae1f7794edfab0d5678e64226shiqian return x1 > x2; 2124d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2125d201456903f3ecae1f7794edfab0d5678e64226shiqian 2126d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED* as long as 2127d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2128d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 2129c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder requires C-style casts rather than static_cast. 2130c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT 2131c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT 2132d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2133d201456903f3ecae1f7794edfab0d5678e64226shiqian 2134d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED* as long as 2135d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2136d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 2137d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsNegative<int>, -5); 2138d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes sure that we can handle templates with more than one 2139d201456903f3ecae1f7794edfab0d5678e64226shiqian // parameter. 2140d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 2141d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2142d201456903f3ecae1f7794edfab0d5678e64226shiqian 2143d201456903f3ecae1f7794edfab0d5678e64226shiqian 2144d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2145d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 2146d201456903f3ecae1f7794edfab0d5678e64226shiqian 21474b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, int n) { 21489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return n > 0 ? AssertionSuccess() : 21499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2150d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2151d201456903f3ecae1f7794edfab0d5678e64226shiqian 21524b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, double x) { 21539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x > 0 ? AssertionSuccess() : 21549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2155d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2156d201456903f3ecae1f7794edfab0d5678e64226shiqian 2157d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 21584b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsNegativeFormat(const char* /* expr */, T x) { 21599b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x < 0 ? AssertionSuccess() : 21609b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2161d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2162d201456903f3ecae1f7794edfab0d5678e64226shiqian 2163d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 21644b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */, 21659b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const T1& x1, const T2& x2) { 21669b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x1 == x2 ? AssertionSuccess() : 21679b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2168d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2169d201456903f3ecae1f7794edfab0d5678e64226shiqian 2170d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED_FORMAT* 21714b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan// without explicitly specifying their types. 2172d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 2173d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 2174d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 2175d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2176d201456903f3ecae1f7794edfab0d5678e64226shiqian 2177d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED_FORMAT* without 2178d201456903f3ecae1f7794edfab0d5678e64226shiqian// explicitly specifying their types. 2179d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 2180d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 2181d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 2182d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2183d201456903f3ecae1f7794edfab0d5678e64226shiqian 2184d201456903f3ecae1f7794edfab0d5678e64226shiqian 2185d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests string assertions. 2186d201456903f3ecae1f7794edfab0d5678e64226shiqian 2187d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with non-NULL arguments. 2188d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ) { 2189d201456903f3ecae1f7794edfab0d5678e64226shiqian const char * const p1 = "good"; 2190d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p1); 2191d201456903f3ecae1f7794edfab0d5678e64226shiqian 2192d201456903f3ecae1f7794edfab0d5678e64226shiqian // Let p2 have the same content as p1, but be at a different address. 2193d201456903f3ecae1f7794edfab0d5678e64226shiqian const char p2[] = "good"; 2194d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p2); 2195d201456903f3ecae1f7794edfab0d5678e64226shiqian 2196d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 2197d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: \"bad\""); 2198d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2199d201456903f3ecae1f7794edfab0d5678e64226shiqian 2200d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2201d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null) { 2202d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 2203d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 2204d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2205d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2206d201456903f3ecae1f7794edfab0d5678e64226shiqian 2207d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2208d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 2209d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 2210d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2211d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2212d201456903f3ecae1f7794edfab0d5678e64226shiqian 2213d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRNE. 2214d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRNE) { 2215d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("hi", "Hi"); 2216d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", NULL); 2217d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, "Hi"); 2218d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", NULL); 2219d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, ""); 2220d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", "Hi"); 2221d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", ""); 2222d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 2223d201456903f3ecae1f7794edfab0d5678e64226shiqian "\"Hi\" vs \"Hi\""); 2224d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2225d201456903f3ecae1f7794edfab0d5678e64226shiqian 2226d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASEEQ. 2227d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 2228d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("hi", "Hi"); 2229d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 2230d201456903f3ecae1f7794edfab0d5678e64226shiqian 2231d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("", ""); 2232d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 2233d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2234d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2235d201456903f3ecae1f7794edfab0d5678e64226shiqian 2236d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASENE. 2237d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASENE) { 2238d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("hi1", "Hi2"); 2239d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", NULL); 2240d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, "Hi"); 2241d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", NULL); 2242d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, ""); 2243d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", "Hi"); 2244d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", ""); 2245d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 2246d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2247d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2248d201456903f3ecae1f7794edfab0d5678e64226shiqian 2249d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STREQ on wide strings. 2250d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STREQ_Wide) { 2251d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2252d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 2253d201456903f3ecae1f7794edfab0d5678e64226shiqian 2254d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2255d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(L"", L""); 2256d201456903f3ecae1f7794edfab0d5678e64226shiqian 2257d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2258d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 2259d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2260d201456903f3ecae1f7794edfab0d5678e64226shiqian 2261d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2262d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(L"Hi", L"Hi"); 2263d201456903f3ecae1f7794edfab0d5678e64226shiqian 2264d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 2266d201456903f3ecae1f7794edfab0d5678e64226shiqian "Abc"); 2267d201456903f3ecae1f7794edfab0d5678e64226shiqian 2268d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2269d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 2270d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2271d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2272d201456903f3ecae1f7794edfab0d5678e64226shiqian 2273d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STRNE on wide strings. 2274d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STRNE_Wide) { 2275d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2277d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 2278d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 2279d201456903f3ecae1f7794edfab0d5678e64226shiqian 2280d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2281d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 2282d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"\""); 2283d201456903f3ecae1f7794edfab0d5678e64226shiqian 2284d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2285d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(L"non-null", NULL); 2286d201456903f3ecae1f7794edfab0d5678e64226shiqian 2287d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2288d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 2289d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"Hi\""); 2290d201456903f3ecae1f7794edfab0d5678e64226shiqian 2291d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2292d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(L"abc", L"Abc"); 2293d201456903f3ecae1f7794edfab0d5678e64226shiqian 2294d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 2296d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2297d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2298d201456903f3ecae1f7794edfab0d5678e64226shiqian 2299d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsSubstring(). 2300d201456903f3ecae1f7794edfab0d5678e64226shiqian 2301d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2302d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2303d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 2304d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 2305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 2306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 2307d201456903f3ecae1f7794edfab0d5678e64226shiqian 2308d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 2309d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 2310d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2311d201456903f3ecae1f7794edfab0d5678e64226shiqian 2312d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2313d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2314d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 2315c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", kNull, L"a")); 2316c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", L"b", kNull)); 2317d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 2318d201456903f3ecae1f7794edfab0d5678e64226shiqian 2319d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 2320d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 2321d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2322d201456903f3ecae1f7794edfab0d5678e64226shiqian 2323d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2324d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2325d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 2326d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2327d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2328d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2329d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"haystack\"", 23309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring("needle_expr", "haystack_expr", 23319b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "needle", "haystack").failure_message()); 2332d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2333d201456903f3ecae1f7794edfab0d5678e64226shiqian 2334d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 2335d201456903f3ecae1f7794edfab0d5678e64226shiqian 2336d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2337d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2338d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 23399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 23409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 2341d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2342d201456903f3ecae1f7794edfab0d5678e64226shiqian 2343d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 2344d201456903f3ecae1f7794edfab0d5678e64226shiqian 2345d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2346d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2347d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2348d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 2349d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2350d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2351d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2352d201456903f3ecae1f7794edfab0d5678e64226shiqian 2353d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2354d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2355d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 2356d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2357d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2358d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2359d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"haystack\"", 23609b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring( 2361d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2362d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring(L"needle"), L"haystack").failure_message()); 2363d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2364d201456903f3ecae1f7794edfab0d5678e64226shiqian 2365d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2366d201456903f3ecae1f7794edfab0d5678e64226shiqian 2367d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsNotSubstring(). 2368d201456903f3ecae1f7794edfab0d5678e64226shiqian 2369d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2370d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2371d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 2372d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 2373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 2374d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2375d201456903f3ecae1f7794edfab0d5678e64226shiqian 2376d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2377d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2378d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 2379d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 2380d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 2381d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2382d201456903f3ecae1f7794edfab0d5678e64226shiqian 2383d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2384d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2385d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 2386d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2387d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2388d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2389d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"two needles\"", 23909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2391d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2392d201456903f3ecae1f7794edfab0d5678e64226shiqian L"needle", L"two needles").failure_message()); 2393d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2394d201456903f3ecae1f7794edfab0d5678e64226shiqian 2395d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 2396d201456903f3ecae1f7794edfab0d5678e64226shiqian 2397d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2398d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2399d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 2400d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 2401d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 2402d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2403d201456903f3ecae1f7794edfab0d5678e64226shiqian 2404d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2405d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2406d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 2407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2408d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2409d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2410d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"two needles\"", 24119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2412d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2413d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::string("needle"), "two needles").failure_message()); 2414d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2415d201456903f3ecae1f7794edfab0d5678e64226shiqian 2416d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 2417d201456903f3ecae1f7794edfab0d5678e64226shiqian 2418d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2419d201456903f3ecae1f7794edfab0d5678e64226shiqian 2420d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2421d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2422d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 2423d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE( 2424d201456903f3ecae1f7794edfab0d5678e64226shiqian IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2425d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2426d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2427d201456903f3ecae1f7794edfab0d5678e64226shiqian 2428d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2429d201456903f3ecae1f7794edfab0d5678e64226shiqian 2430d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests floating-point assertions. 2431d201456903f3ecae1f7794edfab0d5678e64226shiqian 2432d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 24339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FloatingPointTest : public Test { 2434d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2435c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2436c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Pre-calculated numbers to be used by the tests. 2437c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan struct TestValues { 2438c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_positive_zero; 2439c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_negative_zero; 2440c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_negative_zero; 2441c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2442c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_one; 2443c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_one; 2444c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2445c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType infinity; 2446c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_infinity; 2447c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_infinity; 2448c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2449c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan1; 2450c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan2; 2451c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }; 2452c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2453d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename testing::internal::FloatingPoint<RawType> Floating; 2454d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename Floating::Bits Bits; 2455d201456903f3ecae1f7794edfab0d5678e64226shiqian 2456d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 2457d201456903f3ecae1f7794edfab0d5678e64226shiqian const size_t max_ulps = Floating::kMaxUlps; 2458d201456903f3ecae1f7794edfab0d5678e64226shiqian 2459d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 0.0. 2460d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits zero_bits = Floating(0).bits(); 2461d201456903f3ecae1f7794edfab0d5678e64226shiqian 2462d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 0.0. 2463c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_positive_zero = Floating::ReinterpretBits( 2464c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan zero_bits + max_ulps/2); 2465c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_negative_zero = -Floating::ReinterpretBits( 2466d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps - max_ulps/2); 2467c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_negative_zero = -Floating::ReinterpretBits( 2468d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps + 1 - max_ulps/2); 2469d201456903f3ecae1f7794edfab0d5678e64226shiqian 2470d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 1.0. 2471d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits one_bits = Floating(1).bits(); 2472d201456903f3ecae1f7794edfab0d5678e64226shiqian 2473d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 1.0. 2474c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps); 2475c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_one = Floating::ReinterpretBits( 2476c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan one_bits + max_ulps + 1); 2477d201456903f3ecae1f7794edfab0d5678e64226shiqian 2478d201456903f3ecae1f7794edfab0d5678e64226shiqian // +infinity. 2479c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.infinity = Floating::Infinity(); 2480d201456903f3ecae1f7794edfab0d5678e64226shiqian 2481d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent +infinity. 2482c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const Bits infinity_bits = Floating(values_.infinity).bits(); 2483d201456903f3ecae1f7794edfab0d5678e64226shiqian 2484d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to infinity. 2485c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_infinity = Floating::ReinterpretBits( 2486c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan infinity_bits - max_ulps); 2487c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_infinity = Floating::ReinterpretBits( 2488d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_bits - max_ulps - 1); 2489d201456903f3ecae1f7794edfab0d5678e64226shiqian 2490c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Makes some NAN's. Sets the most significant bit of the fraction so that 2491c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // our NaN's are quiet; trying to process a signaling NaN would raise an 2492c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // exception if our environment enables floating point exceptions. 2493c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask 2494c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1); 2495c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask 2496c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200); 2497d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2498d201456903f3ecae1f7794edfab0d5678e64226shiqian 2499d201456903f3ecae1f7794edfab0d5678e64226shiqian void TestSize() { 2500d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2501d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2502d201456903f3ecae1f7794edfab0d5678e64226shiqian 2503c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static TestValues values_; 2504d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2505d201456903f3ecae1f7794edfab0d5678e64226shiqian 2506d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 2507c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wantypename FloatingPointTest<RawType>::TestValues 2508c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FloatingPointTest<RawType>::values_; 2509d201456903f3ecae1f7794edfab0d5678e64226shiqian 2510d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 2511d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<float> FloatTest; 2512d201456903f3ecae1f7794edfab0d5678e64226shiqian 2513d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Float::Bits matches the size of float. 2514d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Size) { 2515d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2516d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2517d201456903f3ecae1f7794edfab0d5678e64226shiqian 2518d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2519d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Zeros) { 2520d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, -0.0); 2521d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 2522d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2523d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 2524d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.5"); 2525d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2526d201456903f3ecae1f7794edfab0d5678e64226shiqian 2527d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2528d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2529d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_FLOAT_EQ handles the sign correctly and no 2530d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2531d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2532d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, AlmostZeros) { 2533c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2534c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2535c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2536c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const FloatTest::TestValues& v(this->values_); 2537c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2538c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero); 2539c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero); 2540c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2541d201456903f3ecae1f7794edfab0d5678e64226shiqian 2542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2543c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(v.close_to_positive_zero, 2544c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2545c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2546d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2547d201456903f3ecae1f7794edfab0d5678e64226shiqian 2548d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2549d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, SmallDiff) { 2550c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(1.0, values_.close_to_one); 2551c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one), 2552c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2553d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2554d201456903f3ecae1f7794edfab0d5678e64226shiqian 2555d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2556d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, LargeDiff) { 2557d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 2558d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2559d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2560d201456903f3ecae1f7794edfab0d5678e64226shiqian 2561d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2562d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2563d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2564d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2565d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Infinity) { 2566c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity); 2567c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity); 25680af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2569e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2570c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity), 2571c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2572d201456903f3ecae1f7794edfab0d5678e64226shiqian 2573c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This is interesting as the representations of infinity and nan1 2574d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2575c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1), 2576c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 25770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2578d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2579d201456903f3ecae1f7794edfab0d5678e64226shiqian 2580d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2581d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, NaN) { 25820af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2583e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Nokia's STLport crashes if we try to output infinity or NaN. 2584c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2585c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2586c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2587c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2588c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const FloatTest::TestValues& v(this->values_); 2589c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2590c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), 2591c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2592c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), 2593c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan2"); 2594c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), 2595c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2596c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2597c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), 2598c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 25990af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2600d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2601d201456903f3ecae1f7794edfab0d5678e64226shiqian 2602d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are reflexive. 2603d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Reflexive) { 2604d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, 0.0); 2605d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0); 2606c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(values_.infinity, values_.infinity); 2607d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2608d201456903f3ecae1f7794edfab0d5678e64226shiqian 2609d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are commutative. 2610d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Commutative) { 2611c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one). 2612c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.close_to_one, 1.0); 2613d201456903f3ecae1f7794edfab0d5678e64226shiqian 2614c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one). 2615c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0), 2616d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2617d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2618d201456903f3ecae1f7794edfab0d5678e64226shiqian 2619d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2620d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, EXPECT_NEAR) { 2621d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 2622d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0f, 3.0f, 1.0f); 2623d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 2624d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 2625d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 2626d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2627d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2628d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2629d201456903f3ecae1f7794edfab0d5678e64226shiqian 2630d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2631d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, ASSERT_NEAR) { 2632d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 2633d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0f, 3.0f, 1.0f); 2634d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 2635d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 2636d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 2637d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2638d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2639d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2640d201456903f3ecae1f7794edfab0d5678e64226shiqian 2641d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should succeed. 2642d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLESucceeds) { 26439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 26449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 2645d201456903f3ecae1f7794edfab0d5678e64226shiqian 2646d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2647c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f); 2648d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2649d201456903f3ecae1f7794edfab0d5678e64226shiqian 2650d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should fail. 2651d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLEFails) { 2652d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 26539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 2654d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0f) <= (1.0f)"); 2655d201456903f3ecae1f7794edfab0d5678e64226shiqian 2656d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2657d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2658c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f); 2659c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0f)"); 2660d201456903f3ecae1f7794edfab0d5678e64226shiqian 2661c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2662e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2663c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2664c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2666c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity); 2667c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2668d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2669c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1); 2670c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(-values_.infinity) <= (values_.nan1)"); 2671d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2672c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1); 2673c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2674c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2675d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2676d201456903f3ecae1f7794edfab0d5678e64226shiqian 2677d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 2678d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<double> DoubleTest; 2679d201456903f3ecae1f7794edfab0d5678e64226shiqian 2680d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Double::Bits matches the size of double. 2681d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Size) { 2682d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2683d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2684d201456903f3ecae1f7794edfab0d5678e64226shiqian 2685d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2686d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Zeros) { 2687d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, -0.0); 2688d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 2689d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2690d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 2691d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2692d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2693d201456903f3ecae1f7794edfab0d5678e64226shiqian 2694d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2695d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2696d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_DOUBLE_EQ handles the sign correctly and no 2697d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2698d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, AlmostZeros) { 2700c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2701c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2702c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2703c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const DoubleTest::TestValues& v(this->values_); 2704c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2705c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero); 2706c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero); 2707c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2708d201456903f3ecae1f7794edfab0d5678e64226shiqian 2709d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2710c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(v.close_to_positive_zero, 2711c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2712c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2713d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2714d201456903f3ecae1f7794edfab0d5678e64226shiqian 2715d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2716d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, SmallDiff) { 2717c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(1.0, values_.close_to_one); 2718c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one), 2719c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2720d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2721d201456903f3ecae1f7794edfab0d5678e64226shiqian 2722d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2723d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, LargeDiff) { 2724d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 2725d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2726d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2727d201456903f3ecae1f7794edfab0d5678e64226shiqian 2728d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2729d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2730d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2731d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2732d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Infinity) { 2733c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity); 2734c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity); 27350af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2736e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2737c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity), 2738c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2739d201456903f3ecae1f7794edfab0d5678e64226shiqian 2740d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 2741d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2742c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1), 2743c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 27440af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2745d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2746d201456903f3ecae1f7794edfab0d5678e64226shiqian 2747d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2748d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, NaN) { 27490af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2750c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2751c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2752c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2753c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const DoubleTest::TestValues& v(this->values_); 2754c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2755e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2756c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), 2757c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2758c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2"); 2759c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1"); 2760c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), 2761c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 27620af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2763d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2764d201456903f3ecae1f7794edfab0d5678e64226shiqian 2765d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are reflexive. 2766d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Reflexive) { 2767d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, 0.0); 2768d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, 1.0); 27690af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2770e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2771c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity); 27720af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2773d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2774d201456903f3ecae1f7794edfab0d5678e64226shiqian 2775d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are commutative. 2776d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Commutative) { 2777c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one). 2778c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0); 2779d201456903f3ecae1f7794edfab0d5678e64226shiqian 2780c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one). 2781c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0), 2782c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "1.0"); 2783d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2784d201456903f3ecae1f7794edfab0d5678e64226shiqian 2785d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2786d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, EXPECT_NEAR) { 2787d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0, -1.1, 0.2); 2788d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0, 3.0, 1.0); 2789d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1), // NOLINT 2790d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2791d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2792d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2793d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2794d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2795d201456903f3ecae1f7794edfab0d5678e64226shiqian 2796d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2797d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, ASSERT_NEAR) { 2798d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0, -1.1, 0.2); 2799d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0, 3.0, 1.0); 2800d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1), // NOLINT 2801d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2802d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2803d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2804d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2805d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2806d201456903f3ecae1f7794edfab0d5678e64226shiqian 2807d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should succeed. 2808d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLESucceeds) { 28099b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 28109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 2811d201456903f3ecae1f7794edfab0d5678e64226shiqian 2812d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2813c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0); 2814d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2815d201456903f3ecae1f7794edfab0d5678e64226shiqian 2816d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should fail. 2817d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLEFails) { 2818d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 28199b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 2820d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0) <= (1.0)"); 2821d201456903f3ecae1f7794edfab0d5678e64226shiqian 2822d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2823d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2824c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0); 2825c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0)"); 2826d201456903f3ecae1f7794edfab0d5678e64226shiqian 2827c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2828e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2829c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2830c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2831d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2832c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity); 2833c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2834d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2835c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1); 2836c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, " (-values_.infinity) <= (values_.nan1)"); 2837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2838c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1); 2839c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2840c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2841d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2842d201456903f3ecae1f7794edfab0d5678e64226shiqian 2843d201456903f3ecae1f7794edfab0d5678e64226shiqian 2844d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that a test or test case whose name starts with DISABLED_ is 2845d201456903f3ecae1f7794edfab0d5678e64226shiqian// not run. 2846d201456903f3ecae1f7794edfab0d5678e64226shiqian 2847d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name starts with DISABLED_. 2848d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2849d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, DISABLED_TestShouldNotRun) { 2850d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2851d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2852d201456903f3ecae1f7794edfab0d5678e64226shiqian 2853d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name does not start with DISABLED_. 2854d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should run. 2855d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, NotDISABLED_TestShouldRun) { 2856d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1); 2857d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2858d201456903f3ecae1f7794edfab0d5678e64226shiqian 2859d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case whose name starts with DISABLED_. 2860d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2861d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, TestShouldNotRun) { 2862d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2863d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2864d201456903f3ecae1f7794edfab0d5678e64226shiqian 2865d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case and test whose names start with DISABLED_. 2866d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2867d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 2868d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2869d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2870d201456903f3ecae1f7794edfab0d5678e64226shiqian 2871d201456903f3ecae1f7794edfab0d5678e64226shiqian// Check that when all tests in a test case are disabled, SetupTestCase() and 2872d201456903f3ecae1f7794edfab0d5678e64226shiqian// TearDownTestCase() are not called. 28739b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass DisabledTestsTest : public Test { 2874d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2875d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 2876d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2877d201456903f3ecae1f7794edfab0d5678e64226shiqian "SetupTestCase() should not be called."; 2878d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2879d201456903f3ecae1f7794edfab0d5678e64226shiqian 2880d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 2881d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2882d201456903f3ecae1f7794edfab0d5678e64226shiqian "TearDownTestCase() should not be called."; 2883d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2884d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2885d201456903f3ecae1f7794edfab0d5678e64226shiqian 2886d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 2887d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2888d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2889d201456903f3ecae1f7794edfab0d5678e64226shiqian 2890d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 2891d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2892d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2893d201456903f3ecae1f7794edfab0d5678e64226shiqian 2894a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled typed tests aren't run. 2895a2b1a8556ea64014606d78b09333d9c522430a25shiqian 28960af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST 2897a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2898a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2899a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTest : public Test { 2900a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2901a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2902a2b1a8556ea64014606d78b09333d9c522430a25shiqiantypedef testing::Types<int, double> NumericTypes; 2903a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(TypedTest, NumericTypes); 2904a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2905a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 2906a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2907a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2908a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2909a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2910a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTest : public Test { 2911a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2912a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2913a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 2914a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2915a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 2916a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2917a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2918a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2919a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST 2920a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2921a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled type-parameterized tests aren't run. 2922a2b1a8556ea64014606d78b09333d9c522430a25shiqian 29230af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST_P 2924a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2925a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2926a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTestP : public Test { 2927a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2928a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2929a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(TypedTestP); 2930a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2931a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 2932a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2933a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2934a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2935a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2936a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 2937a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2938a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 2939a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2940a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2941a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTestP : public Test { 2942a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2943a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2944a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(DISABLED_TypedTestP); 2945a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2946a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 2947a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2948a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2949a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2950a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2951a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 2952a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2953a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 2954a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2955a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST_P 2956d201456903f3ecae1f7794edfab0d5678e64226shiqian 2957d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion macros evaluate their arguments exactly once. 2958d201456903f3ecae1f7794edfab0d5678e64226shiqian 29599b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SingleEvaluationTest : public Test { 29608de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 2961d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_STREQ test 2962c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // below. It's public to work around C++Builder's bug with scoping local 2963c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // classes. 2964d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementCharPtrs() { 2965d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1_++, p2_++); 2966d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2967d201456903f3ecae1f7794edfab0d5678e64226shiqian 2968c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This helper function is needed by the FailedASSERT_NE test below. It's 2969c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // public to work around C++Builder's bug with scoping local classes. 2970d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementInts() { 2971d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(a_++, b_++); 2972d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2973d201456903f3ecae1f7794edfab0d5678e64226shiqian 2974c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan protected: 2975c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan SingleEvaluationTest() { 2976c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p1_ = s1_; 2977c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p2_ = s2_; 2978c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan a_ = 0; 2979c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan b_ = 0; 2980c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 2981c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2982d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s1_; 2983d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s2_; 2984d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p1_; 2985d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p2_; 2986d201456903f3ecae1f7794edfab0d5678e64226shiqian 2987d201456903f3ecae1f7794edfab0d5678e64226shiqian static int a_; 2988d201456903f3ecae1f7794edfab0d5678e64226shiqian static int b_; 2989d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2990d201456903f3ecae1f7794edfab0d5678e64226shiqian 2991d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s1_ = "01234"; 2992d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s2_ = "abcde"; 2993d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p1_; 2994d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p2_; 2995d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::a_; 2996d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::b_; 2997d201456903f3ecae1f7794edfab0d5678e64226shiqian 2998d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_STREQ fails, it evaluates its arguments 2999d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 3000d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 3001c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(), 3002d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2_++"); 3003d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3004d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3005d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3006d201456903f3ecae1f7794edfab0d5678e64226shiqian 3007d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that string assertion arguments are evaluated exactly once. 3008d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, ASSERT_STR) { 3009d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_STRNE 3010d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(p1_++, p2_++); 3011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3012d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3013d201456903f3ecae1f7794edfab0d5678e64226shiqian 3014d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_STRCASEEQ 3015d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 3016d201456903f3ecae1f7794edfab0d5678e64226shiqian "ignoring case"); 3017d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 2, p1_); 3018d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 2, p2_); 3019d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3020d201456903f3ecae1f7794edfab0d5678e64226shiqian 3021d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 3022d201456903f3ecae1f7794edfab0d5678e64226shiqian// once. 3023d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 3024c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(), 3025c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "(a_++) != (b_++)"); 3026d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3027d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3028d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3029d201456903f3ecae1f7794edfab0d5678e64226shiqian 3030d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion arguments are evaluated exactly once. 3031d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, OtherCases) { 3032d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_TRUE 3033d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(0 == a_++); // NOLINT 3034d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3035d201456903f3ecae1f7794edfab0d5678e64226shiqian 3036d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_TRUE 3037d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 3038d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a_); 3039d201456903f3ecae1f7794edfab0d5678e64226shiqian 3040d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_GT 3041d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(a_++, b_++); 3042d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a_); 3043d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3044d201456903f3ecae1f7794edfab0d5678e64226shiqian 3045d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_LT 3046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 3047d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a_); 3048d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, b_); 3049d201456903f3ecae1f7794edfab0d5678e64226shiqian 3050d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_TRUE 3051d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(0 < a_++); // NOLINT 3052d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, a_); 3053d201456903f3ecae1f7794edfab0d5678e64226shiqian 3054d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_GT 3055d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(a_++, b_++); 3056d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(6, a_); 3057d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, b_); 3058d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3059d201456903f3ecae1f7794edfab0d5678e64226shiqian 306036865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 306136865d8d354465e3461eedf2949a4b7799985d5dshiqian 306236865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAnInteger() { 306336865d8d354465e3461eedf2949a4b7799985d5dshiqian throw 1; 306436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 306536865d8d354465e3461eedf2949a4b7799985d5dshiqian 306636865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests that assertion arguments are evaluated exactly once. 306736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST_F(SingleEvaluationTest, ExceptionTests) { 306836865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_THROW 306936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW({ // NOLINT 307036865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 307136865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 307236865d8d354465e3461eedf2949a4b7799985d5dshiqian }, int); 307336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(1, a_); 307436865d8d354465e3461eedf2949a4b7799985d5dshiqian 307536865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws different 307636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 307736865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 307836865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 307936865d8d354465e3461eedf2949a4b7799985d5dshiqian }, bool), "throws a different type"); 308036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(2, a_); 308136865d8d354465e3461eedf2949a4b7799985d5dshiqian 308236865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws nothing 308336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 308436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(3, a_); 308536865d8d354465e3461eedf2949a4b7799985d5dshiqian 308636865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_NO_THROW 308736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(a_++); 308836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(4, a_); 308936865d8d354465e3461eedf2949a4b7799985d5dshiqian 309036865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_NO_THROW 309136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 309236865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 309336865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 309436865d8d354465e3461eedf2949a4b7799985d5dshiqian }), "it throws"); 309536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(5, a_); 309636865d8d354465e3461eedf2949a4b7799985d5dshiqian 309736865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_ANY_THROW 309836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW({ // NOLINT 309936865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 310036865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 310136865d8d354465e3461eedf2949a4b7799985d5dshiqian }); 310236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(6, a_); 310336865d8d354465e3461eedf2949a4b7799985d5dshiqian 310436865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_ANY_THROW 310536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 310636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(7, a_); 310736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 310836865d8d354465e3461eedf2949a4b7799985d5dshiqian 310936865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 3110d201456903f3ecae1f7794edfab0d5678e64226shiqian 3111e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE. 3112e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass NoFatalFailureTest : public Test { 3113e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 3114e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Succeeds() {} 3115e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void FailsNonFatal() { 3116e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "some non-fatal failure"; 3117e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3118e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Fails() { 3119e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FAIL() << "some fatal failure"; 3120e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3121e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3122e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoAssertNoFatalFailureOnFails() { 3123e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Fails()); 3124e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "shold not reach here."; 3125e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3127e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoExpectNoFatalFailureOnFails() { 3128e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Fails()); 3129e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "other failure"; 3130e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3131e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 3132e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3133e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NoFailure) { 3134e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Succeeds()); 3135e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Succeeds()); 3136e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3137e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3138e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NonFatalIsNoFailure) { 3139e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3140e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FailsNonFatal()), 3141e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3142e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3143e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FailsNonFatal()), 3144e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3145e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3146e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3147e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) { 3148e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3149e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3150e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3151e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoAssertNoFatalFailureOnFails(); 3152e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3153e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3154e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 3155e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3156e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 3157e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3158e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3159e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3160e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3161e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3162e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3163e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3164e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) { 3165e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3166e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3167e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3168e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoExpectNoFatalFailureOnFails(); 3169e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3170e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(3, gtest_failures.size()); 3171e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 3172e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3173e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 3174e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3175e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 3176e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).type()); 3177e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3178e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3179e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3180e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3181e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure", 3182e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).message()); 3183e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3184e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3185e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, MessageIsStreamable) { 3186e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3187e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3188e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3189e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message"; 3190e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3191e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3192e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 3193e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3194e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 3195e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3196e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo", 3197e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3198e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message", 3199e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3200e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3201e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3202d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests non-string assertions. 3203d201456903f3ecae1f7794edfab0d5678e64226shiqian 3204d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EqFailure(), used for implementing *EQ* assertions. 3205d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, EqFailure) { 3206d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo_val("5"), bar_val("6"); 3207d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg1( 3208d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", foo_val, bar_val, false) 3209d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3210d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3211d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3212d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3213d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3214d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3215d201456903f3ecae1f7794edfab0d5678e64226shiqian msg1.c_str()); 3216d201456903f3ecae1f7794edfab0d5678e64226shiqian 3217d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg2( 3218d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "6", foo_val, bar_val, false) 3219d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3220d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3221d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3222d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3223d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3224d201456903f3ecae1f7794edfab0d5678e64226shiqian msg2.c_str()); 3225d201456903f3ecae1f7794edfab0d5678e64226shiqian 3226d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg3( 3227d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "bar", foo_val, bar_val, false) 3228d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3229d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3230d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3231d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3232d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3233d201456903f3ecae1f7794edfab0d5678e64226shiqian msg3.c_str()); 3234d201456903f3ecae1f7794edfab0d5678e64226shiqian 3235d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg4( 3236d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 3237d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3238d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3239d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3240d201456903f3ecae1f7794edfab0d5678e64226shiqian msg4.c_str()); 3241d201456903f3ecae1f7794edfab0d5678e64226shiqian 3242d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg5( 3243d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", 3244d201456903f3ecae1f7794edfab0d5678e64226shiqian String("\"x\""), String("\"y\""), 3245d201456903f3ecae1f7794edfab0d5678e64226shiqian true).failure_message()); 3246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3247d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3248d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"y\"\n" 3249d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo (ignoring case)\n" 3250d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"x\"", 3251d201456903f3ecae1f7794edfab0d5678e64226shiqian msg5.c_str()); 3252d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3253d201456903f3ecae1f7794edfab0d5678e64226shiqian 3254d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests AppendUserMessage(), used for implementing the *EQ* macros. 3255d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AppendUserMessage) { 3256d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 3257d201456903f3ecae1f7794edfab0d5678e64226shiqian 32589b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3259d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", 3260d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3261d201456903f3ecae1f7794edfab0d5678e64226shiqian 3262d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << "bar"; 3263d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo\nbar", 3264d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3265d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3266d201456903f3ecae1f7794edfab0d5678e64226shiqian 3267c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3268c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3269c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3270c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3271c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3272d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_TRUE. 3273d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_TRUE) { 3274d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(2 > 1); // NOLINT 3275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 3276d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 1"); 3277d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3278d201456903f3ecae1f7794edfab0d5678e64226shiqian 3279d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_FALSE. 3280d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_FALSE) { 3281d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(2 < 1); // NOLINT 3282d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 3283d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3284d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3285d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3286d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3287d201456903f3ecae1f7794edfab0d5678e64226shiqian 3288c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3289c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3290c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 3291c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3292c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3293d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ASSERT_EQ on double values. The purpose is to make 3294d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3295d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3296d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_Double) { 3297d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3298d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5.6, 5.6); 3299d201456903f3ecae1f7794edfab0d5678e64226shiqian 3300d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3301d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 3302d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3303d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3304d201456903f3ecae1f7794edfab0d5678e64226shiqian 3305d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ. 3306d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ) { 3307d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5, 2 + 3); 3308d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 3309d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3310d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3311d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3312d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3313d201456903f3ecae1f7794edfab0d5678e64226shiqian 3314d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(NULL, pointer). 33150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3316d201456903f3ecae1f7794edfab0d5678e64226shiqian// The NULL-detection template magic fails to compile with 3317d201456903f3ecae1f7794edfab0d5678e64226shiqian// the Nokia compiler and crashes the ARM compiler, hence 3318d201456903f3ecae1f7794edfab0d5678e64226shiqian// not testing on Symbian. 3319d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ_NULL) { 3320d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3321d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3322e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Some older GCC versions may issue a spurious waring in this or the next 3323e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 3324e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 3325e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 3326d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(NULL, p); 3327d201456903f3ecae1f7794edfab0d5678e64226shiqian 3328d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3329d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 3330d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 3331d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3332d201456903f3ecae1f7794edfab0d5678e64226shiqian} 33330af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3334d201456903f3ecae1f7794edfab0d5678e64226shiqian 3335d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 3336d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3337d201456903f3ecae1f7794edfab0d5678e64226shiqian// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 3338d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 3339d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_0) { 3340d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3341d201456903f3ecae1f7794edfab0d5678e64226shiqian 3342d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3343d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0, n); 3344d201456903f3ecae1f7794edfab0d5678e64226shiqian 3345d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3346d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 3347d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3348d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3349d201456903f3ecae1f7794edfab0d5678e64226shiqian 3350d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NE. 3351d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_NE) { 3352d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(6, 7); 3353d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 3354d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3355d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3356d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3357d201456903f3ecae1f7794edfab0d5678e64226shiqian 3358d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LE. 3359d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LE) { 3360d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 3); 3361d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 2); 3362d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 3363d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3364d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3365d201456903f3ecae1f7794edfab0d5678e64226shiqian 3366d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LT. 3367d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LT) { 3368d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(2, 3); 3369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 3370d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3371d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3372d201456903f3ecae1f7794edfab0d5678e64226shiqian 3373d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GE. 3374d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GE) { 3375d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 1); 3376d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 2); 3377d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 3378d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3379d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3380d201456903f3ecae1f7794edfab0d5678e64226shiqian 3381d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GT. 3382d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GT) { 3383d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(2, 1); 3384d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 3385d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3386d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3387d201456903f3ecae1f7794edfab0d5678e64226shiqian 338836865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 338936865d8d354465e3461eedf2949a4b7799985d5dshiqian 3390886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wanvoid ThrowNothing() {} 3391886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan 339236865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_THROW. 339336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_THROW) { 339436865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int); 3395c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 || defined(_DEBUG) 3396c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 (Release build). 3397886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3398886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowAnInteger(), bool), 3399886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of type bool.\n" 3400886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws a different type."); 3401c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3402886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3403886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowNothing(), bool), 3404886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3405886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 340636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 340736865d8d354465e3461eedf2949a4b7799985d5dshiqian 340836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_NO_THROW. 340936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_NO_THROW) { 3410886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()); 341136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 3412886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an exception." 341336865d8d354465e3461eedf2949a4b7799985d5dshiqian "\n Actual: it throws."); 341436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 341536865d8d354465e3461eedf2949a4b7799985d5dshiqian 341636865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_ANY_THROW. 341736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_ANY_THROW) { 341836865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()); 3419886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3420886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_ANY_THROW(ThrowNothing()), 3421886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3422886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 342336865d8d354465e3461eedf2949a4b7799985d5dshiqian} 342436865d8d354465e3461eedf2949a4b7799985d5dshiqian 342536865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 342636865d8d354465e3461eedf2949a4b7799985d5dshiqian 3427d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure we deal with the precedence of <<. This test should 3428d201456903f3ecae1f7794edfab0d5678e64226shiqian// compile. 3429d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertPrecedence) { 3430d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1 < 2, true); 3431d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(true && false, false); 3432d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3433d201456903f3ecae1f7794edfab0d5678e64226shiqian 3434d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3435d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestEq1(int x) { 3436d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, x); 3437d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3438d201456903f3ecae1f7794edfab0d5678e64226shiqian 3439d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests calling a test subroutine that's not part of a fixture. 3440d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, NonFixtureSubroutine) { 3441d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestEq1(2), 3442d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: x"); 3443d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3444d201456903f3ecae1f7794edfab0d5678e64226shiqian 3445d201456903f3ecae1f7794edfab0d5678e64226shiqian// An uncopyable class. 3446d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Uncopyable { 3447d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3448d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Uncopyable(int value) : value_(value) {} 3449d201456903f3ecae1f7794edfab0d5678e64226shiqian 3450d201456903f3ecae1f7794edfab0d5678e64226shiqian int value() const { return value_; } 3451d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator==(const Uncopyable& rhs) const { 3452d201456903f3ecae1f7794edfab0d5678e64226shiqian return value() == rhs.value(); 3453d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3454d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3455d201456903f3ecae1f7794edfab0d5678e64226shiqian // This constructor deliberately has no implementation, as we don't 3456d201456903f3ecae1f7794edfab0d5678e64226shiqian // want this class to be copyable. 3457d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable(const Uncopyable&); // NOLINT 3458d201456903f3ecae1f7794edfab0d5678e64226shiqian 3459d201456903f3ecae1f7794edfab0d5678e64226shiqian int value_; 3460d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3461d201456903f3ecae1f7794edfab0d5678e64226shiqian 3462d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 3463d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << value.value(); 3464d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3465d201456903f3ecae1f7794edfab0d5678e64226shiqian 3466d201456903f3ecae1f7794edfab0d5678e64226shiqian 3467d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositiveUncopyable(const Uncopyable& x) { 3468d201456903f3ecae1f7794edfab0d5678e64226shiqian return x.value() > 0; 3469d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3470d201456903f3ecae1f7794edfab0d5678e64226shiqian 3471d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3472d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertNonPositive() { 3473d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3474d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, y); 3475d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3476d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3477d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertEqualsUncopyable() { 3478d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3479d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3480d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, y); 3481d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3482d201456903f3ecae1f7794edfab0d5678e64226shiqian 3483d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in assertions. 3484d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertWorksWithUncopyableObject) { 3485d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3486d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, x); 3487d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, x); 3488d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 3489d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3490d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 3491d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3492d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3493d201456903f3ecae1f7794edfab0d5678e64226shiqian 3494d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in expects. 3495d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 3496d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3497d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsPositiveUncopyable, x); 3498d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3499d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 3500d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3501d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(x, x); 3502d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 3503d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3504d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3505d201456903f3ecae1f7794edfab0d5678e64226shiqian 3506d201456903f3ecae1f7794edfab0d5678e64226shiqian 3507d201456903f3ecae1f7794edfab0d5678e64226shiqian// The version of gcc used in XCode 2.2 has a bug and doesn't allow 35086a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// anonymous enums in assertions. Therefore the following test is not 35096a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// done on Mac. 35106a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#if !GTEST_OS_MAC 3511d201456903f3ecae1f7794edfab0d5678e64226shiqian 3512d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using assertions with anonymous enums. 3513d201456903f3ecae1f7794edfab0d5678e64226shiqianenum { 3514d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_A = -1, 35150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 3516d201456903f3ecae1f7794edfab0d5678e64226shiqian // We want to test the case where the size of the anonymous enum is 3517d201456903f3ecae1f7794edfab0d5678e64226shiqian // larger than sizeof(int), to make sure our implementation of the 3518d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions doesn't truncate the enums. However, MSVC 3519d201456903f3ecae1f7794edfab0d5678e64226shiqian // (incorrectly) doesn't allow an enum value to exceed the range of 3520d201456903f3ecae1f7794edfab0d5678e64226shiqian // an int, so this has to be conditionally compiled. 3521d201456903f3ecae1f7794edfab0d5678e64226shiqian // 3522d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Linux, CASE_B and CASE_A have the same value when truncated to 3523d201456903f3ecae1f7794edfab0d5678e64226shiqian // int size. We want to test whether this will confuse the 3524d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions. 35259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian CASE_B = testing::internal::kMaxBiggestInt, 3526d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 3527d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_B = INT_MAX, 3528d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 3529d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3530d201456903f3ecae1f7794edfab0d5678e64226shiqian 3531d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AnonymousEnum) { 35320af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 3533d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B)); 3534d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 3535d201456903f3ecae1f7794edfab0d5678e64226shiqian 3536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(CASE_A, CASE_A); 3537d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(CASE_A, CASE_B); 3538d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(CASE_A, CASE_B); 3539d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(CASE_A, CASE_B); 3540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(CASE_B, CASE_A); 3541d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(CASE_A, CASE_A); 3542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(CASE_A, CASE_B), 3543d201456903f3ecae1f7794edfab0d5678e64226shiqian "(CASE_A) >= (CASE_B)"); 3544d201456903f3ecae1f7794edfab0d5678e64226shiqian 3545d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(CASE_A, CASE_A); 3546d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(CASE_A, CASE_B); 3547d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(CASE_A, CASE_B); 3548d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(CASE_A, CASE_B); 3549d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(CASE_B, CASE_A); 3550d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(CASE_A, CASE_A); 3551d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(CASE_A, CASE_B), 3552d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: CASE_B"); 3553d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3554d201456903f3ecae1f7794edfab0d5678e64226shiqian 35556a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#endif // !GTEST_OS_MAC 3556d201456903f3ecae1f7794edfab0d5678e64226shiqian 35570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 3558d201456903f3ecae1f7794edfab0d5678e64226shiqian 3559d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT UnexpectedHRESULTFailure() { 3560d201456903f3ecae1f7794edfab0d5678e64226shiqian return E_UNEXPECTED; 3561d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3562d201456903f3ecae1f7794edfab0d5678e64226shiqian 3563d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT OkHRESULTSuccess() { 3564d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_OK; 3565d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3566d201456903f3ecae1f7794edfab0d5678e64226shiqian 3567d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT FalseHRESULTSuccess() { 3568d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_FALSE; 3569d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3570d201456903f3ecae1f7794edfab0d5678e64226shiqian 3571d201456903f3ecae1f7794edfab0d5678e64226shiqian// HRESULT assertion tests test both zero and non-zero 3572d201456903f3ecae1f7794edfab0d5678e64226shiqian// success codes as well as failure message for each. 3573d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3574d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows CE doesn't support message texts. 3575d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 3576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK); 3577d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_FALSE); 3578d201456903f3ecae1f7794edfab0d5678e64226shiqian 3579d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3580ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3581ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3582d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3583d201456903f3ecae1f7794edfab0d5678e64226shiqian 3584d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 3585d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK); 3586d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_FALSE); 3587d201456903f3ecae1f7794edfab0d5678e64226shiqian 3588d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3589ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3590ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3591d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3592d201456903f3ecae1f7794edfab0d5678e64226shiqian 3593d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 3594d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED); 3595d201456903f3ecae1f7794edfab0d5678e64226shiqian 3596d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 3597ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3598ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3599d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 3600ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3601ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3602d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3603d201456903f3ecae1f7794edfab0d5678e64226shiqian 3604d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 3605d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED); 3606d201456903f3ecae1f7794edfab0d5678e64226shiqian 3607c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3608c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3609d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 3610ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3611ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3612c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3613d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 3614ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3615ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3616d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3617d201456903f3ecae1f7794edfab0d5678e64226shiqian 3618d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that streaming to the HRESULT macros works. 3619d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, Streaming) { 3620d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3621d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3622d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3623d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3624d201456903f3ecae1f7794edfab0d5678e64226shiqian 3625d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3627d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3628d201456903f3ecae1f7794edfab0d5678e64226shiqian 3629c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3630c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3631d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3632d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3633d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3634c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3635d201456903f3ecae1f7794edfab0d5678e64226shiqian 3636d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3637d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 3638d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3639d201456903f3ecae1f7794edfab0d5678e64226shiqian 3640d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3641d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 3642d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3643d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3644d201456903f3ecae1f7794edfab0d5678e64226shiqian 36450af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_WINDOWS 3646d201456903f3ecae1f7794edfab0d5678e64226shiqian 3647c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3648c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3649c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3650c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3651c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3652d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros behave like single statements. 3653e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) { 3654d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3655d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(false) << "This should never be executed; " 3656d201456903f3ecae1f7794edfab0d5678e64226shiqian "It's a compilation test only."; 3657d201456903f3ecae1f7794edfab0d5678e64226shiqian 3658d201456903f3ecae1f7794edfab0d5678e64226shiqian if (true) 3659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false); 3660d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3661ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3662d201456903f3ecae1f7794edfab0d5678e64226shiqian 3663d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3664d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 3); 3665d201456903f3ecae1f7794edfab0d5678e64226shiqian 3666d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3667ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3668d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(3, 2) << ""; 3670e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 367136865d8d354465e3461eedf2949a4b7799985d5dshiqian 367236865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 367337504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the compiler will not complain about unreachable code in the 367437504994338c114247519331237831f88a9a7c40zhanyong.wan// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros. 367537504994338c114247519331237831f88a9a7c40zhanyong.wanTEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) { 367637504994338c114247519331237831f88a9a7c40zhanyong.wan int n = 0; 367737504994338c114247519331237831f88a9a7c40zhanyong.wan 367837504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_THROW(throw 1, int); 367937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), ""); 368037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), ""); 368137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NO_THROW(n++); 368237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), ""); 368337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_ANY_THROW(throw 1); 368437504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), ""); 368537504994338c114247519331237831f88a9a7c40zhanyong.wan} 368637504994338c114247519331237831f88a9a7c40zhanyong.wan 3687e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) { 368836865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 3689886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool); 369036865d8d354465e3461eedf2949a4b7799985d5dshiqian 369136865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 369236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 369336865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3694ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 369536865d8d354465e3461eedf2949a4b7799985d5dshiqian 369636865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 369736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(ThrowAnInteger()); 369836865d8d354465e3461eedf2949a4b7799985d5dshiqian 369936865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 3700886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 370136865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3702ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 370336865d8d354465e3461eedf2949a4b7799985d5dshiqian 370436865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 3705886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()); 370636865d8d354465e3461eedf2949a4b7799985d5dshiqian 370736865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 370836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 370936865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3710ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3711e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 371236865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 3713e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3714e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) { 3715e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3716e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. " 3717e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian << "It's a compilation test only."; 3718e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3719ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3720e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3721e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3722e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FAIL()) << ""; 3723e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3724ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3725e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3726e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (true) 3727e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(SUCCEED()); 3728e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3729ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3730e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3731e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3732ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3733e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3734e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(SUCCEED()); 3735d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3736d201456903f3ecae1f7794edfab0d5678e64226shiqian 3737d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros work well with switch statements. 3738d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, WorksWithSwitch) { 3739d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 3740d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 3741d201456903f3ecae1f7794edfab0d5678e64226shiqian break; 3742d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 3743d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 3744d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3745d201456903f3ecae1f7794edfab0d5678e64226shiqian 3746d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 3747d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 3748d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 3749d201456903f3ecae1f7794edfab0d5678e64226shiqian 3750d201456903f3ecae1f7794edfab0d5678e64226shiqian // Binary assertions are implemented using a different code path 3751d201456903f3ecae1f7794edfab0d5678e64226shiqian // than the Boolean assertions. Hence we test them separately. 3752d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 3753d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 3754d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 3755d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 3756d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3757d201456903f3ecae1f7794edfab0d5678e64226shiqian 3758d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 3759d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 3760d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(1, 2); 3761d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3762d201456903f3ecae1f7794edfab0d5678e64226shiqian 376336865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 376436865d8d354465e3461eedf2949a4b7799985d5dshiqian 376536865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAString() { 376636865d8d354465e3461eedf2949a4b7799985d5dshiqian throw "String"; 376736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 376836865d8d354465e3461eedf2949a4b7799985d5dshiqian 376936865d8d354465e3461eedf2949a4b7799985d5dshiqian// Test that the exception assertion macros compile and work with const 377036865d8d354465e3461eedf2949a4b7799985d5dshiqian// type qualifier. 377136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionSyntaxTest, WorksWithConst) { 377236865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAString(), const char*); 377336865d8d354465e3461eedf2949a4b7799985d5dshiqian 377436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAString(), const char*); 377536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 377636865d8d354465e3461eedf2949a4b7799985d5dshiqian 377736865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 377836865d8d354465e3461eedf2949a4b7799985d5dshiqian 3779d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 3780d201456903f3ecae1f7794edfab0d5678e64226shiqian 3781d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns the number of successful parts in the current test. 3782d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic size_t GetSuccessfulPartCount() { 3783aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wan return GetUnitTestImpl()->current_test_result()->successful_part_count(); 3784d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3785d201456903f3ecae1f7794edfab0d5678e64226shiqian 3786d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 3787d201456903f3ecae1f7794edfab0d5678e64226shiqian 3788d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test tracks SUCCEED*. 3789d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, SUCCEED) { 3790d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 3791d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "OK"; 3792600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(2, GetSuccessfulPartCount()); 3793d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3794d201456903f3ecae1f7794edfab0d5678e64226shiqian 3795d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_*. 3796d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT) { 3797d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true); 3798600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, GetSuccessfulPartCount()); 3799d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3800d201456903f3ecae1f7794edfab0d5678e64226shiqian 3801d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_STR*. 3802d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT_STR) { 3803d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", ""); 3804600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, GetSuccessfulPartCount()); 3805d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3806d201456903f3ecae1f7794edfab0d5678e64226shiqian 3807d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_*. 3808d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT) { 3809d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 3810600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, GetSuccessfulPartCount()); 3811d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3812d201456903f3ecae1f7794edfab0d5678e64226shiqian 3813d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_STR*. 3814d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT_STR) { 3815d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("", ""); 3816600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(0, GetSuccessfulPartCount()); 3817d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3818d201456903f3ecae1f7794edfab0d5678e64226shiqian 3819d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 3820d201456903f3ecae1f7794edfab0d5678e64226shiqian 3821d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 3822d201456903f3ecae1f7794edfab0d5678e64226shiqian 3823d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_TRUE. 3824d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_TRUE) { 3825d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(2 > 1); // NOLINT 3826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 3827d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 < 1\n" 3828d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: false\n" 3829d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: true"); 3830d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 3831d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 > 3"); 3832d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3833d201456903f3ecae1f7794edfab0d5678e64226shiqian 3834d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_FALSE. 3835d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_FALSE) { 3836d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(2 < 1); // NOLINT 3837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 3838d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3839d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3840d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3841d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 3842d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 3"); 3843d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3844d201456903f3ecae1f7794edfab0d5678e64226shiqian 3845c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3846c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3847c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 3848c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3849c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3850d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ. 3851d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ) { 3852d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, 2 + 3); 3853d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 3854d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3855d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3856d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3857d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 3858d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 - 3"); 3859d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3860d201456903f3ecae1f7794edfab0d5678e64226shiqian 3861d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using EXPECT_EQ on double values. The purpose is to make 3862d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3863d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3864d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_Double) { 3865d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3866d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5.6, 5.6); 3867d201456903f3ecae1f7794edfab0d5678e64226shiqian 3868d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3869d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 3870d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3871d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3872d201456903f3ecae1f7794edfab0d5678e64226shiqian 38730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3874d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(NULL, pointer). 3875d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_NULL) { 3876d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3877d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3878e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Some older GCC versions may issue a spurious waring in this or the next 3879e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 3880e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 3881e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 3882d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, p); 3883d201456903f3ecae1f7794edfab0d5678e64226shiqian 3884d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3885d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 3887d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3888d201456903f3ecae1f7794edfab0d5678e64226shiqian} 38890af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3890d201456903f3ecae1f7794edfab0d5678e64226shiqian 3891d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 3892d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3893d201456903f3ecae1f7794edfab0d5678e64226shiqian// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 3894d201456903f3ecae1f7794edfab0d5678e64226shiqian// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 3895d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_0) { 3896d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3897d201456903f3ecae1f7794edfab0d5678e64226shiqian 3898d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3899d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, n); 3900d201456903f3ecae1f7794edfab0d5678e64226shiqian 3901d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3902d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 3903d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3904d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3905d201456903f3ecae1f7794edfab0d5678e64226shiqian 3906d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NE. 3907d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_NE) { 3908d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(6, 7); 3909d201456903f3ecae1f7794edfab0d5678e64226shiqian 3910d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 3911d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3912d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3913d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 3914d201456903f3ecae1f7794edfab0d5678e64226shiqian "2"); 3915d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 3916d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 3917d201456903f3ecae1f7794edfab0d5678e64226shiqian "p0"); 3918d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 3919d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 3920d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 3921d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 3922d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 3923d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 3924d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 3925d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 3926d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3927d201456903f3ecae1f7794edfab0d5678e64226shiqian 3928d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LE. 3929d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LE) { 3930d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 3); 3931d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 2); 3932d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 3933d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3934d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 3935d201456903f3ecae1f7794edfab0d5678e64226shiqian "(1.1) <= (0.9)"); 3936d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3937d201456903f3ecae1f7794edfab0d5678e64226shiqian 3938d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LT. 3939d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LT) { 3940d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(2, 3); 3941d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 3942d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 3944d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) < (1)"); 3945d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3946d201456903f3ecae1f7794edfab0d5678e64226shiqian 3947d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GE. 3948d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GE) { 3949d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 1); 3950d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 2); 3951d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 3952d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3953d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 3954d201456903f3ecae1f7794edfab0d5678e64226shiqian "(0.9) >= (1.1)"); 3955d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3956d201456903f3ecae1f7794edfab0d5678e64226shiqian 3957d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GT. 3958d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GT) { 3959d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(2, 1); 3960d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 3961d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3962d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 3963d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) > (3)"); 3964d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3965d201456903f3ecae1f7794edfab0d5678e64226shiqian 396636865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 396736865d8d354465e3461eedf2949a4b7799985d5dshiqian 396836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_THROW. 396936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_THROW) { 397036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 397136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 3972886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of " 397336865d8d354465e3461eedf2949a4b7799985d5dshiqian "type bool.\n Actual: it throws a different type."); 3974886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 3975886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool), 3976886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3977886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 397836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 397936865d8d354465e3461eedf2949a4b7799985d5dshiqian 398036865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_NO_THROW. 398136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_NO_THROW) { 3982886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 398336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 3984886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an " 398536865d8d354465e3461eedf2949a4b7799985d5dshiqian "exception.\n Actual: it throws."); 398636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 398736865d8d354465e3461eedf2949a4b7799985d5dshiqian 398836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_ANY_THROW. 398936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_ANY_THROW) { 399036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 3991886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 3992886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()), 3993886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3994886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 399536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 399636865d8d354465e3461eedf2949a4b7799985d5dshiqian 399736865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 399836865d8d354465e3461eedf2949a4b7799985d5dshiqian 3999d201456903f3ecae1f7794edfab0d5678e64226shiqian// Make sure we deal with the precedence of <<. 4000d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ExpectPrecedence) { 4001d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1 < 2, true); 4002d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 4003d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true && false"); 4004d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4005d201456903f3ecae1f7794edfab0d5678e64226shiqian 4006d201456903f3ecae1f7794edfab0d5678e64226shiqian 4007d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the StreamableToString() function. 4008d201456903f3ecae1f7794edfab0d5678e64226shiqian 4009d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a scalar. 4010d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Scalar) { 4011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("5", StreamableToString(5).c_str()); 4012d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4013d201456903f3ecae1f7794edfab0d5678e64226shiqian 4014d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a non-char pointer. 4015d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Pointer) { 4016d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4017d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = &n; 4018d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 4019d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4020d201456903f3ecae1f7794edfab0d5678e64226shiqian 4021d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL non-char pointer. 4022d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullPointer) { 4023d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = NULL; 4024d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4025d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4026d201456903f3ecae1f7794edfab0d5678e64226shiqian 4027d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a C string. 4028d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, CString) { 4029d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 4030d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4031d201456903f3ecae1f7794edfab0d5678e64226shiqian 4032d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL C string. 4033d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullCString) { 4034d201456903f3ecae1f7794edfab0d5678e64226shiqian char* p = NULL; 4035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4036d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4037d201456903f3ecae1f7794edfab0d5678e64226shiqian 4038d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using streamable values as assertion messages. 4039d201456903f3ecae1f7794edfab0d5678e64226shiqian 4040d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 4041d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using std::string as an assertion message. 4042d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, string) { 4043d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string str( 4044d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure message is a std::string, and is expected."); 4045d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << str, 4046d201456903f3ecae1f7794edfab0d5678e64226shiqian str.c_str()); 4047d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4048d201456903f3ecae1f7794edfab0d5678e64226shiqian 4049d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output strings containing embedded NULs. 4050d201456903f3ecae1f7794edfab0d5678e64226shiqian// Limited to Linux because we can only do this with std::string's. 4051d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, stringWithEmbeddedNUL) { 4052d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char char_array_with_nul[] = 4053d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\0 and some more string"; 4054d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string string_with_nul(char_array_with_nul, 4055d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(char_array_with_nul) 4056d201456903f3ecae1f7794edfab0d5678e64226shiqian - 1); // drops the trailing NUL 4057d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 4058d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\\0 and some more string"); 4059d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4060d201456903f3ecae1f7794edfab0d5678e64226shiqian 4061d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 4062d201456903f3ecae1f7794edfab0d5678e64226shiqian 4063d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output a NUL char. 4064d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NULChar) { 4065d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4066d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "A NUL" << '\0' << " and some more string"; 4067d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "A NUL\\0 and some more string"); 4068d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4069d201456903f3ecae1f7794edfab0d5678e64226shiqian 4070d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int as an assertion message. 4071d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, int) { 4072d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << 900913, 4073d201456903f3ecae1f7794edfab0d5678e64226shiqian "900913"); 4074d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4075d201456903f3ecae1f7794edfab0d5678e64226shiqian 4076d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using NULL char pointer as an assertion message. 4077d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4078d201456903f3ecae1f7794edfab0d5678e64226shiqian// In MSVC, streaming a NULL char * causes access violation. Google Test 4079d201456903f3ecae1f7794edfab0d5678e64226shiqian// implemented a workaround (substituting "(null)" for NULL). This 4080d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests whether the workaround works. 4081d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NullCharPtr) { 4082d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 4083d201456903f3ecae1f7794edfab0d5678e64226shiqian "(null)"); 4084d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4085d201456903f3ecae1f7794edfab0d5678e64226shiqian 4086d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that basic IO manipulators (endl, ends, and flush) can be 4087d201456903f3ecae1f7794edfab0d5678e64226shiqian// streamed to testing::Message. 4088d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, BasicIoManip) { 4089d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4090d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Line 1." << std::endl 4091d201456903f3ecae1f7794edfab0d5678e64226shiqian << "A NUL char " << std::ends << std::flush << " in line 2."; 4092d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Line 1.\nA NUL char \\0 in line 2."); 4093d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4094d201456903f3ecae1f7794edfab0d5678e64226shiqian 4095d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the macros that haven't been covered so far. 4096d201456903f3ecae1f7794edfab0d5678e64226shiqian 4097d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AddFailureHelper(bool* aborted) { 4098d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 4099d201456903f3ecae1f7794edfab0d5678e64226shiqian ADD_FAILURE() << "Failure"; 4100d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 4101d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4102d201456903f3ecae1f7794edfab0d5678e64226shiqian 4103d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ADD_FAILURE. 4104d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, ADD_FAILURE) { 4105d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 4106d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 4107d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failure"); 4108d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 4109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4110d201456903f3ecae1f7794edfab0d5678e64226shiqian 4111d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests FAIL. 4112d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, FAIL) { 4113d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL(), 4114d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failed"); 4115d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 4116d201456903f3ecae1f7794edfab0d5678e64226shiqian "Intentional failure."); 4117d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4118d201456903f3ecae1f7794edfab0d5678e64226shiqian 4119d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests SUCCEED 4120d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, SUCCEED) { 4121d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 4122d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "Explicit success."; 4123d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4124d201456903f3ecae1f7794edfab0d5678e64226shiqian 4125d201456903f3ecae1f7794edfab0d5678e64226shiqian 4126d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for EXPECT_EQ() and ASSERT_EQ(). 4127d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4128d201456903f3ecae1f7794edfab0d5678e64226shiqian// These tests fail *intentionally*, s.t. the failure messages can be 4129d201456903f3ecae1f7794edfab0d5678e64226shiqian// generated and tested. 4130d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4131d201456903f3ecae1f7794edfab0d5678e64226shiqian// We have different tests for different argument types. 4132d201456903f3ecae1f7794edfab0d5678e64226shiqian 4133d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using bool values in {EXPECT|ASSERT}_EQ. 4134d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Bool) { 4135d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(true, true); 4136d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(false, true), 4137d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true"); 4138d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4139d201456903f3ecae1f7794edfab0d5678e64226shiqian 4140d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int values in {EXPECT|ASSERT}_EQ. 4141d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Int) { 4142d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(32, 32); 4143d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 4144d201456903f3ecae1f7794edfab0d5678e64226shiqian "33"); 4145d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4146d201456903f3ecae1f7794edfab0d5678e64226shiqian 4147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using time_t values in {EXPECT|ASSERT}_EQ. 4148d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Time_T) { 4149d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<time_t>(0), 4150d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(0)); 4151d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 4152d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(1234)), 4153d201456903f3ecae1f7794edfab0d5678e64226shiqian "1234"); 4154d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4155d201456903f3ecae1f7794edfab0d5678e64226shiqian 4156d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char values in {EXPECT|ASSERT}_EQ. 4157d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Char) { 4158d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ('z', 'z'); 4159d201456903f3ecae1f7794edfab0d5678e64226shiqian const char ch = 'b'; 4160d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 4161d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4162d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 4163d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4164d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4165d201456903f3ecae1f7794edfab0d5678e64226shiqian 4166d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 4167d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideChar) { 4168d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L'b', L'b'); 4169d201456903f3ecae1f7794edfab0d5678e64226shiqian 4170d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 4171d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: L'x'\n" 4172d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L'x' (120, 0x78)\n" 4173d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: L'\0'\n" 4174d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L'\0' (0, 0x0)"); 4175d201456903f3ecae1f7794edfab0d5678e64226shiqian 4176d201456903f3ecae1f7794edfab0d5678e64226shiqian static wchar_t wchar; 4177d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'b'; 4178d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 4179d201456903f3ecae1f7794edfab0d5678e64226shiqian "wchar"); 4180d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'\x8119'; 4181d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(L'\x8120', wchar), 4182d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: wchar"); 4183d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4184d201456903f3ecae1f7794edfab0d5678e64226shiqian 4185d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 4186d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 4187d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdString) { 4188d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has identical 4189d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4190d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ("Test", ::std::string("Test")); 4191d201456903f3ecae1f7794edfab0d5678e64226shiqian 4192d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::strings. 4193d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str1("A * in the middle"); 4194d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str2(str1); 4195d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(str1, str2); 4196d201456903f3ecae1f7794edfab0d5678e64226shiqian 4197d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has different 4198d201456903f3ecae1f7794edfab0d5678e64226shiqian // content 4199d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 4200d201456903f3ecae1f7794edfab0d5678e64226shiqian "::std::string(\"test\")"); 4201d201456903f3ecae1f7794edfab0d5678e64226shiqian 4202d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::string to a char* that has different content. 4203d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = const_cast<char*>("foo"); 4204d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 4205d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 4206d201456903f3ecae1f7794edfab0d5678e64226shiqian 4207d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::strings that have different contents, one of 4208d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. This should fail. 4209d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::std::string str3(str1); 4210d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4211d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 4212d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: str3\n" 4213d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"A \\0 in the middle\""); 4214d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4215d201456903f3ecae1f7794edfab0d5678e64226shiqian 4216d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 4217d201456903f3ecae1f7794edfab0d5678e64226shiqian 4218d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 4219d201456903f3ecae1f7794edfab0d5678e64226shiqian 4220d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 4221d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdWideString) { 4222d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has identical 4223d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4224d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8119"); 4225d201456903f3ecae1f7794edfab0d5678e64226shiqian 4226d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::wstrings. 4227d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr1(L"A * in the middle"); 4228d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr2(wstr1); 4229d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(wstr1, wstr2); 4230d201456903f3ecae1f7794edfab0d5678e64226shiqian 4231d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has different 4232d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4233d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4234d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8120"); 4235d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "L\"Test\\x8120\""); 4236d201456903f3ecae1f7794edfab0d5678e64226shiqian 4237d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::wstrings that have different contents, one of 4238d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. 4239d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring wstr3(wstr1); 4240d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4241d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 4242d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4243d201456903f3ecae1f7794edfab0d5678e64226shiqian 4244d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to an std::wstring that has different 4245d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4247d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 4248d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4249d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4250d201456903f3ecae1f7794edfab0d5678e64226shiqian 4251d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 4252d201456903f3ecae1f7794edfab0d5678e64226shiqian 4253d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 4254d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::string values in {EXPECT|ASSERT}_EQ. 4255d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalString) { 4256d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to a ::string that has identical content. 4257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ("Test", ::string("Test")); 4258d201456903f3ecae1f7794edfab0d5678e64226shiqian 4259d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::strings. 4260d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str1("A * in the middle"); 4261d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str2(str1); 4262d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(str1, str2); 4263d201456903f3ecae1f7794edfab0d5678e64226shiqian 4264d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a const char* that has different content. 4265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 4266d201456903f3ecae1f7794edfab0d5678e64226shiqian "test"); 4267d201456903f3ecae1f7794edfab0d5678e64226shiqian 4268d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::strings that have different contents, one of which 4269d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4270d201456903f3ecae1f7794edfab0d5678e64226shiqian ::string str3(str1); 4271d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4272d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 4273d201456903f3ecae1f7794edfab0d5678e64226shiqian "str3"); 4274d201456903f3ecae1f7794edfab0d5678e64226shiqian 4275d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a char* that has different content. 4276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4277d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 4278d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4279d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4280d201456903f3ecae1f7794edfab0d5678e64226shiqian 4281d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 4282d201456903f3ecae1f7794edfab0d5678e64226shiqian 4283d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_WSTRING 4284d201456903f3ecae1f7794edfab0d5678e64226shiqian 4285d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 4286d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalWideString) { 4287d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has identical content. 4288d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(L"Test\x8119", ::wstring(L"Test\x8119")); 4289d201456903f3ecae1f7794edfab0d5678e64226shiqian 4290d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::wstrings. 4291d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr1(L"A * in the middle"); 4292d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr2(wstr1); 4293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(wstr1, wstr2); 4294d201456903f3ecae1f7794edfab0d5678e64226shiqian 4295d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has different 4296d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4297d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4298d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L"Test\x8120", ::wstring(L"Test\x8119")); 4299d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Test\\x8119"); 4300d201456903f3ecae1f7794edfab0d5678e64226shiqian 4301d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to a ::wstring that has different content. 4302d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 4303d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 4304d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar"); 4305d201456903f3ecae1f7794edfab0d5678e64226shiqian 4306d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::wstrings that have different contents, one of which 4307d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4308d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::wstring wstr3; 4309d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3 = wstr1; 4310d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4311d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 4312d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4313d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4314d201456903f3ecae1f7794edfab0d5678e64226shiqian 4315d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 4316d201456903f3ecae1f7794edfab0d5678e64226shiqian 4317d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char pointers in {EXPECT|ASSERT}_EQ. 4318d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, CharPointer) { 4319d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4320d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4321d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4322d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4323d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4324d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4325d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4326d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4327d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p2 = reinterpret_cast<char*>(pv2); 4328d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(p1, p1); 4329d201456903f3ecae1f7794edfab0d5678e64226shiqian 4330d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4331d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4332d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4333d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4334d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 4335d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<char*>(0xABC0)), 4336d201456903f3ecae1f7794edfab0d5678e64226shiqian "ABC0"); 4337d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4338d201456903f3ecae1f7794edfab0d5678e64226shiqian 4339d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 4340d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideCharPointer) { 4341d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p0 = NULL; 4342d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4343d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4344d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4345d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4346d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4347d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4348d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 4349d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 4350d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(p0, p0); 4351d201456903f3ecae1f7794edfab0d5678e64226shiqian 4352d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4353d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4354d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4355d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4356d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv3 = (void*)0x1234; // NOLINT 4357d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv4 = (void*)0xABC0; // NOLINT 4358d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 4359d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 4360d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 4361d201456903f3ecae1f7794edfab0d5678e64226shiqian "p4"); 4362d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4363d201456903f3ecae1f7794edfab0d5678e64226shiqian 4364d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 4365d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, OtherPointer) { 4366d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(static_cast<const int*>(NULL), 4367d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<const int*>(NULL)); 4368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 4369d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<const int*>(0x1234)), 4370d201456903f3ecae1f7794edfab0d5678e64226shiqian "0x1234"); 4371d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4372d201456903f3ecae1f7794edfab0d5678e64226shiqian 4373d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the FRIEND_TEST macro. 4374d201456903f3ecae1f7794edfab0d5678e64226shiqian 4375d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class has a private member we want to test. We will test it 4376d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a TEST and in a TEST_F. 4377d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Foo { 4378d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4379d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo() {} 4380d201456903f3ecae1f7794edfab0d5678e64226shiqian 4381d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4382d201456903f3ecae1f7794edfab0d5678e64226shiqian int Bar() const { return 1; } 4383d201456903f3ecae1f7794edfab0d5678e64226shiqian 4384d201456903f3ecae1f7794edfab0d5678e64226shiqian // Declares the friend tests that can access the private member 4385d201456903f3ecae1f7794edfab0d5678e64226shiqian // Bar(). 4386d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test, TEST); 4387d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 4388d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4389d201456903f3ecae1f7794edfab0d5678e64226shiqian 4390d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST to access a 4391d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4392d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(FRIEND_TEST_Test, TEST) { 4393d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, Foo().Bar()); 4394d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4395d201456903f3ecae1f7794edfab0d5678e64226shiqian 4396d201456903f3ecae1f7794edfab0d5678e64226shiqian// The fixture needed to test using FRIEND_TEST with TEST_F. 43979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FRIEND_TEST_Test2 : public Test { 4398d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4399d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo foo; 4400d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4401d201456903f3ecae1f7794edfab0d5678e64226shiqian 4402d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 4403d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4404d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FRIEND_TEST_Test2, TEST_F) { 4405d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, foo.Bar()); 4406d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4407d201456903f3ecae1f7794edfab0d5678e64226shiqian 4408d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of Test objects. 4409d201456903f3ecae1f7794edfab0d5678e64226shiqian 4410d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing the life cycle of Test objects. 4411d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4412d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class counts the number of live test objects that uses this 4413d201456903f3ecae1f7794edfab0d5678e64226shiqian// fixture. 44149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestLifeCycleTest : public Test { 4415d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4416d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructor. Increments the number of test objects that uses 4417d201456903f3ecae1f7794edfab0d5678e64226shiqian // this fixture. 4418d201456903f3ecae1f7794edfab0d5678e64226shiqian TestLifeCycleTest() { count_++; } 4419d201456903f3ecae1f7794edfab0d5678e64226shiqian 4420d201456903f3ecae1f7794edfab0d5678e64226shiqian // Destructor. Decrements the number of test objects that uses this 4421d201456903f3ecae1f7794edfab0d5678e64226shiqian // fixture. 4422d201456903f3ecae1f7794edfab0d5678e64226shiqian ~TestLifeCycleTest() { count_--; } 4423d201456903f3ecae1f7794edfab0d5678e64226shiqian 4424d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the number of live test objects that uses this fixture. 4425d201456903f3ecae1f7794edfab0d5678e64226shiqian int count() const { return count_; } 4426d201456903f3ecae1f7794edfab0d5678e64226shiqian 4427d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4428d201456903f3ecae1f7794edfab0d5678e64226shiqian static int count_; 4429d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4430d201456903f3ecae1f7794edfab0d5678e64226shiqian 4431d201456903f3ecae1f7794edfab0d5678e64226shiqianint TestLifeCycleTest::count_ = 0; 4432d201456903f3ecae1f7794edfab0d5678e64226shiqian 4433d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4434d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test1) { 4435d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be only one test object in this test case that's 4436d201456903f3ecae1f7794edfab0d5678e64226shiqian // currently alive. 4437d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4438d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4439d201456903f3ecae1f7794edfab0d5678e64226shiqian 4440d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4441d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test2) { 4442d201456903f3ecae1f7794edfab0d5678e64226shiqian // After Test1 is done and Test2 is started, there should still be 4443d201456903f3ecae1f7794edfab0d5678e64226shiqian // only one live test object, as the object for Test1 should've been 4444d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 4445d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4446d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4447d201456903f3ecae1f7794edfab0d5678e64226shiqian 4448d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4449d201456903f3ecae1f7794edfab0d5678e64226shiqian 4450d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator << are 4451d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in the global namespace. 4452d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Base { 4453d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4454d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Base(int x) : x_(x) {} 4455d201456903f3ecae1f7794edfab0d5678e64226shiqian int x() const { return x_; } 4456d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4457d201456903f3ecae1f7794edfab0d5678e64226shiqian int x_; 4458d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4459d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4460d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base& val) { 4461d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4462d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4463d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4464d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base* pointer) { 4465d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4466d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4467d201456903f3ecae1f7794edfab0d5678e64226shiqian 4468d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 44699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4470d201456903f3ecae1f7794edfab0d5678e64226shiqian Base a(1); 4471d201456903f3ecae1f7794edfab0d5678e64226shiqian 4472d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 4473d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4474d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4475d201456903f3ecae1f7794edfab0d5678e64226shiqian 4476d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4477d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in an unnamed namespace. 4478d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 4479d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInUnnamedNameSpace : public Base { 4480d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4481d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInUnnamedNameSpace(int x): Base(x) {} 4482d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4483d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4484d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace& val) { 4485d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4486d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4487d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4488d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace* pointer) { 4489d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4490d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4491d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4492d201456903f3ecae1f7794edfab0d5678e64226shiqian 4493d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 44949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4495d201456903f3ecae1f7794edfab0d5678e64226shiqian MyTypeInUnnamedNameSpace a(1); 4496d201456903f3ecae1f7794edfab0d5678e64226shiqian 4497d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses <unnamed_namespace>::operator<<. 4498d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4499d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4500d201456903f3ecae1f7794edfab0d5678e64226shiqian 4501d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4502d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a user namespace. 4503d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace1 { 4504d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace1 : public Base { 4505d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4506d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace1(int x): Base(x) {} 4507d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4508d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4509d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1& val) { 4510d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4511d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4512d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4513d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1* pointer) { 4514d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4515d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4516d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace1 4517d201456903f3ecae1f7794edfab0d5678e64226shiqian 4518d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 45199b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4520d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace1::MyTypeInNameSpace1 a(1); 4521d201456903f3ecae1f7794edfab0d5678e64226shiqian 4522d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses namespace1::operator<<. 4523d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4524d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4525d201456903f3ecae1f7794edfab0d5678e64226shiqian 4526d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition is in a user namespace 4527d201456903f3ecae1f7794edfab0d5678e64226shiqian// but whose operator<< is in the global namespace. 4528d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace2 { 4529d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace2 : public ::Base { 4530d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4531d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace2(int x): Base(x) {} 4532d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4533d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace2 4534d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4535d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2& val) { 4536d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4537d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4538d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4539d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2* pointer) { 4540d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4541d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4542d201456903f3ecae1f7794edfab0d5678e64226shiqian 4543d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 45449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4545d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace2::MyTypeInNameSpace2 a(1); 4546d201456903f3ecae1f7794edfab0d5678e64226shiqian 4547d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 4548d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4549d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4550d201456903f3ecae1f7794edfab0d5678e64226shiqian 4551d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming NULL pointers to testing::Message. 4552d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, NullPointers) { 45539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4554d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = NULL; 4555d201456903f3ecae1f7794edfab0d5678e64226shiqian unsigned char* const p2 = NULL; 4556d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p3 = NULL; 4557d201456903f3ecae1f7794edfab0d5678e64226shiqian double* p4 = NULL; 4558d201456903f3ecae1f7794edfab0d5678e64226shiqian bool* p5 = NULL; 45599b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message* p6 = NULL; 4560d201456903f3ecae1f7794edfab0d5678e64226shiqian 4561d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << p1 << p2 << p3 << p4 << p5 << p6; 4562d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 4563d201456903f3ecae1f7794edfab0d5678e64226shiqian msg.GetString().c_str()); 4564d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4565d201456903f3ecae1f7794edfab0d5678e64226shiqian 4566d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming wide strings to testing::Message. 4567d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, WideStrings) { 4568d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type const wchar_t*. 4569d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* const_wstr = NULL; 4570d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 4571d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 4572d201456903f3ecae1f7794edfab0d5678e64226shiqian 4573d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type wchar_t*. 4574d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* wstr = NULL; 4575d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 4576d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 4577d201456903f3ecae1f7794edfab0d5678e64226shiqian 4578d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type const wchar_t*. 4579d201456903f3ecae1f7794edfab0d5678e64226shiqian const_wstr = L"abc\x8119"; 4580d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 4581d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 4582d201456903f3ecae1f7794edfab0d5678e64226shiqian 4583d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type wchar_t*. 4584d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr = const_cast<wchar_t*>(const_wstr); 4585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 4586d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 4587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4588d201456903f3ecae1f7794edfab0d5678e64226shiqian 4589d201456903f3ecae1f7794edfab0d5678e64226shiqian 4590d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in the testing namespace. 4591d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 4592d201456903f3ecae1f7794edfab0d5678e64226shiqian 4593d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestInfo class. 4594d201456903f3ecae1f7794edfab0d5678e64226shiqian 45959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestInfoTest : public Test { 4596d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4597b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan static const TestInfo* GetTestInfo(const char* test_name) { 4598b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestCase* const test_case = GetUnitTestImpl()-> 4599b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetTestCase("TestInfoTest", "", NULL, NULL); 4600b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 4601b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan for (int i = 0; i < test_case->total_test_count(); ++i) { 4602b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = test_case->GetTestInfo(i); 4603b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan if (strcmp(test_name, test_info->name()) == 0) 4604b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return test_info; 4605b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 4606b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return NULL; 4607d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4608d201456903f3ecae1f7794edfab0d5678e64226shiqian 4609d201456903f3ecae1f7794edfab0d5678e64226shiqian static const TestResult* GetTestResult( 46109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const TestInfo* test_info) { 4611d201456903f3ecae1f7794edfab0d5678e64226shiqian return test_info->result(); 4612d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4613d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4614d201456903f3ecae1f7794edfab0d5678e64226shiqian 4615d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::test_case_name() and TestInfo::name(). 4616d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, Names) { 4617b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("Names"); 4618d201456903f3ecae1f7794edfab0d5678e64226shiqian 4619d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 4620d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("Names", test_info->name()); 4621d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4622d201456903f3ecae1f7794edfab0d5678e64226shiqian 4623d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::result(). 4624d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, result) { 4625b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("result"); 4626d201456903f3ecae1f7794edfab0d5678e64226shiqian 4627d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initially, there is no TestPartResult for this test. 4628b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 4629d201456903f3ecae1f7794edfab0d5678e64226shiqian 4630d201456903f3ecae1f7794edfab0d5678e64226shiqian // After the previous assertion, there is still none. 4631b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 4632d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4633d201456903f3ecae1f7794edfab0d5678e64226shiqian 4634d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests setting up and tearing down a test case. 4635d201456903f3ecae1f7794edfab0d5678e64226shiqian 46369b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SetUpTestCaseTest : public Test { 4637d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4638d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once before the first test in this test case 4639d201456903f3ecae1f7794edfab0d5678e64226shiqian // is run. 4640d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 4641d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Setting up the test case . . .\n"); 4642d201456903f3ecae1f7794edfab0d5678e64226shiqian 4643d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initializes some shared resource. In this simple example, we 4644d201456903f3ecae1f7794edfab0d5678e64226shiqian // just create a C string. More complex stuff can be done if 4645d201456903f3ecae1f7794edfab0d5678e64226shiqian // desired. 4646d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = "123"; 4647d201456903f3ecae1f7794edfab0d5678e64226shiqian 4648d201456903f3ecae1f7794edfab0d5678e64226shiqian // Increments the number of test cases that have been set up. 4649d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_++; 4650d201456903f3ecae1f7794edfab0d5678e64226shiqian 4651d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once. 4652d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 4653d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4654d201456903f3ecae1f7794edfab0d5678e64226shiqian 4655d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once after the last test in this test case is 4656d201456903f3ecae1f7794edfab0d5678e64226shiqian // run. 4657d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 4658d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Tearing down the test case . . .\n"); 4659d201456903f3ecae1f7794edfab0d5678e64226shiqian 4660d201456903f3ecae1f7794edfab0d5678e64226shiqian // Decrements the number of test cases that have been set up. 4661d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_--; 4662d201456903f3ecae1f7794edfab0d5678e64226shiqian 4663d201456903f3ecae1f7794edfab0d5678e64226shiqian // TearDownTestCase() should be called only once. 4664d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, counter_); 4665d201456903f3ecae1f7794edfab0d5678e64226shiqian 4666d201456903f3ecae1f7794edfab0d5678e64226shiqian // Cleans up the shared resource. 4667d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = NULL; 4668d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4669d201456903f3ecae1f7794edfab0d5678e64226shiqian 4670d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called before each test in this test case. 4671d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 4672d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once, so counter_ should 4673d201456903f3ecae1f7794edfab0d5678e64226shiqian // always be 1. 4674d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 4675d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4676d201456903f3ecae1f7794edfab0d5678e64226shiqian 4677d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of test cases that have been set up. 4678d201456903f3ecae1f7794edfab0d5678e64226shiqian static int counter_; 4679d201456903f3ecae1f7794edfab0d5678e64226shiqian 4680d201456903f3ecae1f7794edfab0d5678e64226shiqian // Some resource to be shared by all tests in this test case. 4681d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* shared_resource_; 4682d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4683d201456903f3ecae1f7794edfab0d5678e64226shiqian 4684d201456903f3ecae1f7794edfab0d5678e64226shiqianint SetUpTestCaseTest::counter_ = 0; 4685d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SetUpTestCaseTest::shared_resource_ = NULL; 4686d201456903f3ecae1f7794edfab0d5678e64226shiqian 4687d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test that uses the shared resource. 4688d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test1) { 4689d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(NULL, shared_resource_); 4690d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4691d201456903f3ecae1f7794edfab0d5678e64226shiqian 4692d201456903f3ecae1f7794edfab0d5678e64226shiqian// Another test that uses the shared resource. 4693d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test2) { 4694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("123", shared_resource_); 4695d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4696d201456903f3ecae1f7794edfab0d5678e64226shiqian 4697d201456903f3ecae1f7794edfab0d5678e64226shiqian// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 4698d201456903f3ecae1f7794edfab0d5678e64226shiqian 4699d201456903f3ecae1f7794edfab0d5678e64226shiqian// The Flags struct stores a copy of all Google Test flags. 4700d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct Flags { 4701d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs a Flags struct where each flag has its default value. 4702fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags() : also_run_disabled_tests(false), 4703fe186c382905dcf57014985ccea8e067275e9f5fshiqian break_on_failure(false), 4704d201456903f3ecae1f7794edfab0d5678e64226shiqian catch_exceptions(false), 470553e0dc4041f660b6517b15b08b496e164be614f1shiqian death_test_use_fork(false), 4706d201456903f3ecae1f7794edfab0d5678e64226shiqian filter(""), 4707d201456903f3ecae1f7794edfab0d5678e64226shiqian list_tests(false), 4708d201456903f3ecae1f7794edfab0d5678e64226shiqian output(""), 4709f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan print_time(true), 47108bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan random_seed(0), 471140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan repeat(1), 47128bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan shuffle(false), 471340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan throw_on_failure(false) {} 4714d201456903f3ecae1f7794edfab0d5678e64226shiqian 4715d201456903f3ecae1f7794edfab0d5678e64226shiqian // Factory methods. 4716d201456903f3ecae1f7794edfab0d5678e64226shiqian 4717fe186c382905dcf57014985ccea8e067275e9f5fshiqian // Creates a Flags struct where the gtest_also_run_disabled_tests flag has 4718fe186c382905dcf57014985ccea8e067275e9f5fshiqian // the given value. 4719fe186c382905dcf57014985ccea8e067275e9f5fshiqian static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { 4720fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags flags; 4721fe186c382905dcf57014985ccea8e067275e9f5fshiqian flags.also_run_disabled_tests = also_run_disabled_tests; 4722fe186c382905dcf57014985ccea8e067275e9f5fshiqian return flags; 4723fe186c382905dcf57014985ccea8e067275e9f5fshiqian } 4724fe186c382905dcf57014985ccea8e067275e9f5fshiqian 4725d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_break_on_failure flag has 4726d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 4727d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags BreakOnFailure(bool break_on_failure) { 4728d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4729d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = break_on_failure; 4730d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4731d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4732d201456903f3ecae1f7794edfab0d5678e64226shiqian 4733d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_catch_exceptions flag has 4734d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 4735d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags CatchExceptions(bool catch_exceptions) { 4736d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4737d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.catch_exceptions = catch_exceptions; 4738d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4739d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4740d201456903f3ecae1f7794edfab0d5678e64226shiqian 474153e0dc4041f660b6517b15b08b496e164be614f1shiqian // Creates a Flags struct where the gtest_death_test_use_fork flag has 474253e0dc4041f660b6517b15b08b496e164be614f1shiqian // the given value. 474353e0dc4041f660b6517b15b08b496e164be614f1shiqian static Flags DeathTestUseFork(bool death_test_use_fork) { 474453e0dc4041f660b6517b15b08b496e164be614f1shiqian Flags flags; 474553e0dc4041f660b6517b15b08b496e164be614f1shiqian flags.death_test_use_fork = death_test_use_fork; 474653e0dc4041f660b6517b15b08b496e164be614f1shiqian return flags; 474753e0dc4041f660b6517b15b08b496e164be614f1shiqian } 474853e0dc4041f660b6517b15b08b496e164be614f1shiqian 4749d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_filter flag has the given 4750d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4751d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Filter(const char* filter) { 4752d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4753d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = filter; 4754d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4755d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4756d201456903f3ecae1f7794edfab0d5678e64226shiqian 4757d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_list_tests flag has the 4758d201456903f3ecae1f7794edfab0d5678e64226shiqian // given value. 4759d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags ListTests(bool list_tests) { 4760d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4761d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.list_tests = list_tests; 4762d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4763d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4764d201456903f3ecae1f7794edfab0d5678e64226shiqian 4765d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_output flag has the given 4766d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4767d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Output(const char* output) { 4768d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4769d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.output = output; 4770d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4771d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4772d201456903f3ecae1f7794edfab0d5678e64226shiqian 477315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // Creates a Flags struct where the gtest_print_time flag has the given 477415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // value. 477515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian static Flags PrintTime(bool print_time) { 477615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian Flags flags; 477715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian flags.print_time = print_time; 477815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian return flags; 477915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian } 478015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 47818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_random_seed flag has 47828bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 47838bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags RandomSeed(Int32 random_seed) { 47848bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 47858bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.random_seed = random_seed; 47868bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 47878bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 47888bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 4789d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_repeat flag has the given 4790d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4791d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Repeat(Int32 repeat) { 4792d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4793d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.repeat = repeat; 4794d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4795d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4796d201456903f3ecae1f7794edfab0d5678e64226shiqian 47978bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_shuffle flag has 47988bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 47998bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags Shuffle(bool shuffle) { 48008bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 48018bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.shuffle = shuffle; 48028bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 48038bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 48048bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 480540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // Creates a Flags struct where the gtest_throw_on_failure flag has 480640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // the given value. 480740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan static Flags ThrowOnFailure(bool throw_on_failure) { 480840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan Flags flags; 480940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan flags.throw_on_failure = throw_on_failure; 481040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan return flags; 481140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan } 481240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 4813d201456903f3ecae1f7794edfab0d5678e64226shiqian // These fields store the flag values. 4814fe186c382905dcf57014985ccea8e067275e9f5fshiqian bool also_run_disabled_tests; 4815d201456903f3ecae1f7794edfab0d5678e64226shiqian bool break_on_failure; 4816d201456903f3ecae1f7794edfab0d5678e64226shiqian bool catch_exceptions; 481753e0dc4041f660b6517b15b08b496e164be614f1shiqian bool death_test_use_fork; 4818d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* filter; 4819d201456903f3ecae1f7794edfab0d5678e64226shiqian bool list_tests; 4820d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* output; 482115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian bool print_time; 48228bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Int32 random_seed; 4823d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 repeat; 48248bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan bool shuffle; 482540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan bool throw_on_failure; 4826d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4827d201456903f3ecae1f7794edfab0d5678e64226shiqian 4828d201456903f3ecae1f7794edfab0d5678e64226shiqian// Fixture for testing InitGoogleTest(). 48299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass InitGoogleTestTest : public Test { 4830d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4831d201456903f3ecae1f7794edfab0d5678e64226shiqian // Clears the flags before each test. 4832d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 4833fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 4834d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(break_on_failure) = false; 4835d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(catch_exceptions) = false; 483653e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 4837d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(filter) = ""; 4838d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(list_tests) = false; 4839d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(output) = ""; 4840f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 48418bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 4842d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(repeat) = 1; 48438bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 484440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 4845d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4846d201456903f3ecae1f7794edfab0d5678e64226shiqian 4847d201456903f3ecae1f7794edfab0d5678e64226shiqian // Asserts that two narrow or wide string arrays are equal. 4848d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 4849d201456903f3ecae1f7794edfab0d5678e64226shiqian static void AssertStringArrayEq(size_t size1, CharType** array1, 4850d201456903f3ecae1f7794edfab0d5678e64226shiqian size_t size2, CharType** array2) { 4851d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(size1, size2) << " Array sizes different."; 4852d201456903f3ecae1f7794edfab0d5678e64226shiqian 4853d201456903f3ecae1f7794edfab0d5678e64226shiqian for (size_t i = 0; i != size1; i++) { 4854d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 4855d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4856d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4857d201456903f3ecae1f7794edfab0d5678e64226shiqian 4858d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the flag values match the expected values. 4859d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CheckFlags(const Flags& expected) { 4860fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_EQ(expected.also_run_disabled_tests, 4861fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests)); 4862d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 4863d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 486453e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork)); 4865d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 4866d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 4867d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 486815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 48698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed)); 4870d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 48718bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle)); 487240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure)); 4873d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4874d201456903f3ecae1f7794edfab0d5678e64226shiqian 4875d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses a command line (specified by argc1 and argv1), then 4876d201456903f3ecae1f7794edfab0d5678e64226shiqian // verifies that the flag values are expected and that the 4877d201456903f3ecae1f7794edfab0d5678e64226shiqian // recognized flags are removed from the command line. 4878d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 4879d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TestParsingFlags(int argc1, const CharType** argv1, 4880d201456903f3ecae1f7794edfab0d5678e64226shiqian int argc2, const CharType** argv2, 4881d201456903f3ecae1f7794edfab0d5678e64226shiqian const Flags& expected) { 4882d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses the command line. 48831998cf5d32a19aaffe8652545802744d9133022dvladlosev internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); 4884d201456903f3ecae1f7794edfab0d5678e64226shiqian 4885d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies the flag values. 4886d201456903f3ecae1f7794edfab0d5678e64226shiqian CheckFlags(expected); 4887d201456903f3ecae1f7794edfab0d5678e64226shiqian 4888d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the recognized flags are removed from the command 4889d201456903f3ecae1f7794edfab0d5678e64226shiqian // line. 4890d201456903f3ecae1f7794edfab0d5678e64226shiqian AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 4891d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4892d201456903f3ecae1f7794edfab0d5678e64226shiqian 4893d201456903f3ecae1f7794edfab0d5678e64226shiqian // This macro wraps TestParsingFlags s.t. the user doesn't need 4894d201456903f3ecae1f7794edfab0d5678e64226shiqian // to specify the array sizes. 48950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected) \ 4896d201456903f3ecae1f7794edfab0d5678e64226shiqian TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 4897d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected) 4898d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4899d201456903f3ecae1f7794edfab0d5678e64226shiqian 4900d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty command line. 4901d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Empty) { 4902d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4903d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4904d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4905d201456903f3ecae1f7794edfab0d5678e64226shiqian 4906d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4907d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4908d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4909d201456903f3ecae1f7794edfab0d5678e64226shiqian 49100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 4911d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4912d201456903f3ecae1f7794edfab0d5678e64226shiqian 4913d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a command line that has no flag. 4914d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, NoFlag) { 4915d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4916d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4917d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4918d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4919d201456903f3ecae1f7794edfab0d5678e64226shiqian 4920d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4921d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4922d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4923d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4924d201456903f3ecae1f7794edfab0d5678e64226shiqian 49250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 4926d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4927d201456903f3ecae1f7794edfab0d5678e64226shiqian 4928d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a bad --gtest_filter flag. 4929d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterBad) { 4930d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4931d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4932d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 4933d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4934d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4935d201456903f3ecae1f7794edfab0d5678e64226shiqian 4936d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4937d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4938d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 4939d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4940d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4941d201456903f3ecae1f7794edfab0d5678e64226shiqian 49420af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("")); 4943d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4944d201456903f3ecae1f7794edfab0d5678e64226shiqian 4945d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty --gtest_filter flag. 4946d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterEmpty) { 4947d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4948d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4949d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=", 4950d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4951d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4952d201456903f3ecae1f7794edfab0d5678e64226shiqian 4953d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4954d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4955d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4956d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4957d201456903f3ecae1f7794edfab0d5678e64226shiqian 49580af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("")); 4959d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4960d201456903f3ecae1f7794edfab0d5678e64226shiqian 4961d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a non-empty --gtest_filter flag. 4962d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterNonEmpty) { 4963d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4964d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4965d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=abc", 4966d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4967d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4968d201456903f3ecae1f7794edfab0d5678e64226shiqian 4969d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4970d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4971d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4972d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4973d201456903f3ecae1f7794edfab0d5678e64226shiqian 49740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc")); 4975d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4976d201456903f3ecae1f7794edfab0d5678e64226shiqian 4977d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure. 49788bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) { 4979d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4980d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4981d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 4982d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4983d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4984d201456903f3ecae1f7794edfab0d5678e64226shiqian 4985d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4986d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4987d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4988d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4989d201456903f3ecae1f7794edfab0d5678e64226shiqian 49900af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true)); 4991d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4992d201456903f3ecae1f7794edfab0d5678e64226shiqian 4993d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=0. 4994d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 4995d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4996d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4997d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=0", 4998d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4999d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5000d201456903f3ecae1f7794edfab0d5678e64226shiqian 5001d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5002d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5003d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5004d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5005d201456903f3ecae1f7794edfab0d5678e64226shiqian 50060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 5007d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5008d201456903f3ecae1f7794edfab0d5678e64226shiqian 5009d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=f. 5010d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 5011d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5012d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5013d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=f", 5014d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5015d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5016d201456903f3ecae1f7794edfab0d5678e64226shiqian 5017d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5018d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5019d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5020d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5021d201456903f3ecae1f7794edfab0d5678e64226shiqian 50220af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 5023d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5024d201456903f3ecae1f7794edfab0d5678e64226shiqian 5025d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 5026d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 5027d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5028d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5029d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=F", 5030d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5031d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5032d201456903f3ecae1f7794edfab0d5678e64226shiqian 5033d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5034d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5035d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5036d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5037d201456903f3ecae1f7794edfab0d5678e64226shiqian 50380af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 5039d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5040d201456903f3ecae1f7794edfab0d5678e64226shiqian 5041d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a --gtest_break_on_failure flag that has a "true" 5042d201456903f3ecae1f7794edfab0d5678e64226shiqian// definition. 5043d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 5044d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5045d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5046d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=1", 5047d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5048d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5049d201456903f3ecae1f7794edfab0d5678e64226shiqian 5050d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5051d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5052d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5053d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5054d201456903f3ecae1f7794edfab0d5678e64226shiqian 50550af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true)); 5056d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5057d201456903f3ecae1f7794edfab0d5678e64226shiqian 5058d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_catch_exceptions. 5059d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, CatchExceptions) { 5060d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5061d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5062d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_catch_exceptions", 5063d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5064d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5065d201456903f3ecae1f7794edfab0d5678e64226shiqian 5066d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5067d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5068d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5069d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5070d201456903f3ecae1f7794edfab0d5678e64226shiqian 50710af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true)); 5072d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5073d201456903f3ecae1f7794edfab0d5678e64226shiqian 507453e0dc4041f660b6517b15b08b496e164be614f1shiqian// Tests parsing --gtest_death_test_use_fork. 507553e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(InitGoogleTestTest, DeathTestUseFork) { 507653e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv[] = { 507753e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 507853e0dc4041f660b6517b15b08b496e164be614f1shiqian "--gtest_death_test_use_fork", 507953e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 508053e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 508153e0dc4041f660b6517b15b08b496e164be614f1shiqian 508253e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv2[] = { 508353e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 508453e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 508553e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 508653e0dc4041f660b6517b15b08b496e164be614f1shiqian 50870af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true)); 508853e0dc4041f660b6517b15b08b496e164be614f1shiqian} 508953e0dc4041f660b6517b15b08b496e164be614f1shiqian 5090d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having the same flag twice with different values. The 5091d201456903f3ecae1f7794edfab0d5678e64226shiqian// expected behavior is that the one coming last takes precedence. 5092d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, DuplicatedFlags) { 5093d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5094d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5095d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=a", 5096d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5097d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5098d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5099d201456903f3ecae1f7794edfab0d5678e64226shiqian 5100d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5101d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5102d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5103d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5104d201456903f3ecae1f7794edfab0d5678e64226shiqian 51050af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b")); 5106d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5107d201456903f3ecae1f7794edfab0d5678e64226shiqian 5108d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having an unrecognized flag on the command line. 5109d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 5110d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5111d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5112d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 5113d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", // Unrecognized by Google Test. 5114d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5115d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5116d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5117d201456903f3ecae1f7794edfab0d5678e64226shiqian 5118d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5119d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5120d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", 5121d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5122d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5123d201456903f3ecae1f7794edfab0d5678e64226shiqian 5124d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5125d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = true; 5126d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = "b"; 51270af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags); 5128d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5129d201456903f3ecae1f7794edfab0d5678e64226shiqian 5130d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag 5131d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFlag) { 5132d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5133d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5134d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests", 5135d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5136d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5137d201456903f3ecae1f7794edfab0d5678e64226shiqian 5138d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5139d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5140d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5141d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5142d201456903f3ecae1f7794edfab0d5678e64226shiqian 51430af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true)); 5144d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5145d201456903f3ecae1f7794edfab0d5678e64226shiqian 5146d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "true" value 5147d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsTrue) { 5148d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5149d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5150d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=1", 5151d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5152d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5153d201456903f3ecae1f7794edfab0d5678e64226shiqian 5154d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5155d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5156d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5157d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5158d201456903f3ecae1f7794edfab0d5678e64226shiqian 51590af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true)); 5160d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5161d201456903f3ecae1f7794edfab0d5678e64226shiqian 5162d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "false" value 5163d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse) { 5164d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5165d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5166d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=0", 5167d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5168d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5169d201456903f3ecae1f7794edfab0d5678e64226shiqian 5170d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5171d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5172d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5173d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5174d201456903f3ecae1f7794edfab0d5678e64226shiqian 51750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 5176d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5177d201456903f3ecae1f7794edfab0d5678e64226shiqian 5178d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_list_tests=f. 5179d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 5180d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5181d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5182d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=f", 5183d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5184d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5185d201456903f3ecae1f7794edfab0d5678e64226shiqian 5186d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5187d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5188d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5189d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5190d201456903f3ecae1f7794edfab0d5678e64226shiqian 51910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 5192d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5193d201456903f3ecae1f7794edfab0d5678e64226shiqian 51948bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_list_tests=F. 5195d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 5196d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5197d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5198d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=F", 5199d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5200d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5201d201456903f3ecae1f7794edfab0d5678e64226shiqian 5202d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5203d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5204d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5205d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5206d201456903f3ecae1f7794edfab0d5678e64226shiqian 52070af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 5208d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5209d201456903f3ecae1f7794edfab0d5678e64226shiqian 5210d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output (invalid). 5211d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputEmpty) { 5212d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5213d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5214d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 5215d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5216d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5217d201456903f3ecae1f7794edfab0d5678e64226shiqian 5218d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5219d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5220d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 5221d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5222d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5223d201456903f3ecae1f7794edfab0d5678e64226shiqian 52240af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 5225d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5226d201456903f3ecae1f7794edfab0d5678e64226shiqian 5227d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml 5228d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXml) { 5229d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5230d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5231d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml", 5232d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5233d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5234d201456903f3ecae1f7794edfab0d5678e64226shiqian 5235d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5236d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5237d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5238d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5239d201456903f3ecae1f7794edfab0d5678e64226shiqian 52400af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml")); 5241d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5242d201456903f3ecae1f7794edfab0d5678e64226shiqian 5243d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:file 5244d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlFile) { 5245d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5246d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5247d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:file", 5248d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5249d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5250d201456903f3ecae1f7794edfab0d5678e64226shiqian 5251d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5252d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5253d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5254d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5255d201456903f3ecae1f7794edfab0d5678e64226shiqian 52560af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file")); 5257d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5258d201456903f3ecae1f7794edfab0d5678e64226shiqian 5259d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:directory/path/ 5260d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 5261d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5262d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5263d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:directory/path/", 5264d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5265d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5266d201456903f3ecae1f7794edfab0d5678e64226shiqian 5267d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5268d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5269d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5270d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5271d201456903f3ecae1f7794edfab0d5678e64226shiqian 52720af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/")); 5273d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5274d201456903f3ecae1f7794edfab0d5678e64226shiqian 527515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag 527615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFlag) { 527715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 527815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 527915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time", 528015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 528115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 528215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 528315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 528415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 528515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 528615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 528715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 52880af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true)); 528915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 529015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 529115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "true" value 529215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeTrue) { 529315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 529415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 529515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=1", 529615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 529715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 529815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 529915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 530015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 530115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 530215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 530315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 53040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true)); 530515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 530615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 530715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "false" value 530815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse) { 530915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 531015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 531115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=0", 531215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 531315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 531415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 531515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 531615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 531715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 531815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 531915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 53200af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 532115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 532215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 532315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=f. 532415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 532515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 532615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 532715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=f", 532815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 532915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 533015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 533115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 533215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 533315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 533415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 533515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 53360af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 533715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 533815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 533915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=F. 534015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 534115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 534215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 534315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=F", 534415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 534515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 534615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 534715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 534815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 534915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 535015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 535115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 53520af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 535315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 535415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 53558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_random_seed=number 53568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, RandomSeed) { 53578bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 53588bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 53598bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_random_seed=1000", 53608bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 53618bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 53628bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 53638bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 53648bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 53658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 53668bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 53678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 53688bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000)); 53698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 53708bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5371d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_repeat=number 5372d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Repeat) { 5373d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5374d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5375d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_repeat=1000", 5376d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5377d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5378d201456903f3ecae1f7794edfab0d5678e64226shiqian 5379d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5380d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5381d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5382d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5383d201456903f3ecae1f7794edfab0d5678e64226shiqian 53840af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000)); 5385d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5386d201456903f3ecae1f7794edfab0d5678e64226shiqian 5387fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag 5388fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { 5389fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5390fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5391fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests", 5392fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5393fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5394fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5395fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5396fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5397fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5398fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5399fe186c382905dcf57014985ccea8e067275e9f5fshiqian 54000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true)); 5401fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5402fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5403fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "true" value 5404fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { 5405fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5406fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5407fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=1", 5408fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5409fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5410fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5411fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5412fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5413fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5414fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5415fe186c382905dcf57014985ccea8e067275e9f5fshiqian 54160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true)); 5417fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5418fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5419fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "false" value 5420fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { 5421fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5422fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5423fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=0", 5424fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5425fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5426fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5427fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5428fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5429fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5430fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5431fe186c382905dcf57014985ccea8e067275e9f5fshiqian 54320af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false)); 5433fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5434fe186c382905dcf57014985ccea8e067275e9f5fshiqian 54358bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle. 54368bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleWithoutValue) { 54378bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 54388bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54398bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle", 54408bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54418bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan}; 54428bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54438bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 54448bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54458bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54468bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 54478bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54488bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true)); 54498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 54508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle=0. 54528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleFalse_0) { 54538bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 54548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=0", 54568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54578bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 54588bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54598bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 54608bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54618bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54628bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 54638bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54648bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false)); 54658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 54668bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing a --gtest_shuffle flag that has a "true" 54688bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// definition. 54698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleTrue) { 54708bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 54718bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54728bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=1", 54738bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 54758bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54768bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 54778bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 54788bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 54798bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 54808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 54818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true)); 54828bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 548340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 548440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure. 54858bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) { 548640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 548740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 548840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure", 548940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 549040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan}; 549140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 549240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 549340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 549440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 549540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 549640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 549740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true)); 549840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 549940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 550040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure=0. 550140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { 550240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 550340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 550440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=0", 550540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 550640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 550740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 550840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 550940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 551040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 551140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 551240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 551340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false)); 551440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 551540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 551640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing a --gtest_throw_on_failure flag that has a "true" 551740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// definition. 551840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { 551940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 552040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 552140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=1", 552240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 552340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 552440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 552540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 552640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 552740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 552840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 552940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 553040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true)); 553140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 553240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 55330af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 5534d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing wide strings. 5535d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, WideStrings) { 5536d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv[] = { 5537d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 5538d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_filter=Foo*", 5539d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_list_tests=1", 5540d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_break_on_failure", 5541d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 5542d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5543d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5544d201456903f3ecae1f7794edfab0d5678e64226shiqian 5545d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv2[] = { 5546d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 5547d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 5548d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5549d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5550d201456903f3ecae1f7794edfab0d5678e64226shiqian 5551d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags expected_flags; 5552d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.break_on_failure = true; 5553d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.filter = "Foo*"; 5554d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.list_tests = true; 5555d201456903f3ecae1f7794edfab0d5678e64226shiqian 55560af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags); 5557d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5558d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 5559d201456903f3ecae1f7794edfab0d5678e64226shiqian 5560d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests current_test_info() in UnitTest. 5561d201456903f3ecae1f7794edfab0d5678e64226shiqianclass CurrentTestInfoTest : public Test { 5562d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5563d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL before the first test in 5564d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case is run. 5565d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 5566d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be no tests running at this point. 5567d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5568d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5569e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 5570d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 5571d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5572d201456903f3ecae1f7794edfab0d5678e64226shiqian 5573d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL after the last test in 5574d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case has run. 5575d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 5576d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5577d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5578e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 5579d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 5580d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5581d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5582d201456903f3ecae1f7794edfab0d5678e64226shiqian 5583d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 5584d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. 5585d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 5586d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5587d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5588d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 5589d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 5590d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 5591d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 5592d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 5593d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 5594d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5595d201456903f3ecae1f7794edfab0d5678e64226shiqian 5596d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 5597d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. We 5598d201456903f3ecae1f7794edfab0d5678e64226shiqian// use this test to see that the TestInfo object actually changed from 5599d201456903f3ecae1f7794edfab0d5678e64226shiqian// the previous invocation. 5600d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 5601d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5602d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5603d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 5604d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 5605d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 5606d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 5607d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 5608d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 5609d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5610d201456903f3ecae1f7794edfab0d5678e64226shiqian 5611d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 5612d201456903f3ecae1f7794edfab0d5678e64226shiqian 5613d201456903f3ecae1f7794edfab0d5678e64226shiqian// These two lines test that we can define tests in a namespace that 5614d201456903f3ecae1f7794edfab0d5678e64226shiqian// has the name "testing" and is nested in another namespace. 5615d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace my_namespace { 5616d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 5617d201456903f3ecae1f7794edfab0d5678e64226shiqian 5618d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that TEST knows to use ::testing::Test instead of 5619d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Test. 5620d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Test {}; 5621d201456903f3ecae1f7794edfab0d5678e64226shiqian 5622d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use ::testing::Message instead of 5623d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Message. 5624d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message {}; 5625d201456903f3ecae1f7794edfab0d5678e64226shiqian 5626d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use 5627d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::testing::AssertionResult instead of 5628d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::AssertionResult. 5629d201456903f3ecae1f7794edfab0d5678e64226shiqianclass AssertionResult {}; 5630d201456903f3ecae1f7794edfab0d5678e64226shiqian 5631d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should succeed works as expected. 5632d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Success) { 5633d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "This shouldn't fail."; 5634d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5635d201456903f3ecae1f7794edfab0d5678e64226shiqian 5636d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should fail works as expected. 5637d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Failure) { 5638d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 5639d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is expected."); 5640d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5641d201456903f3ecae1f7794edfab0d5678e64226shiqian 5642d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 5643d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace my_namespace 5644d201456903f3ecae1f7794edfab0d5678e64226shiqian 5645d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that one can call superclass SetUp and TearDown methods-- 5646d201456903f3ecae1f7794edfab0d5678e64226shiqian// that is, that they are not private. 5647d201456903f3ecae1f7794edfab0d5678e64226shiqian// No tests are based on this fixture; the test "passes" if it compiles 5648d201456903f3ecae1f7794edfab0d5678e64226shiqian// successfully. 56499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass ProtectedFixtureMethodsTest : public Test { 5650d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5651d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 56529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::SetUp(); 5653d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5654d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 56559b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::TearDown(); 5656d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5657d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5658d201456903f3ecae1f7794edfab0d5678e64226shiqian 5659d201456903f3ecae1f7794edfab0d5678e64226shiqian// StreamingAssertionsTest tests the streaming versions of a representative 5660d201456903f3ecae1f7794edfab0d5678e64226shiqian// sample of assertions. 5661d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Unconditional) { 5662d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "expected success"; 5663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 5664d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 5666d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5667d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5668d201456903f3ecae1f7794edfab0d5678e64226shiqian 5669c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 5670c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 5671c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 5672c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 5673c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 5674d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth) { 5675d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true) << "unexpected failure"; 5676d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true) << "unexpected failure"; 5677d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 5678d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5679d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 5680d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5681d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5682d201456903f3ecae1f7794edfab0d5678e64226shiqian 5683d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth2) { 5684d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "unexpected failure"; 5685d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(false) << "unexpected failure"; 5686d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 5687d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5688d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 5689d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5690d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5691d201456903f3ecae1f7794edfab0d5678e64226shiqian 5692c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 5693c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 5694c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 5695c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 5696c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 5697d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerEquals) { 5698d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "unexpected failure"; 5699d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "unexpected failure"; 5700d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 5701d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 5703d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5704d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5705d201456903f3ecae1f7794edfab0d5678e64226shiqian 5706d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerLessThan) { 5707d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(1, 2) << "unexpected failure"; 5708d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 2) << "unexpected failure"; 5709d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 5710d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5711d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 5712d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5713d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5714d201456903f3ecae1f7794edfab0d5678e64226shiqian 5715d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqual) { 5716d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", "foo") << "unexpected failure"; 5717d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("foo", "foo") << "unexpected failure"; 5718d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 5719d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5720d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 5721d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5722d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5723d201456903f3ecae1f7794edfab0d5678e64226shiqian 5724d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsNotEqual) { 5725d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("foo", "bar") << "unexpected failure"; 5726d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("foo", "bar") << "unexpected failure"; 5727d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 5728d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5729d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 5730d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5731d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5732d201456903f3ecae1f7794edfab0d5678e64226shiqian 5733d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 5734d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 5735d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 5736d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 5737d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5738d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 5739d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5740d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5741d201456903f3ecae1f7794edfab0d5678e64226shiqian 5742d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 5743d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 5744d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 5745d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 5746d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5747d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 5748d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5749d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5750d201456903f3ecae1f7794edfab0d5678e64226shiqian 5751d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, FloatingPointEquals) { 5752d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 5753d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 5754d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 5755d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5756d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 5757d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5758d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5759d201456903f3ecae1f7794edfab0d5678e64226shiqian 576036865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 576136865d8d354465e3461eedf2949a4b7799985d5dshiqian 576236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, Throw) { 576336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 576436865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 576536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 576636865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 576736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 576836865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 576936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 577036865d8d354465e3461eedf2949a4b7799985d5dshiqian 577136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, NoThrow) { 5772886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure"; 5773886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure"; 577436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 577536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 577636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 577736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 577836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 577936865d8d354465e3461eedf2949a4b7799985d5dshiqian 578036865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, AnyThrow) { 578136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 578236865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 5783886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) << 578436865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 5785886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << 578636865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 578736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 578836865d8d354465e3461eedf2949a4b7799985d5dshiqian 578936865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 579036865d8d354465e3461eedf2949a4b7799985d5dshiqian 5791d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test correctly decides whether to use colors in the output. 5792d201456903f3ecae1f7794edfab0d5678e64226shiqian 5793d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 5794d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "yes"; 5795d201456903f3ecae1f7794edfab0d5678e64226shiqian 5796d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5797d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5798d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5799d201456903f3ecae1f7794edfab0d5678e64226shiqian 5800d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5801d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5802d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5803d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5804d201456903f3ecae1f7794edfab0d5678e64226shiqian 5805d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 5806d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5807d201456903f3ecae1f7794edfab0d5678e64226shiqian 5808d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "True"; 5809d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5810d201456903f3ecae1f7794edfab0d5678e64226shiqian 5811d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "t"; 5812d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5813d201456903f3ecae1f7794edfab0d5678e64226shiqian 5814d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "1"; 5815d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5816d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5817d201456903f3ecae1f7794edfab0d5678e64226shiqian 5818d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 5819d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "no"; 5820d201456903f3ecae1f7794edfab0d5678e64226shiqian 5821d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5822d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5823d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5824d201456903f3ecae1f7794edfab0d5678e64226shiqian 5825d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5827d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5828d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5829d201456903f3ecae1f7794edfab0d5678e64226shiqian 5830d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 5831d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5832d201456903f3ecae1f7794edfab0d5678e64226shiqian 5833d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "F"; 5834d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5835d201456903f3ecae1f7794edfab0d5678e64226shiqian 5836d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "0"; 5837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5838d201456903f3ecae1f7794edfab0d5678e64226shiqian 5839d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "unknown"; 5840d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5841d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5842d201456903f3ecae1f7794edfab0d5678e64226shiqian 5843d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 5844d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 5845d201456903f3ecae1f7794edfab0d5678e64226shiqian 5846d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5847d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5848d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5849d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5850d201456903f3ecae1f7794edfab0d5678e64226shiqian 5851d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 5852d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 5853d201456903f3ecae1f7794edfab0d5678e64226shiqian 58540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 5855d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Windows, we ignore the TERM variable as it's usually not set. 5856d201456903f3ecae1f7794edfab0d5678e64226shiqian 5857d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); 5858d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5859d201456903f3ecae1f7794edfab0d5678e64226shiqian 5860d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", ""); 5861d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5862d201456903f3ecae1f7794edfab0d5678e64226shiqian 5863d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); 5864d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5865d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 5866d201456903f3ecae1f7794edfab0d5678e64226shiqian // On non-Windows platforms, we rely on TERM to determine if the 5867d201456903f3ecae1f7794edfab0d5678e64226shiqian // terminal supports colors. 5868d201456903f3ecae1f7794edfab0d5678e64226shiqian 5869d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5870d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5871d201456903f3ecae1f7794edfab0d5678e64226shiqian 5872d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "emacs"); // TERM doesn't support colors. 5873d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5874d201456903f3ecae1f7794edfab0d5678e64226shiqian 5875d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "vt100"); // TERM doesn't support colors. 5876d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5877d201456903f3ecae1f7794edfab0d5678e64226shiqian 5878d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 5879d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5880d201456903f3ecae1f7794edfab0d5678e64226shiqian 5881d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5882d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5883d201456903f3ecae1f7794edfab0d5678e64226shiqian 5884d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-color"); // TERM supports colors. 5885d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 588689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 588789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan SetEnv("TERM", "linux"); // TERM supports colors. 588889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5889d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 5890d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5891d201456903f3ecae1f7794edfab0d5678e64226shiqian 589253e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a namespace scope. 589353e0dc4041f660b6517b15b08b496e164be614f1shiqian 589453e0dc4041f660b6517b15b08b496e164be614f1shiqianstatic bool dummy1 = StaticAssertTypeEq<bool, bool>(); 589553e0dc4041f660b6517b15b08b496e164be614f1shiqianstatic bool dummy2 = StaticAssertTypeEq<const int, const int>(); 589653e0dc4041f660b6517b15b08b496e164be614f1shiqian 589753e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a class. 589853e0dc4041f660b6517b15b08b496e164be614f1shiqian 589953e0dc4041f660b6517b15b08b496e164be614f1shiqiantemplate <typename T> 590053e0dc4041f660b6517b15b08b496e164be614f1shiqianclass StaticAssertTypeEqTestHelper { 590153e0dc4041f660b6517b15b08b496e164be614f1shiqian public: 590253e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); } 590353e0dc4041f660b6517b15b08b496e164be614f1shiqian}; 590453e0dc4041f660b6517b15b08b496e164be614f1shiqian 590553e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, WorksInClass) { 590653e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper<bool>(); 590753e0dc4041f660b6517b15b08b496e164be614f1shiqian} 590853e0dc4041f660b6517b15b08b496e164be614f1shiqian 590953e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works inside a function. 591053e0dc4041f660b6517b15b08b496e164be614f1shiqian 591153e0dc4041f660b6517b15b08b496e164be614f1shiqiantypedef int IntAlias; 591253e0dc4041f660b6517b15b08b496e164be614f1shiqian 591353e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, CompilesForEqualTypes) { 591453e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int, IntAlias>(); 591553e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int*, IntAlias*>(); 591653e0dc4041f660b6517b15b08b496e164be614f1shiqian} 591753e0dc4041f660b6517b15b08b496e164be614f1shiqian 5918e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(ThreadLocalTest, DefaultConstructor) { 5919e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int> t1; 5920e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(0, t1.get()); 5921e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5922e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<void*> t2; 5923e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(t2.get() == NULL); 5924e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 5925e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5926e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(ThreadLocalTest, Init) { 5927e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int> t1(123); 5928e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(123, t1.get()); 5929e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5930e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian int i = 0; 5931e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int*> t2(&i); 5932e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(&i, t2.get()); 5933e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 5934e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 59353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) { 59363d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev testing::UnitTest* const unit_test = testing::UnitTest::GetInstance(); 59373d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 59383d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // We don't have a stack walker in Google Test yet. 59393d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str()); 59403d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str()); 59413d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 5942c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5943c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) { 5944c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailure()); 5945c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5946c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5947c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic void FailFatally() { FAIL(); } 5948c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5949c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) { 5950c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5951c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5952c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5953c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(has_nonfatal_failure); 5954c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5955c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5956c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 5957c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5958c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5959c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5960c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5961c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5962c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5963c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 5964c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5965c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5966c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5967c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5968c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5969c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5970c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5971c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasNonfatalFailure outside of a test body. 5972c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasNonfatalFailureHelper() { 5973c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan return testing::Test::HasNonfatalFailure(); 5974c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5975c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5976c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) { 5977c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailureHelper()); 5978c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5979c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5980c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) { 5981c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5982c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailureHelper(); 5983c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5984c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5985c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5986c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5987c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) { 5988c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailure()); 5989c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5990c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5991c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) { 5992c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5993c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 5994c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5995c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 5996c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5997c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5998c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 5999c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6000c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6001c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6002c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6003c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6004c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6005c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 6006c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6007c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6008c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6009c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6010c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6011c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6012c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6013c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasFailure outside of a test body. 6014c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasFailureHelper() { return testing::Test::HasFailure(); } 6015c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6016c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody) { 6017c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailureHelper()); 6018c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6019c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6020c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody2) { 6021c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6022c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailureHelper(); 6023c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6024c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6025c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6026