gtest_unittest.cc revision 48b1315108cdba8f37394aedb8098102ca00e8b9
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 35dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest.h" 360d27868d0faef474594682f25336229daa89d6d7zhanyong.wan#include <vector> 3725958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev#include <ostream> 38ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 39ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Verifies that the command line flag variables can be accessed 40ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// in code once <gtest/gtest.h> has been #included. 41ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Do not move it after other #includes. 42ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wanTEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { 43ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) 44ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(break_on_failure) 45ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(catch_exceptions) 46ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(color) != "unknown" 47ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(filter) != "unknown" 48ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(list_tests) 49ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(output) != "unknown" 50ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(print_time) 518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(random_seed) 52ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(repeat) > 0 53ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(show_internal_stack_frames) 548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(shuffle) 5540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(stack_trace_depth) > 0 56a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan || testing::GTEST_FLAG(stream_result_to) != "unknown" 5740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(throw_on_failure); 58ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. 59ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan} 60ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 61dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest-spi.h" 62d201456903f3ecae1f7794edfab0d5678e64226shiqian 63d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 64d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 65d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 66d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 67d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 680af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_IMPLEMENTATION_ 1 69d201456903f3ecae1f7794edfab0d5678e64226shiqian#include "src/gtest-internal-inl.h" 700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#undef GTEST_IMPLEMENTATION_ 71d201456903f3ecae1f7794edfab0d5678e64226shiqian 72ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan#include <limits.h> // For INT_MAX. 73d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 74c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <time.h> 75d201456903f3ecae1f7794edfab0d5678e64226shiqian 76c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <map> 77c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 78d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 79d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 80b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 81f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Provides access to otherwise private parts of the TestEventListeners class 8216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// that are needed to test it. 83f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanclass TestEventListenersAccessor { 8416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 85f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static TestEventListener* GetRepeater(TestEventListeners* listeners) { 86b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan return listeners->repeater(); 87b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan } 8816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 89f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SetDefaultResultPrinter(TestEventListeners* listeners, 90b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan TestEventListener* listener) { 9116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SetDefaultResultPrinter(listener); 9216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 93f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SetDefaultXmlGenerator(TestEventListeners* listeners, 94b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan TestEventListener* listener) { 9516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SetDefaultXmlGenerator(listener); 9616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 9716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 98f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static bool EventForwardingEnabled(const TestEventListeners& listeners) { 9916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan return listeners.EventForwardingEnabled(); 10016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 10116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 102f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SuppressEventForwarding(TestEventListeners* listeners) { 10316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SuppressEventForwarding(); 10416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 10516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 10616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 107d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 108d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 109d201456903f3ecae1f7794edfab0d5678e64226shiqian 1109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionFailure; 1119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionResult; 1129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionSuccess; 1139b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::DoubleLE; 114b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::EmptyTestEventListener; 1159b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::FloatLE; 116fe186c382905dcf57014985ccea8e067275e9f5fshiqianusing testing::GTEST_FLAG(also_run_disabled_tests); 1179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(break_on_failure); 1189b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(catch_exceptions); 119d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::GTEST_FLAG(color); 120c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::GTEST_FLAG(death_test_use_fork); 1219b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(filter); 1229b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(list_tests); 1239b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(output); 1249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(print_time); 1258bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(random_seed); 1269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(repeat); 1279b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(show_internal_stack_frames); 1288bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(shuffle); 1299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(stack_trace_depth); 130a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wanusing testing::GTEST_FLAG(stream_result_to); 13140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanusing testing::GTEST_FLAG(throw_on_failure); 1329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsNotSubstring; 1339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsSubstring; 1349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Message; 135d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::ScopedFakeTestPartResultReporter; 13653e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::StaticAssertTypeEq; 137c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::Test; 138b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestCase; 1392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::TestEventListeners; 140c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::TestPartResult; 141c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::TestPartResultArray; 142b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestProperty; 143b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestResult; 144d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::UnitTest; 145bf26ca01f23e432f8b2355fd700707ba217a7605vladlosevusing testing::kMaxStackTraceDepth; 1462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::AddReference; 147f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysFalse; 148f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysTrue; 149d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::AppendUserMessage; 1502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ArrayAwareFind; 1512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ArrayEq; 1520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::CodePointToUtf8; 1532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::CompileAssertTypesEqual; 1542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::CopyArray; 1550d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::CountIf; 156d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::EqFailure; 1579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::FloatingPoint; 1580d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::ForEach; 1592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::FormatTimeInMillisAsSeconds; 160c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::internal::GTestFlagSaver; 1613d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetCurrentOsStackTraceExceptTop; 1620d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::GetElementOr; 1638bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetNextRandomSeed; 1648bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetRandomSeedFromFlag; 165c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTestTypeId; 166c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTypeId; 167aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wanusing testing::internal::GetUnitTestImpl; 1682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ImplicitlyConvertible; 169d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::Int32; 170cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::Int32FromEnvOrDie; 1712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsAProtocolMessage; 1722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsContainer; 1732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsContainerTest; 1742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsNotContainer; 1752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::NativeArray; 176f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::ParseInt32Flag; 1772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::RemoveConst; 1782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::RemoveReference; 179cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldRunTestOnShard; 180cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldShard; 181d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ShouldUseColor; 1820d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::Shuffle; 1830d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::ShuffleRange; 184985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanusing testing::internal::SkipPrefix; 185d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::StreamableToString; 186d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::String; 187f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::TestEventListenersAccessor; 188b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanusing testing::internal::TestResultAccessor; 1892534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanusing testing::internal::UInt32; 1900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::WideStringToUtf8; 1912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::kCopy; 192b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::internal::kMaxRandomSeed; 1932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::kReference; 194c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::internal::kTestTypeIdInGoogleTest; 19516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanusing testing::internal::scoped_ptr; 196d201456903f3ecae1f7794edfab0d5678e64226shiqian 19735c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 19881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wanusing testing::internal::CaptureStdout; 19981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wanusing testing::internal::GetCapturedStdout; 20035c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 20181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 20212a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 20312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wanusing testing::internal::ThreadWithParam; 20412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif 20512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 2060d27868d0faef474594682f25336229daa89d6d7zhanyong.wanclass TestingVector : public std::vector<int> { 207bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan}; 208bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 209bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan::std::ostream& operator<<(::std::ostream& os, 210bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const TestingVector& vector) { 211bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan os << "{ "; 2120d27868d0faef474594682f25336229daa89d6d7zhanyong.wan for (size_t i = 0; i < vector.size(); i++) { 2130d27868d0faef474594682f25336229daa89d6d7zhanyong.wan os << vector[i] << " "; 214bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 215bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan os << "}"; 216bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return os; 217bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 218bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 219d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in an unnamed namespace. 220d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 221d201456903f3ecae1f7794edfab0d5678e64226shiqian 2228bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, HandlesZero) { 2238bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed = GetRandomSeedFromFlag(0); 2248bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed); 2258bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed)); 2268bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2278bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2288bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, PreservesValidSeed) { 2298bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetRandomSeedFromFlag(1)); 2308bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetRandomSeedFromFlag(2)); 2318bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1)); 2328bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 2338bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetRandomSeedFromFlag(kMaxRandomSeed)); 2348bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2358bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2368bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) { 2378bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed1 = GetRandomSeedFromFlag(-1); 2388bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed1); 2398bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed)); 2408bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2418bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1); 2428bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed2); 2438bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed)); 2448bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2458bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2468bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetNextRandomSeedTest, WorksForValidInput) { 2478bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetNextRandomSeed(1)); 2488bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(3, GetNextRandomSeed(2)); 2498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 2508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetNextRandomSeed(kMaxRandomSeed - 1)); 2518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed)); 2528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 2538bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // We deliberately don't test GetNextRandomSeed() with invalid 2548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // inputs, as that requires death tests, which are expensive. This 2558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // is fine as GetNextRandomSeed() is internal and has a 2568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // straightforward definition. 2578bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 2588bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 259b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanstatic void ClearCurrentTestPartResults() { 260b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::ClearTestPartResults( 261b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetUnitTestImpl()->current_test_result()); 262b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan} 263b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 264c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Tests GetTypeId. 265c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 266c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsSameValueForSameType) { 267c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>()); 268c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>()); 269c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 270c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 271c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass SubClassOfTest : public Test {}; 272c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass AnotherSubClassOfTest : public Test {}; 273c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 274c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) { 275c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>()); 276c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<char>()); 277c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTestTypeId()); 278c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId()); 279c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId()); 280c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>()); 281c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 282c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 283c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Verifies that GetTestTypeId() returns the same value, no matter it 284c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// is called from inside Google Test or outside of it. 285c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) { 286c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId()); 287c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 288c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 28964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Tests FormatTimeInMillisAsSeconds(). 29064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 29164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsZero) { 292e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0)); 29364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 29464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 29564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) { 296e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3)); 297e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10)); 298e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200)); 299e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200)); 300e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000)); 30164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 30264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 30364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) { 304e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3)); 305e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10)); 306e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200)); 307e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200)); 308e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000)); 30964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 31064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 31106d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 312d201456903f3ecae1f7794edfab0d5678e64226shiqian 313c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 314c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 315c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 316c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 317c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 318e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null 319d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 320d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsTrueForNullLiterals) { 321e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL)); 322e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0)); 323e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U)); 324e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L)); 325c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 326c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Some compilers may fail to detect some null pointer literals; 327c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // as long as users of the framework don't use such literals, this 328c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // is harmless. 329c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1)); 330c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 331d201456903f3ecae1f7794edfab0d5678e64226shiqian} 332d201456903f3ecae1f7794edfab0d5678e64226shiqian 333e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null 334d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 335d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 336e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1)); 337e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0)); 338e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a')); 339e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL))); 340d201456903f3ecae1f7794edfab0d5678e64226shiqian} 341d201456903f3ecae1f7794edfab0d5678e64226shiqian 342c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 343d21c142eb89ce42817165368641329072e2ad8fbvladlosev// Restores warnings after previous "#pragma option push" suppressed them. 344c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 345c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 346c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 34706d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 3480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 3490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests CodePointToUtf8(). 350d201456903f3ecae1f7794edfab0d5678e64226shiqian 351d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the NUL character L'\0' is encoded correctly. 3520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeNul) { 3530c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 3540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer)); 355d201456903f3ecae1f7794edfab0d5678e64226shiqian} 356d201456903f3ecae1f7794edfab0d5678e64226shiqian 357d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASCII characters are encoded correctly. 3580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeAscii) { 3590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 3600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer)); 3610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer)); 3620c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer)); 3630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer)); 364d201456903f3ecae1f7794edfab0d5678e64226shiqian} 365d201456903f3ecae1f7794edfab0d5678e64226shiqian 366d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 8 to 11 bits are encoded 367d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 110xxxxx 10xxxxxx. 3680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 3690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 370d201456903f3ecae1f7794edfab0d5678e64226shiqian // 000 1101 0011 => 110-00011 10-010011 3710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer)); 372d201456903f3ecae1f7794edfab0d5678e64226shiqian 373d201456903f3ecae1f7794edfab0d5678e64226shiqian // 101 0111 0110 => 110-10101 10-110110 374c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints 375c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // in wide strings and wide chars. In order to accomodate them, we have to 376c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // introduce such character constants as integers. 377c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xD5\xB6", 378c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan CodePointToUtf8(static_cast<wchar_t>(0x576), buffer)); 379d201456903f3ecae1f7794edfab0d5678e64226shiqian} 380d201456903f3ecae1f7794edfab0d5678e64226shiqian 381d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 12 to 16 bits are encoded 382d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 1110xxxx 10xxxxxx 10xxxxxx. 3830c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 3840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 385d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 386c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xE0\xA3\x93", 387c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan CodePointToUtf8(static_cast<wchar_t>(0x8D3), buffer)); 388d201456903f3ecae1f7794edfab0d5678e64226shiqian 389d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 390c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xEC\x9D\x8D", 391c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan CodePointToUtf8(static_cast<wchar_t>(0xC74D), buffer)); 392d201456903f3ecae1f7794edfab0d5678e64226shiqian} 393d201456903f3ecae1f7794edfab0d5678e64226shiqian 3940af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 395d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests in this group require a wchar_t to hold > 16 bits, and thus 396e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 3970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 16-bit wide. This code may not compile on those systems. 398d201456903f3ecae1f7794edfab0d5678e64226shiqian 399d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 17 to 21 bits are encoded 400d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 4010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 4020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 403d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 4040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer)); 4050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 4070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer)); 408d201456903f3ecae1f7794edfab0d5678e64226shiqian 4090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 4100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer)); 411d201456903f3ecae1f7794edfab0d5678e64226shiqian} 412d201456903f3ecae1f7794edfab0d5678e64226shiqian 413d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that encoding an invalid code-point generates the expected result. 4140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 4150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 416d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)", 4170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev CodePointToUtf8(L'\x1234ABCD', buffer)); 4180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4200af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 4210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests WideStringToUtf8(). 4230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the NUL character L'\0' is encoded correctly. 4250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeNul) { 4260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 4270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 4280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that ASCII strings are encoded correctly. 4310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeAscii) { 4320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 4330c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 4340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 4350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 4360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 8 to 11 bits are encoded 4390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 110xxxxx 10xxxxxx. 4400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 4410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 000 1101 0011 => 110-00011 10-010011 4420c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 4430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 4440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 101 0111 0110 => 110-10101 10-110110 446c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0x576, '\0' }; 447c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str()); 448c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str()); 4490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4510c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 12 to 16 bits are encoded 4520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 1110xxxx 10xxxxxx 10xxxxxx. 4530c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 4540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 455c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s1[] = { 0x8D3, '\0' }; 456c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str()); 457c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str()); 4580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 460c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s2[] = { 0xC74D, '\0' }; 461c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str()); 462c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str()); 463d201456903f3ecae1f7794edfab0d5678e64226shiqian} 464d201456903f3ecae1f7794edfab0d5678e64226shiqian 4650c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function encounters \0 character. 4660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 4670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 4680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function reaches the limit 4710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// specified by the 'length' parameter. 4720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 4730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 4740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 4770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 17 to 21 bits are encoded 4780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 4790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// on the systems using UTF-16 encoding. 4800c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 4810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 4820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 4830c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 4840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 4860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 4870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 4880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid code-point generates the expected result. 4910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 4920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 4930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xABCDFF", -1).c_str()); 4940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#else // !GTEST_WIDE_STRING_USES_UTF16_ 4960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that surrogate pairs are encoded correctly on the systems using 4970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// UTF-16 encoding in the wide strings. 4980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 499c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0xD801, 0xDC00, '\0' }; 500c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str()); 5010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5030c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid UTF-16 surrogate pair 5040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// generates the expected result. 5050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 5060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is at the end of the string. 507c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s1[] = { 0xD800, '\0' }; 508c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str()); 5090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is not followed by the trailing surrogate. 510c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s2[] = { 0xD800, 'M', '\0' }; 511c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str()); 5120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Trailing surrogate appearas without a leading surrogate. 513c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' }; 514c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str()); 5150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 5170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that codepoint concatenation works correctly. 5190af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 5200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 521c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'}; 5220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 5230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4" 5240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" 5250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\n" 5260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xD5\xB6" 5270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xE0\xA3\x93" 5280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4", 529c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan WideStringToUtf8(s, -1).c_str()); 5300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 5320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 533c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'}; 5340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 5350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 536c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan WideStringToUtf8(s, -1).c_str()); 5370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5380af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 539d201456903f3ecae1f7794edfab0d5678e64226shiqian 5402534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan// Tests the Random class. 5412534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5422534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) { 5432534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(42); 5442534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 5452534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Generate(0), 5462534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "Cannot generate a number in the range \\[0, 0\\)"); 5472534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 5482534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Generate(testing::internal::Random::kMaxRange + 1), 5492534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "Generation of a number in \\[0, 2147483649\\) was requested, " 5502534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "but this can only generate numbers in \\[0, 2147483648\\)"); 5512534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 5522534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5532534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomTest, GeneratesNumbersWithinRange) { 5542534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const UInt32 kRange = 10000; 5552534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(12345); 5562534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < 10; i++) { 5572534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i; 5582534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 5592534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5602534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random2(testing::internal::Random::kMaxRange); 5612534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < 10; i++) { 5622534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i; 5632534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 5642534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 5652534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5662534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomTest, RepeatsWhenReseeded) { 5672534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const int kSeed = 123; 5682534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const int kArraySize = 10; 5692534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const UInt32 kRange = 10000; 5702534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan UInt32 values[kArraySize]; 5712534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5722534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(kSeed); 5732534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < kArraySize; i++) { 5742534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan values[i] = random.Generate(kRange); 5752534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 5762534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5772534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Reseed(kSeed); 5782534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < kArraySize; i++) { 5792534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i; 5802534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 5812534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 5822534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 5830d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests STL container utilities. 584600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 5850d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests CountIf(). 586600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 5870d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic bool IsPositive(int n) { return n > 0; } 58889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 5890d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, CountIf) { 5900d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> v; 5910d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, CountIf(v, IsPositive)); // Works for an empty container. 59289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 5930d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(-1); 5940d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(0); 5950d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, CountIf(v, IsPositive)); // Works when no value satisfies. 59689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 5970d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(2); 5980d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(-10); 5990d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(10); 6000d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(2, CountIf(v, IsPositive)); 601e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 602d201456903f3ecae1f7794edfab0d5678e64226shiqian 6030d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests ForEach(). 604bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6050d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic int g_sum = 0; 6060d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic void Accumulate(int n) { g_sum += n; } 607bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6080d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, ForEach) { 6090d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> v; 6100d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 6110d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 6120d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, g_sum); // Works for an empty container; 613bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6140d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 6150d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(1); 6160d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 6170d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(1, g_sum); // Works for a container with one element. 6180d27868d0faef474594682f25336229daa89d6d7zhanyong.wan 6190d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 6200d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(20); 6210d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(300); 6220d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 6230d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(321, g_sum); 624bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 625bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6260d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests GetElementOr(). 6270d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, GetElementOr) { 6280d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<char> a; 6290d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, 0, 'x')); 630bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6310d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back('a'); 6320d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back('b'); 6330d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('a', GetElementOr(a, 0, 'x')); 6340d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('b', GetElementOr(a, 1, 'x')); 6350d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, -2, 'x')); 6360d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, 2, 'x')); 637bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 638bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 6390d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityDeathTest, ShuffleRange) { 6400d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> a; 6410d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(0); 6420d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(1); 6430d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(2); 644bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan testing::internal::Random random(1); 645bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 646bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 6470d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, -1, 1, &a), 648bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range start -1: must be in range \\[0, 3\\]"); 649bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 6500d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 4, 4, &a), 651bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range start 4: must be in range \\[0, 3\\]"); 652bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 6530d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 3, 2, &a), 654bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range finish 2: must be in range \\[3, 3\\]"); 655bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 6560d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 3, 4, &a), 657bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range finish 4: must be in range \\[3, 3\\]"); 658bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 659bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 660bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanclass VectorShuffleTest : public Test { 661bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan protected: 662bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static const int kVectorSize = 20; 663bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 664bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan VectorShuffleTest() : random_(1) { 665bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 6660d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_.push_back(i); 667bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 668bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 669bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 670bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsCorrupt(const TestingVector& vector) { 6710d27868d0faef474594682f25336229daa89d6d7zhanyong.wan if (kVectorSize != static_cast<int>(vector.size())) { 672bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 673bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 674bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 675bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan bool found_in_vector[kVectorSize] = { false }; 6760d27868d0faef474594682f25336229daa89d6d7zhanyong.wan for (size_t i = 0; i < vector.size(); i++) { 6770d27868d0faef474594682f25336229daa89d6d7zhanyong.wan const int e = vector[i]; 678bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan if (e < 0 || e >= kVectorSize || found_in_vector[e]) { 679bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 680bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 681bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan found_in_vector[e] = true; 682bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 683bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 684bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Vector size is correct, elements' range is correct, no 685bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // duplicate elements. Therefore no corruption has occurred. 686bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return false; 687bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 688bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 689bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsNotCorrupt(const TestingVector& vector) { 690bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !VectorIsCorrupt(vector); 691bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 692bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 693bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) { 694bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = begin; i < end; i++) { 6950d27868d0faef474594682f25336229daa89d6d7zhanyong.wan if (i != vector[i]) { 696bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 697bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 698bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 699bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return false; 700bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 701bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 702bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool RangeIsUnshuffled( 703bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const TestingVector& vector, int begin, int end) { 704bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !RangeIsShuffled(vector, begin, end); 705bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 706bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 707bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsShuffled(const TestingVector& vector) { 7086baed3c1173c19f5d43af75798d3685853fbe8bdzhanyong.wan return RangeIsShuffled(vector, 0, static_cast<int>(vector.size())); 709bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 710bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 711bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsUnshuffled(const TestingVector& vector) { 712bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !VectorIsShuffled(vector); 713bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 714bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 715bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan testing::internal::Random random_; 716bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan TestingVector vector_; 717bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan}; // class VectorShuffleTest 718bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 719bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanconst int VectorShuffleTest::kVectorSize; 720bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 721bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, HandlesEmptyRange) { 722bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests an empty range at the beginning... 7230d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, 0, &vector_); 724bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 725bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 726bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 727bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...in the middle... 7280d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_); 729bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 730bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 731bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 732bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...at the end... 7330d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_); 734bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 735bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 736bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 737bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...and past the end. 7380d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_); 739bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 740bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 741bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 742bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 743bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) { 744bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests a size one range at the beginning... 7450d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, 1, &vector_); 746bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 747bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 748bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 749bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...in the middle... 7500d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_); 751bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 752bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 753bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 754bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...and at the end. 7550d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_); 756bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 757bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 758bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 759bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 760bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan// Because we use our own random number generator and a fixed seed, 761bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan// we can guarantee that the following "random" tests will succeed. 762bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 763bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesEntireVector) { 7640d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector_); 765bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 766bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_; 767bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 768bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests the first and last elements in particular to ensure that 769bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // there are no off-by-one problems in our shuffle algorithm. 7700d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_NE(0, vector_[0]); 7710d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]); 772bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 773bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 774bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesStartOfVector) { 775bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const int kRangeSize = kVectorSize/2; 776bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 7770d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, kRangeSize, &vector_); 778bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 779bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 780bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize); 781bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize); 782bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 783bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 784bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesEndOfVector) { 785bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const int kRangeSize = kVectorSize / 2; 7860d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_); 787bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 788bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 789bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 790bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize); 791bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 792bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 793bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesMiddleOfVector) { 794bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan int kRangeSize = kVectorSize/3; 7950d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_); 796bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 797bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 798bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 799bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize); 800bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize); 801bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 802bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 803bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesRepeatably) { 804bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan TestingVector vector2; 805bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 8060d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector2.push_back(i); 807bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 808bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 809bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan random_.Reseed(1234); 8100d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector_); 811bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan random_.Reseed(1234); 8120d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector2); 813bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 814bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 815bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector2); 816bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 817bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 8180d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i; 819bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 820bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 821bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 82216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests the size of the AssertHelper class. 823d201456903f3ecae1f7794edfab0d5678e64226shiqian 82416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(AssertHelperTest, AssertHelperIsSmall) { 82556a2e686e915d483cb22db091140130b23814127zhanyong.wan // To avoid breaking clients that use lots of assertions in one 82616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // function, we cannot grow the size of AssertHelper. 82716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*)); 82856a2e686e915d483cb22db091140130b23814127zhanyong.wan} 82956a2e686e915d483cb22db091140130b23814127zhanyong.wan 83016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests the String class. 83116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 832d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String's constructors. 833d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Constructors) { 834d201456903f3ecae1f7794edfab0d5678e64226shiqian // Default ctor. 835d201456903f3ecae1f7794edfab0d5678e64226shiqian String s1; 836bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing 837bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // pointers with NULL isn't supported on all platforms. 83856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, s1.length()); 839bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(NULL == s1.c_str()); 840d201456903f3ecae1f7794edfab0d5678e64226shiqian 841d201456903f3ecae1f7794edfab0d5678e64226shiqian // Implicitly constructs from a C-string. 842d201456903f3ecae1f7794edfab0d5678e64226shiqian String s2 = "Hi"; 84356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(2U, s2.length()); 844d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Hi", s2.c_str()); 845d201456903f3ecae1f7794edfab0d5678e64226shiqian 846d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs from a C-string and a length. 847d201456903f3ecae1f7794edfab0d5678e64226shiqian String s3("hello", 3); 84856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(3U, s3.length()); 849d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s3.c_str()); 850d201456903f3ecae1f7794edfab0d5678e64226shiqian 85156a2e686e915d483cb22db091140130b23814127zhanyong.wan // The empty String should be created when String is constructed with 85256a2e686e915d483cb22db091140130b23814127zhanyong.wan // a NULL pointer and length 0. 85356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, String(NULL, 0).length()); 85456a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(String(NULL, 0).c_str() == NULL); 85556a2e686e915d483cb22db091140130b23814127zhanyong.wan 85656a2e686e915d483cb22db091140130b23814127zhanyong.wan // Constructs a String that contains '\0'. 85756a2e686e915d483cb22db091140130b23814127zhanyong.wan String s4("a\0bcd", 4); 85856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(4U, s4.length()); 85956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('a', s4.c_str()[0]); 86056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('\0', s4.c_str()[1]); 86156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('b', s4.c_str()[2]); 86256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('c', s4.c_str()[3]); 86356a2e686e915d483cb22db091140130b23814127zhanyong.wan 86456a2e686e915d483cb22db091140130b23814127zhanyong.wan // Copy ctor where the source is NULL. 86556a2e686e915d483cb22db091140130b23814127zhanyong.wan const String null_str; 86656a2e686e915d483cb22db091140130b23814127zhanyong.wan String s5 = null_str; 86756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_TRUE(s5.c_str() == NULL); 86856a2e686e915d483cb22db091140130b23814127zhanyong.wan 86956a2e686e915d483cb22db091140130b23814127zhanyong.wan // Copy ctor where the source isn't NULL. 87056a2e686e915d483cb22db091140130b23814127zhanyong.wan String s6 = s3; 87156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(3U, s6.length()); 87256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_STREQ("hel", s6.c_str()); 87356a2e686e915d483cb22db091140130b23814127zhanyong.wan 87456a2e686e915d483cb22db091140130b23814127zhanyong.wan // Copy ctor where the source contains '\0'. 87556a2e686e915d483cb22db091140130b23814127zhanyong.wan String s7 = s4; 87656a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(4U, s7.length()); 87756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('a', s7.c_str()[0]); 87856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('\0', s7.c_str()[1]); 87956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('b', s7.c_str()[2]); 88056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('c', s7.c_str()[3]); 881d201456903f3ecae1f7794edfab0d5678e64226shiqian} 882d201456903f3ecae1f7794edfab0d5678e64226shiqian 8831998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromStdString) { 8841998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty std::string. 8851998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src1(""); 8861998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 88756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, dest1.length()); 8881998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 8891998cf5d32a19aaffe8652545802744d9133022dvladlosev 8901998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal std::string. 8911998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src2("Hi"); 8921998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 89356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(2U, dest2.length()); 8941998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 8951998cf5d32a19aaffe8652545802744d9133022dvladlosev 8961998cf5d32a19aaffe8652545802744d9133022dvladlosev // An std::string with an embedded NUL character. 89756a2e686e915d483cb22db091140130b23814127zhanyong.wan const char src3[] = "a\0b"; 8981998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = std::string(src3, sizeof(src3)); 89956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(sizeof(src3), dest3.length()); 90056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('a', dest3.c_str()[0]); 90156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('\0', dest3.c_str()[1]); 90256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('b', dest3.c_str()[2]); 9031998cf5d32a19aaffe8652545802744d9133022dvladlosev} 9041998cf5d32a19aaffe8652545802744d9133022dvladlosev 9051998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToStdString) { 9061998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 9071998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 9081998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest1 = src1; 9091998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 9101998cf5d32a19aaffe8652545802744d9133022dvladlosev 9111998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 9121998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 9131998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest2 = src2; 9141998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 91556a2e686e915d483cb22db091140130b23814127zhanyong.wan 91656a2e686e915d483cb22db091140130b23814127zhanyong.wan // A String containing a '\0'. 91756a2e686e915d483cb22db091140130b23814127zhanyong.wan const String src3("x\0y", 3); 91856a2e686e915d483cb22db091140130b23814127zhanyong.wan const std::string dest3 = src3; 91956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(std::string("x\0y", 3), dest3); 9201998cf5d32a19aaffe8652545802744d9133022dvladlosev} 9211998cf5d32a19aaffe8652545802744d9133022dvladlosev 9221998cf5d32a19aaffe8652545802744d9133022dvladlosev#if GTEST_HAS_GLOBAL_STRING 9231998cf5d32a19aaffe8652545802744d9133022dvladlosev 9241998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromGlobalString) { 9251998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty ::string. 9261998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src1(""); 9271998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 92856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, dest1.length()); 9291998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 9301998cf5d32a19aaffe8652545802744d9133022dvladlosev 9311998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal ::string. 9321998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src2("Hi"); 9331998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 93456a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(2U, dest2.length()); 9351998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 9361998cf5d32a19aaffe8652545802744d9133022dvladlosev 9371998cf5d32a19aaffe8652545802744d9133022dvladlosev // An ::string with an embedded NUL character. 93856a2e686e915d483cb22db091140130b23814127zhanyong.wan const char src3[] = "x\0y"; 9391998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = ::string(src3, sizeof(src3)); 94056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(sizeof(src3), dest3.length()); 94156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('x', dest3.c_str()[0]); 94256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('\0', dest3.c_str()[1]); 94356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('y', dest3.c_str()[2]); 9441998cf5d32a19aaffe8652545802744d9133022dvladlosev} 9451998cf5d32a19aaffe8652545802744d9133022dvladlosev 9461998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToGlobalString) { 9471998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 9481998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 9491998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest1 = src1; 9501998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 9511998cf5d32a19aaffe8652545802744d9133022dvladlosev 9521998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 9531998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 9541998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest2 = src2; 9551998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 95656a2e686e915d483cb22db091140130b23814127zhanyong.wan 95756a2e686e915d483cb22db091140130b23814127zhanyong.wan const String src3("x\0y", 3); 95856a2e686e915d483cb22db091140130b23814127zhanyong.wan const ::string dest3 = src3; 95956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(::string("x\0y", 3), dest3); 9601998cf5d32a19aaffe8652545802744d9133022dvladlosev} 9611998cf5d32a19aaffe8652545802744d9133022dvladlosev 9621998cf5d32a19aaffe8652545802744d9133022dvladlosev#endif // GTEST_HAS_GLOBAL_STRING 9631998cf5d32a19aaffe8652545802744d9133022dvladlosev 964d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCStringQuoted(). 965d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCStringQuoted) { 966d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 967d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted(NULL).c_str()); 968d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"\"", 969d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("").c_str()); 970d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"foo\"", 971d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("foo").c_str()); 972d201456903f3ecae1f7794edfab0d5678e64226shiqian} 973d201456903f3ecae1f7794edfab0d5678e64226shiqian 97456a2e686e915d483cb22db091140130b23814127zhanyong.wan// Tests String::empty(). 97556a2e686e915d483cb22db091140130b23814127zhanyong.wanTEST(StringTest, Empty) { 97656a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_TRUE(String("").empty()); 97756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(String().empty()); 97856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(String(NULL).empty()); 97956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(String("a").empty()); 98056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(String("\0", 1).empty()); 98156a2e686e915d483cb22db091140130b23814127zhanyong.wan} 98256a2e686e915d483cb22db091140130b23814127zhanyong.wan 98356a2e686e915d483cb22db091140130b23814127zhanyong.wan// Tests String::Compare(). 98456a2e686e915d483cb22db091140130b23814127zhanyong.wanTEST(StringTest, Compare) { 98556a2e686e915d483cb22db091140130b23814127zhanyong.wan // NULL vs NULL. 98656a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0, String().Compare(String())); 98756a2e686e915d483cb22db091140130b23814127zhanyong.wan 98856a2e686e915d483cb22db091140130b23814127zhanyong.wan // NULL vs non-NULL. 98956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String().Compare(String(""))); 99056a2e686e915d483cb22db091140130b23814127zhanyong.wan 99156a2e686e915d483cb22db091140130b23814127zhanyong.wan // Non-NULL vs NULL. 99256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(1, String("").Compare(String())); 99356a2e686e915d483cb22db091140130b23814127zhanyong.wan 99456a2e686e915d483cb22db091140130b23814127zhanyong.wan // The following covers non-NULL vs non-NULL. 99556a2e686e915d483cb22db091140130b23814127zhanyong.wan 99656a2e686e915d483cb22db091140130b23814127zhanyong.wan // "" vs "". 99756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0, String("").Compare(String(""))); 99856a2e686e915d483cb22db091140130b23814127zhanyong.wan 99956a2e686e915d483cb22db091140130b23814127zhanyong.wan // "" vs non-"". 100056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String("").Compare(String("\0", 1))); 100156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String("").Compare(" ")); 100256a2e686e915d483cb22db091140130b23814127zhanyong.wan 100356a2e686e915d483cb22db091140130b23814127zhanyong.wan // Non-"" vs "". 100456a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(1, String("a").Compare(String(""))); 100556a2e686e915d483cb22db091140130b23814127zhanyong.wan 100656a2e686e915d483cb22db091140130b23814127zhanyong.wan // The following covers non-"" vs non-"". 100756a2e686e915d483cb22db091140130b23814127zhanyong.wan 100856a2e686e915d483cb22db091140130b23814127zhanyong.wan // Same length and equal. 100956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0, String("a").Compare(String("a"))); 101056a2e686e915d483cb22db091140130b23814127zhanyong.wan 101156a2e686e915d483cb22db091140130b23814127zhanyong.wan // Same length and different. 101256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String("a\0b", 3).Compare(String("a\0c", 3))); 101356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(1, String("b").Compare(String("a"))); 101456a2e686e915d483cb22db091140130b23814127zhanyong.wan 101556a2e686e915d483cb22db091140130b23814127zhanyong.wan // Different lengths. 101656a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String("a").Compare(String("ab"))); 101756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(-1, String("a").Compare(String("a\0", 2))); 101856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(1, String("abc").Compare(String("aacd"))); 101956a2e686e915d483cb22db091140130b23814127zhanyong.wan} 102056a2e686e915d483cb22db091140130b23814127zhanyong.wan 1021d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator==(). 1022d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Equals) { 1023d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 1024d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null == NULL); // NOLINT 1025d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == ""); // NOLINT 1026d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == "bar"); // NOLINT 1027d201456903f3ecae1f7794edfab0d5678e64226shiqian 1028d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 1029d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == NULL); // NOLINT 1030d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty == ""); // NOLINT 1031d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == "bar"); // NOLINT 1032d201456903f3ecae1f7794edfab0d5678e64226shiqian 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 1034d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == NULL); // NOLINT 1035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == ""); // NOLINT 1036d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == "bar"); // NOLINT 1037d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo == "foo"); // NOLINT 103856a2e686e915d483cb22db091140130b23814127zhanyong.wan 103956a2e686e915d483cb22db091140130b23814127zhanyong.wan const String bar("x\0y", 3); 104056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_FALSE(bar == "x"); 1041d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1042d201456903f3ecae1f7794edfab0d5678e64226shiqian 1043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator!=(). 1044d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, NotEquals) { 1045d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 1046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null != NULL); // NOLINT 1047d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != ""); // NOLINT 1048d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != "bar"); // NOLINT 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian 1050d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 1051d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != NULL); // NOLINT 1052d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty != ""); // NOLINT 1053d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != "bar"); // NOLINT 1054d201456903f3ecae1f7794edfab0d5678e64226shiqian 1055d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 1056d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != NULL); // NOLINT 1057d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != ""); // NOLINT 1058d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != "bar"); // NOLINT 1059d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo != "foo"); // NOLINT 106056a2e686e915d483cb22db091140130b23814127zhanyong.wan 106156a2e686e915d483cb22db091140130b23814127zhanyong.wan const String bar("x\0y", 3); 106256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_TRUE(bar != "x"); 106356a2e686e915d483cb22db091140130b23814127zhanyong.wan} 106456a2e686e915d483cb22db091140130b23814127zhanyong.wan 106556a2e686e915d483cb22db091140130b23814127zhanyong.wan// Tests String::length(). 106656a2e686e915d483cb22db091140130b23814127zhanyong.wanTEST(StringTest, Length) { 106756a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, String().length()); 106856a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(0U, String("").length()); 106956a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(2U, String("ab").length()); 107056a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(3U, String("a\0b", 3).length()); 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1072d201456903f3ecae1f7794edfab0d5678e64226shiqian 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWith(). 1074d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWith) { 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("bar")); 1076d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("")); 1077d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWith("")); 1078d201456903f3ecae1f7794edfab0d5678e64226shiqian 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWith("foo")); 1080d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWith("foo")); 1081d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1082d201456903f3ecae1f7794edfab0d5678e64226shiqian 1083d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWithCaseInsensitive(). 1084d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWithCaseInsensitive) { 1085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR")); 1086d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar")); 1087d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("")); 1088d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWithCaseInsensitive("")); 1089d201456903f3ecae1f7794edfab0d5678e64226shiqian 1090d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo")); 1091d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo")); 1092d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo")); 1093d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1094d201456903f3ecae1f7794edfab0d5678e64226shiqian 1095c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// C++Builder's preprocessor is buggy; it fails to expand macros that 1096c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// appear in macro parameters after wide char literals. Provide an alias 1097c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// for NULL as a workaround. 1098c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic const wchar_t* const kNull = NULL; 1099c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1100a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests String::CaseInsensitiveWideCStringEquals 1101a2b1a8556ea64014606d78b09333d9c522430a25shiqianTEST(StringTest, CaseInsensitiveWideCStringEquals) { 1102a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 1103c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"")); 1104c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull)); 1105c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar")); 1106c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull)); 1107a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 1108a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 1109a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 1110a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 1111a2b1a8556ea64014606d78b09333d9c522430a25shiqian 1112d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that NULL can be assigned to a String. 1113d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNULL) { 1114d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(NULL); 1115d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 1116d201456903f3ecae1f7794edfab0d5678e64226shiqian 1117d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 1118d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(NULL, dest.c_str()); 1119d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1120d201456903f3ecae1f7794edfab0d5678e64226shiqian 1121d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the empty string "" can be assigned to a String. 1122d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedEmpty) { 1123d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(""); 1124d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 1125d201456903f3ecae1f7794edfab0d5678e64226shiqian 1126d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 1127d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", dest.c_str()); 1128d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1129d201456903f3ecae1f7794edfab0d5678e64226shiqian 1130d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a non-empty string can be assigned to a String. 1131d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNonEmpty) { 1132d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src("hello"); 1133d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 1134d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 113556a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(5U, dest.length()); 1136d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 113756a2e686e915d483cb22db091140130b23814127zhanyong.wan 113856a2e686e915d483cb22db091140130b23814127zhanyong.wan const String src2("x\0y", 3); 113956a2e686e915d483cb22db091140130b23814127zhanyong.wan String dest2; 114056a2e686e915d483cb22db091140130b23814127zhanyong.wan dest2 = src2; 114156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(3U, dest2.length()); 114256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('x', dest2.c_str()[0]); 114356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('\0', dest2.c_str()[1]); 114456a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ('y', dest2.c_str()[2]); 1145d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1146d201456903f3ecae1f7794edfab0d5678e64226shiqian 1147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a String can be assigned to itself. 1148d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedSelf) { 1149d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest("hello"); 1150d201456903f3ecae1f7794edfab0d5678e64226shiqian 11517225dd179a49165036ebad0a92a8f6f408d332c6zhanyong.wan // Use explicit function call notation here to suppress self-assign warning. 11527225dd179a49165036ebad0a92a8f6f408d332c6zhanyong.wan dest.operator=(dest); 1153d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 1154d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1155d201456903f3ecae1f7794edfab0d5678e64226shiqian 1156cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Sun Studio < 12 incorrectly rejects this code due to an overloading 1157cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// ambiguity. 1158cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#if !(defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) 115956a2e686e915d483cb22db091140130b23814127zhanyong.wan// Tests streaming a String. 116056a2e686e915d483cb22db091140130b23814127zhanyong.wanTEST(StringTest, Streams) { 116156a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(StreamableToString(String()), "(null)"); 116256a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(StreamableToString(String("")), ""); 116356a2e686e915d483cb22db091140130b23814127zhanyong.wan EXPECT_EQ(StreamableToString(String("a\0b", 3)), "a\\0b"); 116456a2e686e915d483cb22db091140130b23814127zhanyong.wan} 1165cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif 116656a2e686e915d483cb22db091140130b23814127zhanyong.wan 116716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that String::Format() works. 116816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(StringTest, FormatWorks) { 116916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Normal case: the format spec is valid, the arguments match the 117016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // spec, and the result is < 4095 characters. 117116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_STREQ("Hello, 42", String::Format("%s, %d", "Hello", 42).c_str()); 117216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 117316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Edge case: the result is 4095 characters. 117416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan char buffer[4096]; 117516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan const size_t kSize = sizeof(buffer); 117616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan memset(buffer, 'a', kSize - 1); 117716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan buffer[kSize - 1] = '\0'; 117816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_STREQ(buffer, String::Format("%s", buffer).c_str()); 117916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 118016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // The result needs to be 4096 characters, exceeding Format()'s limit. 118116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_STREQ("<formatting error or buffer exceeded>", 118216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan String::Format("x%s", buffer).c_str()); 118316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 118416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan#if GTEST_OS_LINUX 118516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // On Linux, invalid format spec should lead to an error message. 118616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // In other environment (e.g. MSVC on Windows), String::Format() may 118716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // simply ignore a bad format spec, so this assertion is run on 118816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Linux only. 118916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_STREQ("<formatting error or buffer exceeded>", 119016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan String::Format("%").c_str()); 119116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan#endif 119216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 119316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 11940af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 1195d201456903f3ecae1f7794edfab0d5678e64226shiqian 1196d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCString(). 1197d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCString) { 1198d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 1199d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCString(NULL).c_str()); 1200d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 1201d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 1202d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1203d201456903f3ecae1f7794edfab0d5678e64226shiqian 1204d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCStringQuoted(). 1205d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCStringQuoted) { 1206d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 1207d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(NULL).c_str()); 1208d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"\"", 1209d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"").c_str()); 1210d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"foo\"", 1211d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"foo").c_str()); 1212d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1213d201456903f3ecae1f7794edfab0d5678e64226shiqian 1214b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 1215bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16Null) { 1216bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 1217bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 1218bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1219bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1220bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertBasic) { 1221bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L"str"); 1222bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ("str", ansi); 1223bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 1224bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16("str"); 1225ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L"str", utf16, 3)); 1226bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 1227bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1228bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1229bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 1230bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 1231bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ(".:\\ \"*?", ansi); 1232bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 1233bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 1234ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3)); 1235bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 1236bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1237b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 1238bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1239d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 1240d201456903f3ecae1f7794edfab0d5678e64226shiqian 1241d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty construction. 1242d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, StringValue) { 1243d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 1244d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key", property.key()); 1245d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 1246d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1247d201456903f3ecae1f7794edfab0d5678e64226shiqian 1248d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty replacing a value. 1249d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, ReplaceStringValue) { 1250d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 1251d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 1252d201456903f3ecae1f7794edfab0d5678e64226shiqian property.SetValue("2"); 1253d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", property.value()); 1254d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1255d201456903f3ecae1f7794edfab0d5678e64226shiqian 1256c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// AddFatalFailure() and AddNonfatalFailure() must be stand-alone 1257c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// functions (i.e. their definitions cannot be inlined at the call 1258c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// sites), or C++Builder won't compile the code. 1259c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddFatalFailure() { 1260c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FAIL() << "Expected fatal failure."; 1261c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1262c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1263c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddNonfatalFailure() { 1264c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ADD_FAILURE() << "Expected non-fatal failure."; 1265c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1266c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1267e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterTest : public Test { 12688de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 1269e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian enum FailureMode { 1270e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FATAL_FAILURE, 1271e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NONFATAL_FAILURE 1272e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }; 1273e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailure(FailureMode failure) { 1274e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (failure == FATAL_FAILURE) { 1275c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1276e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } else { 1277c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1278e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1279e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1280d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1281d201456903f3ecae1f7794edfab0d5678e64226shiqian 1282e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that ScopedFakeTestPartResultReporter intercepts test 1283e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// failures. 1284e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 1285e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1286e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1287e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1288e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 1289e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &results); 1290e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1291e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1292e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1293d201456903f3ecae1f7794edfab0d5678e64226shiqian 1294e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(2, results.size()); 1295e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1296e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1297d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1298d201456903f3ecae1f7794edfab0d5678e64226shiqian 1299e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) { 1300e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1301e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1302e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Tests, that the deprecated constructor still works. 1303e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter(&results); 1304e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1305e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1306e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(1, results.size()); 1307d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1308d201456903f3ecae1f7794edfab0d5678e64226shiqian 130912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 1310e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1311e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterWithThreadsTest 1312e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian : public ScopedFakeTestPartResultReporterTest { 1313e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 1314e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailureInOtherThread(FailureMode failure) { 131512a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 131612a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan thread.Join(); 1317e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1318e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 1319e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1320e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterWithThreadsTest, 1321e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian InterceptsTestFailuresInAllThreads) { 1322e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1323e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1324e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1325e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results); 1326e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1327e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1328e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE); 1329e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(FATAL_FAILURE); 1330e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1331e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1332e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(4, results.size()); 1333e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1334e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1335e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed()); 1336e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed()); 1337d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1338d201456903f3ecae1f7794edfab0d5678e64226shiqian 133912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif // GTEST_IS_THREADSAFE 1340e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1341c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they 1342c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// work even if the failure is generated in a called function rather than 1343c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// the current context. 1344e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 134537504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest; 1346e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 134737504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) { 1348c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure."); 1349d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1350d201456903f3ecae1f7794edfab0d5678e64226shiqian 1351b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#if GTEST_HAS_GLOBAL_STRING 1352b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsStringObject) { 1353b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure.")); 1354b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1355b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#endif 1356b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 1357b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) { 1358b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), 1359b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::std::string("Expected fatal failure.")); 1360b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1361b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 136237504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) { 136337504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches fatal 136437504994338c114247519331237831f88a9a7c40zhanyong.wan // failures generated on another thread. 1365c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(), 1366e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1367d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1368d201456903f3ecae1f7794edfab0d5678e64226shiqian 1369c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1370c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true" 1371c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc 1372c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1373c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 137437504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void 137537504994338c114247519331237831f88a9a7c40zhanyong.wan// function even when the statement in it contains ASSERT_*. 137637504994338c114247519331237831f88a9a7c40zhanyong.wan 137737504994338c114247519331237831f88a9a7c40zhanyong.wanint NonVoidFunction() { 137837504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 137937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 138037504994338c114247519331237831f88a9a7c40zhanyong.wan return 0; 138137504994338c114247519331237831f88a9a7c40zhanyong.wan} 138237504994338c114247519331237831f88a9a7c40zhanyong.wan 138337504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) { 138437504994338c114247519331237831f88a9a7c40zhanyong.wan NonVoidFunction(); 138537504994338c114247519331237831f88a9a7c40zhanyong.wan} 138637504994338c114247519331237831f88a9a7c40zhanyong.wan 138737504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the 138837504994338c114247519331237831f88a9a7c40zhanyong.wan// current function even though 'statement' generates a fatal failure. 138937504994338c114247519331237831f88a9a7c40zhanyong.wan 139037504994338c114247519331237831f88a9a7c40zhanyong.wanvoid DoesNotAbortHelper(bool* aborted) { 139137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 139237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 139337504994338c114247519331237831f88a9a7c40zhanyong.wan 139437504994338c114247519331237831f88a9a7c40zhanyong.wan *aborted = false; 139537504994338c114247519331237831f88a9a7c40zhanyong.wan} 139637504994338c114247519331237831f88a9a7c40zhanyong.wan 1397c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1398d21c142eb89ce42817165368641329072e2ad8fbvladlosev// Restores warnings after previous "#pragma option push" suppressed them. 1399c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 1400c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1401c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 140237504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, DoesNotAbort) { 140337504994338c114247519331237831f88a9a7c40zhanyong.wan bool aborted = true; 140437504994338c114247519331237831f88a9a7c40zhanyong.wan DoesNotAbortHelper(&aborted); 140537504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FALSE(aborted); 1406d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1407d201456903f3ecae1f7794edfab0d5678e64226shiqian 140837504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a 140937504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 141037504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 1411d201456903f3ecae1f7794edfab0d5678e64226shiqian 1412e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianstatic int global_var = 0; 1413e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++ 1414d201456903f3ecae1f7794edfab0d5678e64226shiqian 141537504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1416d21c142eb89ce42817165368641329072e2ad8fbvladlosev#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 1417c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007. 1418e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE({ 1419e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1420c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1421e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1422c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1423d201456903f3ecae1f7794edfab0d5678e64226shiqian 1424e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS({ 1425e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1426c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1427e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 142837504994338c114247519331237831f88a9a7c40zhanyong.wan} 142937504994338c114247519331237831f88a9a7c40zhanyong.wan 143037504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}. 143137504994338c114247519331237831f88a9a7c40zhanyong.wan 143237504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest; 143337504994338c114247519331237831f88a9a7c40zhanyong.wan 143437504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) { 1435c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 143637504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 143737504994338c114247519331237831f88a9a7c40zhanyong.wan} 1438d201456903f3ecae1f7794edfab0d5678e64226shiqian 1439b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#if GTEST_HAS_GLOBAL_STRING 1440b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) { 1441b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 1442b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::string("Expected non-fatal failure.")); 1443b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1444b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#endif 1445b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 1446b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) { 1447b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 1448b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::std::string("Expected non-fatal failure.")); 1449b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1450b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 145137504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) { 145237504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches 145337504994338c114247519331237831f88a9a7c40zhanyong.wan // non-fatal failures generated on another thread. 1454c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(), 145537504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 145637504994338c114247519331237831f88a9a7c40zhanyong.wan} 145737504994338c114247519331237831f88a9a7c40zhanyong.wan 145837504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a 145937504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 146037504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 146137504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1462e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE({ 1463e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1464c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1465e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1466d201456903f3ecae1f7794edfab0d5678e64226shiqian 1467e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({ 1468e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1469c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1470e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1471d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1472d201456903f3ecae1f7794edfab0d5678e64226shiqian 147312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 1474d201456903f3ecae1f7794edfab0d5678e64226shiqian 1475e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqiantypedef ScopedFakeTestPartResultReporterWithThreadsTest 1476e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ExpectFailureWithThreadsTest; 1477d201456903f3ecae1f7794edfab0d5678e64226shiqian 1478e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) { 1479e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE), 1480e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1481e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 1482e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1483e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) { 1484e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS( 1485e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure."); 1486d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1487d201456903f3ecae1f7794edfab0d5678e64226shiqian 148812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif // GTEST_IS_THREADSAFE 1489e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1490c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan// Tests the TestProperty class. 1491c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1492c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanTEST(TestPropertyTest, ConstructorWorks) { 1493c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan const TestProperty property("key", "value"); 1494c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1495c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("value", property.value()); 1496c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan} 1497c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1498c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanTEST(TestPropertyTest, SetValue) { 1499c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan TestProperty property("key", "value_1"); 1500c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1501c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan property.SetValue("value_2"); 1502c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1503c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("value_2", property.value()); 1504c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan} 1505c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1506d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestResult class 1507d201456903f3ecae1f7794edfab0d5678e64226shiqian 1508d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestResult. 15099b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestResultTest : public Test { 1510d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 15110d27868d0faef474594682f25336229daa89d6d7zhanyong.wan typedef std::vector<TestPartResult> TPRVector; 1512d201456903f3ecae1f7794edfab0d5678e64226shiqian 1513d201456903f3ecae1f7794edfab0d5678e64226shiqian // We make use of 2 TestPartResult objects, 1514d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult * pr1, * pr2; 1515d201456903f3ecae1f7794edfab0d5678e64226shiqian 1516d201456903f3ecae1f7794edfab0d5678e64226shiqian // ... and 3 TestResult objects. 1517d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult * r0, * r1, * r2; 1518d201456903f3ecae1f7794edfab0d5678e64226shiqian 1519d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 1520d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr1 is for success. 1521e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan pr1 = new TestPartResult(TestPartResult::kSuccess, 1522e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "foo/bar.cc", 1523e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan 10, 1524e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "Success!"); 1525d201456903f3ecae1f7794edfab0d5678e64226shiqian 1526d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr2 is for fatal failure. 1527e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan pr2 = new TestPartResult(TestPartResult::kFatalFailure, 1528e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "foo/bar.cc", 15299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian -1, // This line number means "unknown" 15309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "Failure!"); 1531d201456903f3ecae1f7794edfab0d5678e64226shiqian 1532d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates the TestResult objects. 1533d201456903f3ecae1f7794edfab0d5678e64226shiqian r0 = new TestResult(); 1534d201456903f3ecae1f7794edfab0d5678e64226shiqian r1 = new TestResult(); 1535d201456903f3ecae1f7794edfab0d5678e64226shiqian r2 = new TestResult(); 1536d201456903f3ecae1f7794edfab0d5678e64226shiqian 1537d201456903f3ecae1f7794edfab0d5678e64226shiqian // In order to test TestResult, we need to modify its internal 15380d27868d0faef474594682f25336229daa89d6d7zhanyong.wan // state, in particular the TestPartResult vector it holds. 15390d27868d0faef474594682f25336229daa89d6d7zhanyong.wan // test_part_results() returns a const reference to this vector. 1540d201456903f3ecae1f7794edfab0d5678e64226shiqian // We cast it to a non-const object s.t. it can be modified (yes, 1541d201456903f3ecae1f7794edfab0d5678e64226shiqian // this is a hack). 15420d27868d0faef474594682f25336229daa89d6d7zhanyong.wan TPRVector* results1 = const_cast<TPRVector*>( 1543b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r1)); 15440d27868d0faef474594682f25336229daa89d6d7zhanyong.wan TPRVector* results2 = const_cast<TPRVector*>( 1545b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r2)); 1546d201456903f3ecae1f7794edfab0d5678e64226shiqian 1547d201456903f3ecae1f7794edfab0d5678e64226shiqian // r0 is an empty TestResult. 1548d201456903f3ecae1f7794edfab0d5678e64226shiqian 1549d201456903f3ecae1f7794edfab0d5678e64226shiqian // r1 contains a single SUCCESS TestPartResult. 15500d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results1->push_back(*pr1); 1551d201456903f3ecae1f7794edfab0d5678e64226shiqian 1552d201456903f3ecae1f7794edfab0d5678e64226shiqian // r2 contains a SUCCESS, and a FAILURE. 15530d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results2->push_back(*pr1); 15540d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results2->push_back(*pr2); 1555d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1556d201456903f3ecae1f7794edfab0d5678e64226shiqian 1557d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 1558d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr1; 1559d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr2; 1560d201456903f3ecae1f7794edfab0d5678e64226shiqian 1561d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r0; 1562d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r1; 1563d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r2; 1564d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1565e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1566e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Helper that compares two two TestPartResults. 1567600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan static void CompareTestPartResult(const TestPartResult& expected, 1568600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestPartResult& actual) { 1569600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.type(), actual.type()); 1570600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.file_name(), actual.file_name()); 1571600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.line_number(), actual.line_number()); 1572600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.summary(), actual.summary()); 1573600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.message(), actual.message()); 1574600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.passed(), actual.passed()); 1575600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.failed(), actual.failed()); 1576600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed()); 1577600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed()); 1578e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan } 1579d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1580d201456903f3ecae1f7794edfab0d5678e64226shiqian 1581b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::total_part_count(). 1582d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, total_part_count) { 1583b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->total_part_count()); 1584b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r1->total_part_count()); 1585b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, r2->total_part_count()); 1586d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1587d201456903f3ecae1f7794edfab0d5678e64226shiqian 1588e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Passed(). 1589d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Passed) { 1590d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r0->Passed()); 1591d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r1->Passed()); 1592d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r2->Passed()); 1593d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1594d201456903f3ecae1f7794edfab0d5678e64226shiqian 1595e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Failed(). 1596d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Failed) { 1597d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r0->Failed()); 1598d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r1->Failed()); 1599d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r2->Failed()); 1600d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1601d201456903f3ecae1f7794edfab0d5678e64226shiqian 1602e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestPartResult(). 1603600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1604600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef TestResultTest TestResultDeathTest; 1605600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1606600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(TestResultDeathTest, GetTestPartResult) { 1607600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr1, r2->GetTestPartResult(0)); 1608600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr2, r2->GetTestPartResult(1)); 16090d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), ""); 16100d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), ""); 1611e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1612e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1613b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has no properties when none are added. 1614d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 1615d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1616b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, test_result.test_property_count()); 1617d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1618d201456903f3ecae1f7794edfab0d5678e64226shiqian 1619b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has the expected property when added. 1620d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 1621d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1622d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key_1", "1"); 1623b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property); 1624b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, test_result.test_property_count()); 1625600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property = test_result.GetTestProperty(0); 1626600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property.key()); 1627600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property.value()); 1628d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1629d201456903f3ecae1f7794edfab0d5678e64226shiqian 1630b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has multiple properties when added. 1631d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 1632d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1633d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1("key_1", "1"); 1634d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2("key_2", "2"); 1635b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1); 1636b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2); 1637b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1638600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1639600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1640600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property_1.value()); 1641d201456903f3ecae1f7794edfab0d5678e64226shiqian 1642600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1643600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1644600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", actual_property_2.value()); 1645d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1646d201456903f3ecae1f7794edfab0d5678e64226shiqian 1647b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::RecordProperty() overrides values for duplicate keys. 1648d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 1649d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1650d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_1("key_1", "1"); 1651d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_1("key_2", "2"); 1652d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_2("key_1", "12"); 1653d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_2("key_2", "22"); 1654b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1_1); 1655b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2_1); 1656b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1_2); 1657b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2_2); 1658e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1659e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1660600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1661600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1662600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("12", actual_property_1.value()); 1663b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 1664600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1665600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1666600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("22", actual_property_2.value()); 1667e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1668e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1669e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestProperty(). 1670600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST(TestResultPropertyDeathTest, GetTestProperty) { 1671e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestResult test_result; 1672e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_1("key_1", "1"); 1673e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_2("key_2", "2"); 1674e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_3("key_3", "3"); 1675b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_1); 1676b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_2); 1677b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property_3); 1678e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1679600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_1 = test_result.GetTestProperty(0); 1680600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_2 = test_result.GetTestProperty(1); 1681600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_3 = test_result.GetTestProperty(2); 1682e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1683600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", fetched_property_1.key()); 1684600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", fetched_property_1.value()); 1685e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1686600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", fetched_property_2.key()); 1687600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", fetched_property_2.value()); 1688e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1689600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_3", fetched_property_3.key()); 1690600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("3", fetched_property_3.value()); 1691e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 16920d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), ""); 16930d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), ""); 1694e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1695e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1696d201456903f3ecae1f7794edfab0d5678e64226shiqian// When a property using a reserved key is supplied to this function, it tests 1697d201456903f3ecae1f7794edfab0d5678e64226shiqian// that a non-fatal failure is added, a fatal failure is not added, and that the 1698d201456903f3ecae1f7794edfab0d5678e64226shiqian// property is not recorded. 1699d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) { 1700d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 17014b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan TestProperty property(key, "1"); 1702b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan EXPECT_NONFATAL_FAILURE( 1703b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::RecordProperty(&test_result, property), 1704b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan "Reserved key"); 1705b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, test_result.test_property_count()) << "Not recorded"; 1706d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1707d201456903f3ecae1f7794edfab0d5678e64226shiqian 1708d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "name" 1709d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1710d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) { 1711d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("name"); 1712d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1713d201456903f3ecae1f7794edfab0d5678e64226shiqian 1714d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "status" 1715d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1716d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) { 1717d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("status"); 1718d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1719d201456903f3ecae1f7794edfab0d5678e64226shiqian 1720d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "time" 1721d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1722d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) { 1723d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("time"); 1724d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1725d201456903f3ecae1f7794edfab0d5678e64226shiqian 1726d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "classname" 1727d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1728d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) { 1729d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname"); 1730d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1731d201456903f3ecae1f7794edfab0d5678e64226shiqian 1732d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTestFlagSaver works on Windows and Mac. 1733d201456903f3ecae1f7794edfab0d5678e64226shiqian 17349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass GTestFlagSaverTest : public Test { 1735d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1736d201456903f3ecae1f7794edfab0d5678e64226shiqian // Saves the Google Test flags such that we can restore them later, and 1737d201456903f3ecae1f7794edfab0d5678e64226shiqian // then sets them to their default values. This will be called 1738d201456903f3ecae1f7794edfab0d5678e64226shiqian // before the first test in this test case is run. 1739d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 17409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian saver_ = new GTestFlagSaver; 17419b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1742fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 17439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = false; 17449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = false; 174553e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 17469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "auto"; 17479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = ""; 17489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = false; 17499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = ""; 1750f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 17518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 17529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 1; 17538bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 1754bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 1755a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = ""; 175640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 1757d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1758d201456903f3ecae1f7794edfab0d5678e64226shiqian 1759d201456903f3ecae1f7794edfab0d5678e64226shiqian // Restores the Google Test flags that the tests have modified. This will 1760d201456903f3ecae1f7794edfab0d5678e64226shiqian // be called after the last test in this test case is run. 1761d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 1762d201456903f3ecae1f7794edfab0d5678e64226shiqian delete saver_; 1763d201456903f3ecae1f7794edfab0d5678e64226shiqian saver_ = NULL; 1764d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1765d201456903f3ecae1f7794edfab0d5678e64226shiqian 1766d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the Google Test flags have their default values, and then 1767d201456903f3ecae1f7794edfab0d5678e64226shiqian // modifies each of them. 1768d201456903f3ecae1f7794edfab0d5678e64226shiqian void VerifyAndModifyFlags() { 1769fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests)); 17709b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 17719b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 17729b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 177353e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_FALSE(GTEST_FLAG(death_test_use_fork)); 17749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 17759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(list_tests)); 17769b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 1777f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan EXPECT_TRUE(GTEST_FLAG(print_time)); 17788bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(0, GTEST_FLAG(random_seed)); 17799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(1, GTEST_FLAG(repeat)); 17808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_FALSE(GTEST_FLAG(shuffle)); 1781bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth)); 1782a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str()); 178340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_FALSE(GTEST_FLAG(throw_on_failure)); 17849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1785fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = true; 17869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = true; 17879b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = true; 17889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "no"; 178953e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = true; 17909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = "abc"; 17919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = true; 17929b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = "xml:foo.xml"; 1793f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = false; 17948bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 1; 17959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 100; 17968bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = true; 1797bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = 1; 1798a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = "localhost:1234"; 179940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = true; 1800d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1801d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1802d201456903f3ecae1f7794edfab0d5678e64226shiqian // For saving Google Test flags during this test case. 18039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian static GTestFlagSaver* saver_; 1804d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1805d201456903f3ecae1f7794edfab0d5678e64226shiqian 18069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 1807d201456903f3ecae1f7794edfab0d5678e64226shiqian 1808d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test doesn't guarantee the order of tests. The following two 1809d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests are designed to work regardless of their order. 1810d201456903f3ecae1f7794edfab0d5678e64226shiqian 1811d201456903f3ecae1f7794edfab0d5678e64226shiqian// Modifies the Google Test flags in the test body. 1812d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 1813d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1814d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1815d201456903f3ecae1f7794edfab0d5678e64226shiqian 1816d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that the Google Test flags in the body of the previous test were 1817d201456903f3ecae1f7794edfab0d5678e64226shiqian// restored to their original values. 1818d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 1819d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1820d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1821d201456903f3ecae1f7794edfab0d5678e64226shiqian 1822d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets an environment variable with the given name to the given 1823d201456903f3ecae1f7794edfab0d5678e64226shiqian// value. If the value argument is "", unsets the environment 1824d201456903f3ecae1f7794edfab0d5678e64226shiqian// variable. The caller must ensure that both arguments are not NULL. 1825d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic void SetEnv(const char* name, const char* value) { 1826b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 1827d201456903f3ecae1f7794edfab0d5678e64226shiqian // Environment variables are not supported on Windows CE. 1828d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1829cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 1830c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder's putenv only stores a pointer to its parameter; we have to 1831c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ensure that the string remains valid as long as it might be needed. 1832c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We use an std::map to do so. 1833c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static std::map<String, String*> added_env; 1834c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1835c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Because putenv stores a pointer to the string buffer, we can't delete the 1836c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // previous string (if present) until after it's replaced. 1837c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan String *prev_env = NULL; 1838c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan if (added_env.find(name) != added_env.end()) { 1839c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan prev_env = added_env[name]; 1840c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 1841c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan added_env[name] = new String((Message() << name << "=" << value).GetString()); 1842cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev 1843cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // The standard signature of putenv accepts a 'char*' argument. Other 1844cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // implementations, like C++Builder's, accept a 'const char*'. 1845cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We cast away the 'const' since that would work for both variants. 1846cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev putenv(const_cast<char*>(added_env[name]->c_str())); 1847c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan delete prev_env; 18480af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#elif GTEST_OS_WINDOWS // If we are on Windows proper. 18499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian _putenv((Message() << name << "=" << value).GetString().c_str()); 1850d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1851d201456903f3ecae1f7794edfab0d5678e64226shiqian if (*value == '\0') { 1852d201456903f3ecae1f7794edfab0d5678e64226shiqian unsetenv(name); 1853d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1854d201456903f3ecae1f7794edfab0d5678e64226shiqian setenv(name, value, 1); 1855d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1856b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 1857d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1858d201456903f3ecae1f7794edfab0d5678e64226shiqian 1859b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1860d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variables are not supported on Windows CE. 1861d201456903f3ecae1f7794edfab0d5678e64226shiqian 18629b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::Int32FromGTestEnv; 1863d201456903f3ecae1f7794edfab0d5678e64226shiqian 1864d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests Int32FromGTestEnv(). 1865d201456903f3ecae1f7794edfab0d5678e64226shiqian 1866d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1867d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable is not set. 1868d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 18690af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", ""); 1870d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 1871d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1872d201456903f3ecae1f7794edfab0d5678e64226shiqian 1873d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1874d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable overflows as an Int32. 1875d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 1876d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1877d201456903f3ecae1f7794edfab0d5678e64226shiqian 18780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321"); 1879d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 1880d201456903f3ecae1f7794edfab0d5678e64226shiqian 18810af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321"); 1882d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 1883d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1884d201456903f3ecae1f7794edfab0d5678e64226shiqian 1885d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1886d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable does not represent a valid decimal integer. 1887d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 1888d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1889d201456903f3ecae1f7794edfab0d5678e64226shiqian 18900af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1"); 1891d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 1892d201456903f3ecae1f7794edfab0d5678e64226shiqian 18930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X"); 1894d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 1895d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1896d201456903f3ecae1f7794edfab0d5678e64226shiqian 1897d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() parses and returns the value of the 1898d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable when it represents a valid decimal integer in 1899d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1900d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 19010af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123"); 1902d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 1903d201456903f3ecae1f7794edfab0d5678e64226shiqian 19040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321"); 1905d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 1906d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1907b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 1908d201456903f3ecae1f7794edfab0d5678e64226shiqian 1909d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ParseInt32Flag(). 1910d201456903f3ecae1f7794edfab0d5678e64226shiqian 1911d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1912d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag has wrong format 1913d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 1914d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1915d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 1916d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1917d201456903f3ecae1f7794edfab0d5678e64226shiqian 1918d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 1919d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1920d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1921d201456903f3ecae1f7794edfab0d5678e64226shiqian 1922d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1923d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag overflows as an Int32. 1924d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 1925d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1926d201456903f3ecae1f7794edfab0d5678e64226shiqian 1927d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1928d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 1929d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1930d201456903f3ecae1f7794edfab0d5678e64226shiqian 1931d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 1932d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1933d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1934d201456903f3ecae1f7794edfab0d5678e64226shiqian 1935d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1936d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag does not represent a valid decimal 1937d201456903f3ecae1f7794edfab0d5678e64226shiqian// integer. 1938d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 1939d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1940d201456903f3ecae1f7794edfab0d5678e64226shiqian 1941d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1942d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 1943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1944d201456903f3ecae1f7794edfab0d5678e64226shiqian 1945d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 1946d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1947d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1948d201456903f3ecae1f7794edfab0d5678e64226shiqian 1949d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() parses the value of the flag and 1950d201456903f3ecae1f7794edfab0d5678e64226shiqian// returns true when the flag represents a valid decimal integer in 1951d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1952d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 1953d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 19540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value)); 1955d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(456, value); 1956d201456903f3ecae1f7794edfab0d5678e64226shiqian 1957c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", 1958c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "abc", &value)); 1959d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-789, value); 1960d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1961d201456903f3ecae1f7794edfab0d5678e64226shiqian 1962cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() parses the value of the var or 1963cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// returns the correct default. 19644853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 1965b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1966cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { 19670af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 19680af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); 19690af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 19700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123"); 19710af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 1972cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1973b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 1974cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1975cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1976cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable is not an Int32. 1977cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) { 19780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx"); 1979ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 1980600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1981600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1982cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1983cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1984cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1985cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable cannot be represnted by an Int32. 1986cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) { 19870af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234"); 1988ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 1989600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1990600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1991cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1992cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1993cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard() selects all tests 1994cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// where there is 1 shard. 1995cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) { 1996cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0)); 1997cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1)); 1998cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2)); 1999cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3)); 2000cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4)); 2001cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2002cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2003cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanclass ShouldShardTest : public testing::Test { 2004cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan protected: 2005cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void SetUp() { 20060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX"; 20070af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL"; 2008cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2009cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2010cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void TearDown() { 2011cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 2012cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 2013cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2014cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2015cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* index_var_; 2016cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* total_var_; 2017cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan}; 2018cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2019cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is disabled if neither of the environment variables 2020cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// are set. 2021cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) { 2022cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 2023cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 2024cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2025cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 2026cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 2027cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2028cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2029cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is not enabled if total_shards == 1. 2030cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) { 2031cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 2032cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "1"); 2033cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 2034cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 2035cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2036cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2037cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is enabled if total_shards > 1 and 2038cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// we are not in a death test subprocess. 20394853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 2040b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 2041cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { 2042cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 2043cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "22"); 2044cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 2045cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 2046cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2047cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "8"); 2048cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 2049cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 2050cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 2051cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2052cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 2053cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 2054cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 2055cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 2056cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2057b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 2058cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2059cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that we exit in error if the sharding values are not valid. 2060600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 2061600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef ShouldShardTest ShouldShardDeathTest; 2062600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 2063600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) { 2064cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 2065cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "4"); 2066ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 2067cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2068cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 2069cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "-2"); 2070ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 2071cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2072cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "5"); 2073cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 2074ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 2075cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2076cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 2077cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "5"); 2078ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 2079cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2080cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2081cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard is a partition when 5 2082cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// shards are used. 2083cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { 2084cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Choose an arbitrary number of tests and shards. 2085cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_tests = 17; 2086cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_shards = 5; 2087cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2088cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check partitioning: each test should be on exactly 1 shard. 2089cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 2090cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int prev_selected_shard_index = -1; 2091cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 2092cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) { 2093cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (prev_selected_shard_index < 0) { 2094cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan prev_selected_shard_index = shard_index; 2095cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } else { 2096cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and " 2097cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan << shard_index << " are both selected to run test " << test_id; 2098cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2099cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2100cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2101cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2102cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2103cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check balance: This is not required by the sharding protocol, but is a 2104cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // desirable property for performance. 2105cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 2106cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int num_tests_on_shard = 0; 2107cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 2108cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan num_tests_on_shard += 2109cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ShouldRunTestOnShard(num_shards, shard_index, test_id); 2110cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2111cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_GE(num_tests_on_shard, num_tests / num_shards); 2112cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 2113cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 2114cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 2115d201456903f3ecae1f7794edfab0d5678e64226shiqian// For the same reason we are not explicitly testing everything in the 2116019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Test class, there are no separate tests for the following classes 2117019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// (except for some trivial cases): 2118d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2119d201456903f3ecae1f7794edfab0d5678e64226shiqian// TestCase, UnitTest, UnitTestResultPrinter. 2120d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2121d201456903f3ecae1f7794edfab0d5678e64226shiqian// Similarly, there are no separate tests for the following macros: 2122d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2123d201456903f3ecae1f7794edfab0d5678e64226shiqian// TEST, TEST_F, RUN_ALL_TESTS 2124d201456903f3ecae1f7794edfab0d5678e64226shiqian 2125019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST(UnitTestTest, CanGetOriginalWorkingDir) { 2126019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 2127019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 2128019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 2129019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 2130d201456903f3ecae1f7794edfab0d5678e64226shiqian// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 2131d201456903f3ecae1f7794edfab0d5678e64226shiqian// of various arities. They do not attempt to be exhaustive. Rather, 2132d201456903f3ecae1f7794edfab0d5678e64226shiqian// view them as smoke tests that can be easily reviewed and verified. 2133d201456903f3ecae1f7794edfab0d5678e64226shiqian// A more complete set of tests for predicate assertions can be found 2134d201456903f3ecae1f7794edfab0d5678e64226shiqian// in gtest_pred_impl_unittest.cc. 2135d201456903f3ecae1f7794edfab0d5678e64226shiqian 2136d201456903f3ecae1f7794edfab0d5678e64226shiqian// First, some predicates and predicate-formatters needed by the tests. 2137d201456903f3ecae1f7794edfab0d5678e64226shiqian 2138d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the argument is an even number. 2139d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsEven(int n) { 2140d201456903f3ecae1f7794edfab0d5678e64226shiqian return (n % 2) == 0; 2141d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2142d201456903f3ecae1f7794edfab0d5678e64226shiqian 2143d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the argument is an even number. 2144d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct IsEvenFunctor { 2145d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n) { return IsEven(n); } 2146d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2147d201456903f3ecae1f7794edfab0d5678e64226shiqian 2148d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the argument is an even 2149d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 21509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertIsEven(const char* expr, int n) { 2151d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(n)) { 21529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2153d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2154d201456903f3ecae1f7794edfab0d5678e64226shiqian 21559b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2156d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << expr << " evaluates to " << n << ", which is not even."; 21579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2158d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2159d201456903f3ecae1f7794edfab0d5678e64226shiqian 2160bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// A predicate function that returns AssertionResult for use in 2161bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// EXPECT/ASSERT_TRUE/FALSE. 2162bad778caa39a88b7c11b159e20730aeec4fd711evladlosevAssertionResult ResultIsEven(int n) { 2163bad778caa39a88b7c11b159e20730aeec4fd711evladlosev if (IsEven(n)) 2164bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionSuccess() << n << " is even"; 2165bad778caa39a88b7c11b159e20730aeec4fd711evladlosev else 2166bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionFailure() << n << " is odd"; 2167bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 2168bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 2169bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// A predicate function that returns AssertionResult but gives no 2170bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// explanation why it succeeds. Needed for testing that 2171bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// EXPECT/ASSERT_FALSE handles such functions correctly. 2172bad778caa39a88b7c11b159e20730aeec4fd711evladlosevAssertionResult ResultIsEvenNoExplanation(int n) { 2173bad778caa39a88b7c11b159e20730aeec4fd711evladlosev if (IsEven(n)) 2174bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionSuccess(); 2175bad778caa39a88b7c11b159e20730aeec4fd711evladlosev else 2176bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionFailure() << n << " is odd"; 2177bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 2178bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 2179d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the argument is an even 2180d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 2181d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertIsEvenFunctor { 21829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()(const char* expr, int n) { 2183d201456903f3ecae1f7794edfab0d5678e64226shiqian return AssertIsEven(expr, n); 2184d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2185d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2186d201456903f3ecae1f7794edfab0d5678e64226shiqian 2187d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the sum of the arguments is an even number. 2188d201456903f3ecae1f7794edfab0d5678e64226shiqianbool SumIsEven2(int n1, int n2) { 2189d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2); 2190d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2191d201456903f3ecae1f7794edfab0d5678e64226shiqian 2192d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the sum of the arguments is an even 2193d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 2194d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct SumIsEven3Functor { 2195d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n1, int n2, int n3) { 2196d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2 + n3); 2197d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2198d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2199d201456903f3ecae1f7794edfab0d5678e64226shiqian 2200d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the sum of the 2201d201456903f3ecae1f7794edfab0d5678e64226shiqian// arguments is an even number. 22029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertSumIsEven4( 22039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 22049b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian int n1, int n2, int n3, int n4) { 2205d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4; 2206d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 22079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2208d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2209d201456903f3ecae1f7794edfab0d5678e64226shiqian 22109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2211d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 2212d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 2213d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 22149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2215d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2216d201456903f3ecae1f7794edfab0d5678e64226shiqian 2217d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the sum of the arguments 2218d201456903f3ecae1f7794edfab0d5678e64226shiqian// is an even number. 2219d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertSumIsEven5Functor { 22209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()( 22219b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 22229b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e5, int n1, int n2, int n3, int n4, int n5) { 2223d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4 + n5; 2224d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 22259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2226d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2227d201456903f3ecae1f7794edfab0d5678e64226shiqian 22289b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2229d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 2230d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" 2231d201456903f3ecae1f7794edfab0d5678e64226shiqian << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 2232d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 22339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2234d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2235d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2236d201456903f3ecae1f7794edfab0d5678e64226shiqian 2237d201456903f3ecae1f7794edfab0d5678e64226shiqian 2238d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions. 2239d201456903f3ecae1f7794edfab0d5678e64226shiqian 2240d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that don't use a custom formatter. 2241d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithoutFormat) { 2242d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2243d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 2244d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsEven, 4); 2245d201456903f3ecae1f7794edfab0d5678e64226shiqian 2246d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2247d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2248d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 2249d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2250d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 2251d201456903f3ecae1f7794edfab0d5678e64226shiqian "evaluates to false"); 2252d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2253d201456903f3ecae1f7794edfab0d5678e64226shiqian 2254d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that use a custom formatter. 2255d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithFormat) { 2256d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(AssertIsEven, 2); 2258d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 2259d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 2260d201456903f3ecae1f7794edfab0d5678e64226shiqian 2261d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2262d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n = 5; 2263d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 2264d201456903f3ecae1f7794edfab0d5678e64226shiqian "n evaluates to 5, which is not even."); 2265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2266d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 2267d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2268d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2269d201456903f3ecae1f7794edfab0d5678e64226shiqian 2270d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that unary predicate assertions evaluates their arguments 2271d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2272d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, SingleEvaluationOnFailure) { 2273d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2274d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 2275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, n++); 2276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 2277d201456903f3ecae1f7794edfab0d5678e64226shiqian 2278d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2280d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 2281d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2282d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 2284d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2285d201456903f3ecae1f7794edfab0d5678e64226shiqian 2286d201456903f3ecae1f7794edfab0d5678e64226shiqian 2287d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions whose arity is >= 2. 2288d201456903f3ecae1f7794edfab0d5678e64226shiqian 2289d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that don't use a custom formatter. 2290d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithoutFormat) { 2291d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2292d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 2293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 2294d201456903f3ecae1f7794edfab0d5678e64226shiqian 2295d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2296d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2297d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2298d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2299d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 2300d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2301d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2302d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 2303d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to false"); 2304d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2305d201456903f3ecae1f7794edfab0d5678e64226shiqian 2306d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that use a custom formatter. 2307d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithFormat) { 2308d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2309d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 2310d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is UNEXPECTED!"; 2311d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 2312d201456903f3ecae1f7794edfab0d5678e64226shiqian 2313d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2314d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2315d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2316d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n3 = 4; 2317d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n4 = 6; 2318d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2319d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 2320d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 13, which is not even."); 2321d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2322d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 2323d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2324d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2325d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2326d201456903f3ecae1f7794edfab0d5678e64226shiqian 2327d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that predicate assertions evaluates their arguments 2328d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2329d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, SingleEvaluationOnFailure) { 2330d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2331d201456903f3ecae1f7794edfab0d5678e64226shiqian int n1 = 0; 2332d201456903f3ecae1f7794edfab0d5678e64226shiqian int n2 = 0; 2333d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1++, n2++); 2334d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2335d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2336d201456903f3ecae1f7794edfab0d5678e64226shiqian 2337d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another success case. 2338d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = 0; 2339d201456903f3ecae1f7794edfab0d5678e64226shiqian int n3 = 0; 2340d201456903f3ecae1f7794edfab0d5678e64226shiqian int n4 = 0; 2341d201456903f3ecae1f7794edfab0d5678e64226shiqian int n5 = 0; 2342d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2343d201456903f3ecae1f7794edfab0d5678e64226shiqian n1++, n2++, n3++, n4++, n5++) 2344d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 2345d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2346d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2347d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2348d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2349d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 2350d201456903f3ecae1f7794edfab0d5678e64226shiqian 2351d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2352d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = 0; 2353d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2354d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 2355d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2356d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2357d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2358d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2359d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2360d201456903f3ecae1f7794edfab0d5678e64226shiqian 2361d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another failure case. 2362d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = n4 = 0; 2363d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2364d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 2365d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 1, which is not even."); 2366d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2367d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2370d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2371d201456903f3ecae1f7794edfab0d5678e64226shiqian 2372d201456903f3ecae1f7794edfab0d5678e64226shiqian 2373d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2374d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PREDn and EXPECT_PREDn. 2375d201456903f3ecae1f7794edfab0d5678e64226shiqian 2376d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(double x) { 2377d201456903f3ecae1f7794edfab0d5678e64226shiqian return x > 0; 2378d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2379d201456903f3ecae1f7794edfab0d5678e64226shiqian 2380d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 2381d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsNegative(T x) { 2382d201456903f3ecae1f7794edfab0d5678e64226shiqian return x < 0; 2383d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2384d201456903f3ecae1f7794edfab0d5678e64226shiqian 2385d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 2386d201456903f3ecae1f7794edfab0d5678e64226shiqianbool GreaterThan(T1 x1, T2 x2) { 2387d201456903f3ecae1f7794edfab0d5678e64226shiqian return x1 > x2; 2388d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2389d201456903f3ecae1f7794edfab0d5678e64226shiqian 2390d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED* as long as 2391d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2392d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 2393c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder requires C-style casts rather than static_cast. 2394c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT 2395c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT 2396d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2397d201456903f3ecae1f7794edfab0d5678e64226shiqian 2398d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED* as long as 2399d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2400d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 2401d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsNegative<int>, -5); 2402d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes sure that we can handle templates with more than one 2403d201456903f3ecae1f7794edfab0d5678e64226shiqian // parameter. 2404d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 2405d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2406d201456903f3ecae1f7794edfab0d5678e64226shiqian 2407d201456903f3ecae1f7794edfab0d5678e64226shiqian 2408d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2409d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 2410d201456903f3ecae1f7794edfab0d5678e64226shiqian 24114b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, int n) { 24129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return n > 0 ? AssertionSuccess() : 24139b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2414d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2415d201456903f3ecae1f7794edfab0d5678e64226shiqian 24164b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, double x) { 24179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x > 0 ? AssertionSuccess() : 24189b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2419d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2420d201456903f3ecae1f7794edfab0d5678e64226shiqian 2421d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 24224b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsNegativeFormat(const char* /* expr */, T x) { 24239b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x < 0 ? AssertionSuccess() : 24249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2425d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2426d201456903f3ecae1f7794edfab0d5678e64226shiqian 2427d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 24284b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */, 24299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const T1& x1, const T2& x2) { 24309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x1 == x2 ? AssertionSuccess() : 24319b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2432d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2433d201456903f3ecae1f7794edfab0d5678e64226shiqian 2434d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED_FORMAT* 24354b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan// without explicitly specifying their types. 2436d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 2437d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 2438d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 2439d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2440d201456903f3ecae1f7794edfab0d5678e64226shiqian 2441d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED_FORMAT* without 2442d201456903f3ecae1f7794edfab0d5678e64226shiqian// explicitly specifying their types. 2443d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 2444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 2445d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 2446d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2447d201456903f3ecae1f7794edfab0d5678e64226shiqian 2448d201456903f3ecae1f7794edfab0d5678e64226shiqian 2449d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests string assertions. 2450d201456903f3ecae1f7794edfab0d5678e64226shiqian 2451d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with non-NULL arguments. 2452d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ) { 2453d201456903f3ecae1f7794edfab0d5678e64226shiqian const char * const p1 = "good"; 2454d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p1); 2455d201456903f3ecae1f7794edfab0d5678e64226shiqian 2456d201456903f3ecae1f7794edfab0d5678e64226shiqian // Let p2 have the same content as p1, but be at a different address. 2457d201456903f3ecae1f7794edfab0d5678e64226shiqian const char p2[] = "good"; 2458d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p2); 2459d201456903f3ecae1f7794edfab0d5678e64226shiqian 2460d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 2461d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: \"bad\""); 2462d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2463d201456903f3ecae1f7794edfab0d5678e64226shiqian 2464d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2465d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null) { 2466d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 2467d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 2468d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2469d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2470d201456903f3ecae1f7794edfab0d5678e64226shiqian 2471d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2472d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 2473d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 2474d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2475d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2476d201456903f3ecae1f7794edfab0d5678e64226shiqian 2477d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRNE. 2478d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRNE) { 2479d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("hi", "Hi"); 2480d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", NULL); 2481d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, "Hi"); 2482d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", NULL); 2483d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, ""); 2484d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", "Hi"); 2485d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", ""); 2486d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 2487d201456903f3ecae1f7794edfab0d5678e64226shiqian "\"Hi\" vs \"Hi\""); 2488d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2489d201456903f3ecae1f7794edfab0d5678e64226shiqian 2490d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASEEQ. 2491d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 2492d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("hi", "Hi"); 2493d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 2494d201456903f3ecae1f7794edfab0d5678e64226shiqian 2495d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("", ""); 2496d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 2497d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2498d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2499d201456903f3ecae1f7794edfab0d5678e64226shiqian 2500d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASENE. 2501d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASENE) { 2502d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("hi1", "Hi2"); 2503d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", NULL); 2504d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, "Hi"); 2505d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", NULL); 2506d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, ""); 2507d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", "Hi"); 2508d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", ""); 2509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 2510d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2511d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2512d201456903f3ecae1f7794edfab0d5678e64226shiqian 2513d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STREQ on wide strings. 2514d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STREQ_Wide) { 2515d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2516d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 2517d201456903f3ecae1f7794edfab0d5678e64226shiqian 2518d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2519d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(L"", L""); 2520d201456903f3ecae1f7794edfab0d5678e64226shiqian 2521d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2522d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 2523d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2524d201456903f3ecae1f7794edfab0d5678e64226shiqian 2525d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2526d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(L"Hi", L"Hi"); 2527d201456903f3ecae1f7794edfab0d5678e64226shiqian 2528d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 2530d201456903f3ecae1f7794edfab0d5678e64226shiqian "Abc"); 2531d201456903f3ecae1f7794edfab0d5678e64226shiqian 2532d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2533d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 2534d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2535d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2536d201456903f3ecae1f7794edfab0d5678e64226shiqian 2537d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STRNE on wide strings. 2538d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STRNE_Wide) { 2539d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2541d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 2542d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 2543d201456903f3ecae1f7794edfab0d5678e64226shiqian 2544d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2545d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 2546d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"\""); 2547d201456903f3ecae1f7794edfab0d5678e64226shiqian 2548d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2549d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(L"non-null", NULL); 2550d201456903f3ecae1f7794edfab0d5678e64226shiqian 2551d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2552d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 2553d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"Hi\""); 2554d201456903f3ecae1f7794edfab0d5678e64226shiqian 2555d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2556d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(L"abc", L"Abc"); 2557d201456903f3ecae1f7794edfab0d5678e64226shiqian 2558d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2559d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 2560d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2561d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2562d201456903f3ecae1f7794edfab0d5678e64226shiqian 2563d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsSubstring(). 2564d201456903f3ecae1f7794edfab0d5678e64226shiqian 2565d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2566d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2567d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 2568d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 2569d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 2570d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 2571d201456903f3ecae1f7794edfab0d5678e64226shiqian 2572d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 2573d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 2574d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2575d201456903f3ecae1f7794edfab0d5678e64226shiqian 2576d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2577d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2578d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 2579c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", kNull, L"a")); 2580c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", L"b", kNull)); 2581d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 2582d201456903f3ecae1f7794edfab0d5678e64226shiqian 2583d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 2584d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 2585d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2586d201456903f3ecae1f7794edfab0d5678e64226shiqian 2587d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2588d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2589d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 2590d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2591d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2592d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2593d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"haystack\"", 25949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring("needle_expr", "haystack_expr", 25959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "needle", "haystack").failure_message()); 2596d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2597d201456903f3ecae1f7794edfab0d5678e64226shiqian 2598d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2599d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2600d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 26019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 26029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 2603d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2604d201456903f3ecae1f7794edfab0d5678e64226shiqian 2605d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2606d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2607d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2608d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 2609d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2610d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2611d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2612d201456903f3ecae1f7794edfab0d5678e64226shiqian 2613d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2614d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2615d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 2616d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2617d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2618d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2619d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"haystack\"", 26209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring( 2621d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2622d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring(L"needle"), L"haystack").failure_message()); 2623d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2624d201456903f3ecae1f7794edfab0d5678e64226shiqian 2625d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2626d201456903f3ecae1f7794edfab0d5678e64226shiqian 2627d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsNotSubstring(). 2628d201456903f3ecae1f7794edfab0d5678e64226shiqian 2629d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2630d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2631d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 2632d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 2633d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 2634d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2635d201456903f3ecae1f7794edfab0d5678e64226shiqian 2636d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2637d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2638d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 2639d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 2640d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 2641d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2642d201456903f3ecae1f7794edfab0d5678e64226shiqian 2643d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2644d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2645d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 2646d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2647d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2648d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2649d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"two needles\"", 26509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2651d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2652d201456903f3ecae1f7794edfab0d5678e64226shiqian L"needle", L"two needles").failure_message()); 2653d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2654d201456903f3ecae1f7794edfab0d5678e64226shiqian 2655d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2656d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2657d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 2658d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 2659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 2660d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2661d201456903f3ecae1f7794edfab0d5678e64226shiqian 2662d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2663d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2664d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 2665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2666d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2667d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2668d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"two needles\"", 26699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2670d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2671d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::string("needle"), "two needles").failure_message()); 2672d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2673d201456903f3ecae1f7794edfab0d5678e64226shiqian 2674d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2675d201456903f3ecae1f7794edfab0d5678e64226shiqian 2676d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2677d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2678d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 2679d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE( 2680d201456903f3ecae1f7794edfab0d5678e64226shiqian IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2681d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2682d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2683d201456903f3ecae1f7794edfab0d5678e64226shiqian 2684d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2685d201456903f3ecae1f7794edfab0d5678e64226shiqian 2686d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests floating-point assertions. 2687d201456903f3ecae1f7794edfab0d5678e64226shiqian 2688d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 26899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FloatingPointTest : public Test { 2690d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2691c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2692c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Pre-calculated numbers to be used by the tests. 2693c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan struct TestValues { 2694c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_positive_zero; 2695c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_negative_zero; 2696c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_negative_zero; 2697c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2698c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_one; 2699c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_one; 2700c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2701c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType infinity; 2702c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_infinity; 2703c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_infinity; 2704c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2705c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan1; 2706c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan2; 2707c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }; 2708c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2709d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename testing::internal::FloatingPoint<RawType> Floating; 2710d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename Floating::Bits Bits; 2711d201456903f3ecae1f7794edfab0d5678e64226shiqian 2712d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 2713d201456903f3ecae1f7794edfab0d5678e64226shiqian const size_t max_ulps = Floating::kMaxUlps; 2714d201456903f3ecae1f7794edfab0d5678e64226shiqian 2715d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 0.0. 2716d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits zero_bits = Floating(0).bits(); 2717d201456903f3ecae1f7794edfab0d5678e64226shiqian 2718d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 0.0. 2719c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_positive_zero = Floating::ReinterpretBits( 2720c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan zero_bits + max_ulps/2); 2721c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_negative_zero = -Floating::ReinterpretBits( 2722d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps - max_ulps/2); 2723c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_negative_zero = -Floating::ReinterpretBits( 2724d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps + 1 - max_ulps/2); 2725d201456903f3ecae1f7794edfab0d5678e64226shiqian 2726d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 1.0. 2727d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits one_bits = Floating(1).bits(); 2728d201456903f3ecae1f7794edfab0d5678e64226shiqian 2729d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 1.0. 2730c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps); 2731c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_one = Floating::ReinterpretBits( 2732c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan one_bits + max_ulps + 1); 2733d201456903f3ecae1f7794edfab0d5678e64226shiqian 2734d201456903f3ecae1f7794edfab0d5678e64226shiqian // +infinity. 2735c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.infinity = Floating::Infinity(); 2736d201456903f3ecae1f7794edfab0d5678e64226shiqian 2737d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent +infinity. 2738c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const Bits infinity_bits = Floating(values_.infinity).bits(); 2739d201456903f3ecae1f7794edfab0d5678e64226shiqian 2740d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to infinity. 2741c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_infinity = Floating::ReinterpretBits( 2742c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan infinity_bits - max_ulps); 2743c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_infinity = Floating::ReinterpretBits( 2744d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_bits - max_ulps - 1); 2745d201456903f3ecae1f7794edfab0d5678e64226shiqian 2746c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Makes some NAN's. Sets the most significant bit of the fraction so that 2747c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // our NaN's are quiet; trying to process a signaling NaN would raise an 2748c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // exception if our environment enables floating point exceptions. 2749c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask 2750c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1); 2751c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask 2752c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200); 2753d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2754d201456903f3ecae1f7794edfab0d5678e64226shiqian 2755d201456903f3ecae1f7794edfab0d5678e64226shiqian void TestSize() { 2756d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2757d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2758d201456903f3ecae1f7794edfab0d5678e64226shiqian 2759c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static TestValues values_; 2760d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2761d201456903f3ecae1f7794edfab0d5678e64226shiqian 2762d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 2763c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wantypename FloatingPointTest<RawType>::TestValues 2764c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FloatingPointTest<RawType>::values_; 2765d201456903f3ecae1f7794edfab0d5678e64226shiqian 2766d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 2767d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<float> FloatTest; 2768d201456903f3ecae1f7794edfab0d5678e64226shiqian 2769d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Float::Bits matches the size of float. 2770d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Size) { 2771d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2772d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2773d201456903f3ecae1f7794edfab0d5678e64226shiqian 2774d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2775d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Zeros) { 2776d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, -0.0); 2777d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 2778d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2779d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 2780d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.5"); 2781d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2782d201456903f3ecae1f7794edfab0d5678e64226shiqian 2783d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2784d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2785d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_FLOAT_EQ handles the sign correctly and no 2786d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2787d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2788d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, AlmostZeros) { 2789c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2790c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2791c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2792cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2793cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2794cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2795cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const FloatTest::TestValues& v = this->values_; 2796c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2797c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero); 2798c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero); 2799c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2800d201456903f3ecae1f7794edfab0d5678e64226shiqian 2801d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2802c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(v.close_to_positive_zero, 2803c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2804c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2805d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2806d201456903f3ecae1f7794edfab0d5678e64226shiqian 2807d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2808d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, SmallDiff) { 2809c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(1.0, values_.close_to_one); 2810c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one), 2811c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2812d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2813d201456903f3ecae1f7794edfab0d5678e64226shiqian 2814d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2815d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, LargeDiff) { 2816d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 2817d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2818d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2819d201456903f3ecae1f7794edfab0d5678e64226shiqian 2820d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2821d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2822d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2823d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2824d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Infinity) { 2825c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity); 2826c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity); 28270af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2828e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2829c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity), 2830c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2831d201456903f3ecae1f7794edfab0d5678e64226shiqian 2832c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This is interesting as the representations of infinity and nan1 2833d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2834c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1), 2835c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 28360af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2837d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2838d201456903f3ecae1f7794edfab0d5678e64226shiqian 2839d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2840d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, NaN) { 28410af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2842e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Nokia's STLport crashes if we try to output infinity or NaN. 2843c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2844c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2845c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2846c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2847cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2848cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2849cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2850cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const FloatTest::TestValues& v = this->values_; 2851c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2852c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), 2853c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2854c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), 2855c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan2"); 2856c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), 2857c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2858c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2859c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), 2860c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 28610af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2862d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2863d201456903f3ecae1f7794edfab0d5678e64226shiqian 2864d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are reflexive. 2865d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Reflexive) { 2866d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, 0.0); 2867d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0); 2868c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(values_.infinity, values_.infinity); 2869d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2870d201456903f3ecae1f7794edfab0d5678e64226shiqian 2871d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are commutative. 2872d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Commutative) { 2873c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one). 2874c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.close_to_one, 1.0); 2875d201456903f3ecae1f7794edfab0d5678e64226shiqian 2876c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one). 2877c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0), 2878d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2879d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2880d201456903f3ecae1f7794edfab0d5678e64226shiqian 2881d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2882d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, EXPECT_NEAR) { 2883d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 2884d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0f, 3.0f, 1.0f); 2885e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 2886e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0f and 1.5f is 0.5, " 2887e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25f"); 2888d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2889d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2890d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2891d201456903f3ecae1f7794edfab0d5678e64226shiqian 2892d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2893d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, ASSERT_NEAR) { 2894d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 2895d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0f, 3.0f, 1.0f); 2896e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 2897e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0f and 1.5f is 0.5, " 2898e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25f"); 2899d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2900d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2901d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2902d201456903f3ecae1f7794edfab0d5678e64226shiqian 2903d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should succeed. 2904d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLESucceeds) { 29059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 29069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 2907d201456903f3ecae1f7794edfab0d5678e64226shiqian 2908d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2909c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f); 2910d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2911d201456903f3ecae1f7794edfab0d5678e64226shiqian 2912d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should fail. 2913d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLEFails) { 2914d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 29159b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 2916d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0f) <= (1.0f)"); 2917d201456903f3ecae1f7794edfab0d5678e64226shiqian 2918d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2919d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2920c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f); 2921c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0f)"); 2922d201456903f3ecae1f7794edfab0d5678e64226shiqian 2923c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2924e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2925c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2926c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2927d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2928c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity); 2929c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2930d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2931c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1); 2932c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(-values_.infinity) <= (values_.nan1)"); 2933d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2934c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1); 2935c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2936c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2937d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2938d201456903f3ecae1f7794edfab0d5678e64226shiqian 2939d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 2940d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<double> DoubleTest; 2941d201456903f3ecae1f7794edfab0d5678e64226shiqian 2942d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Double::Bits matches the size of double. 2943d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Size) { 2944d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2945d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2946d201456903f3ecae1f7794edfab0d5678e64226shiqian 2947d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2948d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Zeros) { 2949d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, -0.0); 2950d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 2951d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2952d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 2953d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2954d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2955d201456903f3ecae1f7794edfab0d5678e64226shiqian 2956d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2957d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2958d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_DOUBLE_EQ handles the sign correctly and no 2959d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2960d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2961d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, AlmostZeros) { 2962c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2963c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2964c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2965cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2966cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2967cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2968cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const DoubleTest::TestValues& v = this->values_; 2969c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2970c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero); 2971c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero); 2972c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2973d201456903f3ecae1f7794edfab0d5678e64226shiqian 2974d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2975c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(v.close_to_positive_zero, 2976c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2977c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2978d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2979d201456903f3ecae1f7794edfab0d5678e64226shiqian 2980d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2981d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, SmallDiff) { 2982c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(1.0, values_.close_to_one); 2983c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one), 2984c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2985d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2986d201456903f3ecae1f7794edfab0d5678e64226shiqian 2987d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2988d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, LargeDiff) { 2989d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 2990d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2991d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2992d201456903f3ecae1f7794edfab0d5678e64226shiqian 2993d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2994d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2995d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2996d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2997d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Infinity) { 2998c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity); 2999c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity); 30000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3001e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3002c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity), 3003c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 3004d201456903f3ecae1f7794edfab0d5678e64226shiqian 3005d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 3006d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 3007c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1), 3008c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 30090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3010d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3011d201456903f3ecae1f7794edfab0d5678e64226shiqian 3012d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 3013d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, NaN) { 30140af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3015c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 3016c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 3017c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 3018cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 3019cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 3020cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 3021cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const DoubleTest::TestValues& v = this->values_; 3022c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3023e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3024c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), 3025c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 3026c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2"); 3027c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1"); 3028c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), 3029c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 30300af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3031d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3032d201456903f3ecae1f7794edfab0d5678e64226shiqian 3033d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are reflexive. 3034d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Reflexive) { 3035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, 0.0); 3036d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, 1.0); 30370af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3038e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3039c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity); 30400af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3041d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3042d201456903f3ecae1f7794edfab0d5678e64226shiqian 3043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are commutative. 3044d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Commutative) { 3045c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one). 3046c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0); 3047d201456903f3ecae1f7794edfab0d5678e64226shiqian 3048c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one). 3049c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0), 3050c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "1.0"); 3051d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3052d201456903f3ecae1f7794edfab0d5678e64226shiqian 3053d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 3054d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, EXPECT_NEAR) { 3055d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0, -1.1, 0.2); 3056d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0, 3.0, 1.0); 3057e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25), // NOLINT 3058e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0 and 1.5 is 0.5, " 3059e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25"); 3060d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 3061d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 3062d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3063d201456903f3ecae1f7794edfab0d5678e64226shiqian 3064d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 3065d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, ASSERT_NEAR) { 3066d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0, -1.1, 0.2); 3067d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0, 3.0, 1.0); 3068e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25), // NOLINT 3069e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0 and 1.5 is 0.5, " 3070e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25"); 3071d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 3072d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 3073d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3074d201456903f3ecae1f7794edfab0d5678e64226shiqian 3075d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should succeed. 3076d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLESucceeds) { 30779b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 30789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 3079d201456903f3ecae1f7794edfab0d5678e64226shiqian 3080d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 3081c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0); 3082d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3083d201456903f3ecae1f7794edfab0d5678e64226shiqian 3084d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should fail. 3085d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLEFails) { 3086d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 30879b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 3088d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0) <= (1.0)"); 3089d201456903f3ecae1f7794edfab0d5678e64226shiqian 3090d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 3091d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3092c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0); 3093c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0)"); 3094d201456903f3ecae1f7794edfab0d5678e64226shiqian 3095c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 3096e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3097c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 3098c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 3099d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3100c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity); 3101c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 3102d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3103c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1); 3104c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, " (-values_.infinity) <= (values_.nan1)"); 3105d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3106c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1); 3107c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 3108c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 3109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3110d201456903f3ecae1f7794edfab0d5678e64226shiqian 3111d201456903f3ecae1f7794edfab0d5678e64226shiqian 3112d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that a test or test case whose name starts with DISABLED_ is 3113d201456903f3ecae1f7794edfab0d5678e64226shiqian// not run. 3114d201456903f3ecae1f7794edfab0d5678e64226shiqian 3115d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name starts with DISABLED_. 3116d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3117d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, DISABLED_TestShouldNotRun) { 3118d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3119d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3120d201456903f3ecae1f7794edfab0d5678e64226shiqian 3121d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name does not start with DISABLED_. 3122d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should run. 3123d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, NotDISABLED_TestShouldRun) { 3124d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1); 3125d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3126d201456903f3ecae1f7794edfab0d5678e64226shiqian 3127d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case whose name starts with DISABLED_. 3128d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3129d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, TestShouldNotRun) { 3130d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 3131d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3132d201456903f3ecae1f7794edfab0d5678e64226shiqian 3133d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case and test whose names start with DISABLED_. 3134d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3135d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 3136d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 3137d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3138d201456903f3ecae1f7794edfab0d5678e64226shiqian 3139d201456903f3ecae1f7794edfab0d5678e64226shiqian// Check that when all tests in a test case are disabled, SetupTestCase() and 3140d201456903f3ecae1f7794edfab0d5678e64226shiqian// TearDownTestCase() are not called. 31419b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass DisabledTestsTest : public Test { 3142d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3143d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 3144d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 3145d201456903f3ecae1f7794edfab0d5678e64226shiqian "SetupTestCase() should not be called."; 3146d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3147d201456903f3ecae1f7794edfab0d5678e64226shiqian 3148d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 3149d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 3150d201456903f3ecae1f7794edfab0d5678e64226shiqian "TearDownTestCase() should not be called."; 3151d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3152d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3153d201456903f3ecae1f7794edfab0d5678e64226shiqian 3154d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 3155d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3156d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3157d201456903f3ecae1f7794edfab0d5678e64226shiqian 3158d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 3159d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3160d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3161d201456903f3ecae1f7794edfab0d5678e64226shiqian 3162a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled typed tests aren't run. 3163a2b1a8556ea64014606d78b09333d9c522430a25shiqian 31640af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST 3165a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3166a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3167a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTest : public Test { 3168a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3169a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3170a2b1a8556ea64014606d78b09333d9c522430a25shiqiantypedef testing::Types<int, double> NumericTypes; 3171a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(TypedTest, NumericTypes); 3172a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3173a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 3174a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 3175a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3176a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3177a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3178a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTest : public Test { 3179a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3180a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3181a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 3182a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3183a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 3184a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 3185a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3186a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3187a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST 3188a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3189a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled type-parameterized tests aren't run. 3190a2b1a8556ea64014606d78b09333d9c522430a25shiqian 31910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST_P 3192a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3193a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3194a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTestP : public Test { 3195a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3196a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3197a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(TypedTestP); 3198a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3199a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 3200a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 3201a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 3202a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3203a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3204a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 3205a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3206a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 3207a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3208a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3209a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTestP : public Test { 3210a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3211a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3212a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(DISABLED_TypedTestP); 3213a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3214a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 3215a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 3216a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 3217a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3218a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3219a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 3220a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3221a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 3222a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3223a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST_P 3224d201456903f3ecae1f7794edfab0d5678e64226shiqian 3225d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion macros evaluate their arguments exactly once. 3226d201456903f3ecae1f7794edfab0d5678e64226shiqian 32279b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SingleEvaluationTest : public Test { 32288de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 3229d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_STREQ test 3230c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // below. It's public to work around C++Builder's bug with scoping local 3231c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // classes. 3232d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementCharPtrs() { 3233d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1_++, p2_++); 3234d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3235d201456903f3ecae1f7794edfab0d5678e64226shiqian 3236c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This helper function is needed by the FailedASSERT_NE test below. It's 3237c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // public to work around C++Builder's bug with scoping local classes. 3238d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementInts() { 3239d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(a_++, b_++); 3240d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3241d201456903f3ecae1f7794edfab0d5678e64226shiqian 3242c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan protected: 3243c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan SingleEvaluationTest() { 3244c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p1_ = s1_; 3245c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p2_ = s2_; 3246c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan a_ = 0; 3247c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan b_ = 0; 3248c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 3249c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3250d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s1_; 3251d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s2_; 3252d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p1_; 3253d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p2_; 3254d201456903f3ecae1f7794edfab0d5678e64226shiqian 3255d201456903f3ecae1f7794edfab0d5678e64226shiqian static int a_; 3256d201456903f3ecae1f7794edfab0d5678e64226shiqian static int b_; 3257d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3258d201456903f3ecae1f7794edfab0d5678e64226shiqian 3259d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s1_ = "01234"; 3260d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s2_ = "abcde"; 3261d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p1_; 3262d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p2_; 3263d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::a_; 3264d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::b_; 3265d201456903f3ecae1f7794edfab0d5678e64226shiqian 3266d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_STREQ fails, it evaluates its arguments 3267d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 3268d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 3269c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(), 3270d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2_++"); 3271d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3272d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3273d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3274d201456903f3ecae1f7794edfab0d5678e64226shiqian 3275d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that string assertion arguments are evaluated exactly once. 3276d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, ASSERT_STR) { 3277d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_STRNE 3278d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(p1_++, p2_++); 3279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3280d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3281d201456903f3ecae1f7794edfab0d5678e64226shiqian 3282d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_STRCASEEQ 3283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 3284d201456903f3ecae1f7794edfab0d5678e64226shiqian "ignoring case"); 3285d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 2, p1_); 3286d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 2, p2_); 3287d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3288d201456903f3ecae1f7794edfab0d5678e64226shiqian 3289d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 3290d201456903f3ecae1f7794edfab0d5678e64226shiqian// once. 3291d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 3292c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(), 3293c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "(a_++) != (b_++)"); 3294d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3296d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3297d201456903f3ecae1f7794edfab0d5678e64226shiqian 3298d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion arguments are evaluated exactly once. 3299d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, OtherCases) { 3300d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_TRUE 3301d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(0 == a_++); // NOLINT 3302d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3303d201456903f3ecae1f7794edfab0d5678e64226shiqian 3304d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_TRUE 3305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 3306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a_); 3307d201456903f3ecae1f7794edfab0d5678e64226shiqian 3308d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_GT 3309d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(a_++, b_++); 3310d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a_); 3311d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3312d201456903f3ecae1f7794edfab0d5678e64226shiqian 3313d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_LT 3314d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 3315d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a_); 3316d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, b_); 3317d201456903f3ecae1f7794edfab0d5678e64226shiqian 3318d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_TRUE 3319d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(0 < a_++); // NOLINT 3320d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, a_); 3321d201456903f3ecae1f7794edfab0d5678e64226shiqian 3322d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_GT 3323d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(a_++, b_++); 3324d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(6, a_); 3325d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, b_); 3326d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3327d201456903f3ecae1f7794edfab0d5678e64226shiqian 332836865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 332936865d8d354465e3461eedf2949a4b7799985d5dshiqian 333036865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAnInteger() { 333136865d8d354465e3461eedf2949a4b7799985d5dshiqian throw 1; 333236865d8d354465e3461eedf2949a4b7799985d5dshiqian} 333336865d8d354465e3461eedf2949a4b7799985d5dshiqian 333436865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests that assertion arguments are evaluated exactly once. 333536865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST_F(SingleEvaluationTest, ExceptionTests) { 333636865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_THROW 333736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW({ // NOLINT 333836865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 333936865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 334036865d8d354465e3461eedf2949a4b7799985d5dshiqian }, int); 334136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(1, a_); 334236865d8d354465e3461eedf2949a4b7799985d5dshiqian 334336865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws different 334436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 334536865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 334636865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 334736865d8d354465e3461eedf2949a4b7799985d5dshiqian }, bool), "throws a different type"); 334836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(2, a_); 334936865d8d354465e3461eedf2949a4b7799985d5dshiqian 335036865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws nothing 335136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 335236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(3, a_); 335336865d8d354465e3461eedf2949a4b7799985d5dshiqian 335436865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_NO_THROW 335536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(a_++); 335636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(4, a_); 335736865d8d354465e3461eedf2949a4b7799985d5dshiqian 335836865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_NO_THROW 335936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 336036865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 336136865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 336236865d8d354465e3461eedf2949a4b7799985d5dshiqian }), "it throws"); 336336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(5, a_); 336436865d8d354465e3461eedf2949a4b7799985d5dshiqian 336536865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_ANY_THROW 336636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW({ // NOLINT 336736865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 336836865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 336936865d8d354465e3461eedf2949a4b7799985d5dshiqian }); 337036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(6, a_); 337136865d8d354465e3461eedf2949a4b7799985d5dshiqian 337236865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_ANY_THROW 337336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 337436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(7, a_); 337536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 337636865d8d354465e3461eedf2949a4b7799985d5dshiqian 337736865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 3378d201456903f3ecae1f7794edfab0d5678e64226shiqian 3379e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE. 3380e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass NoFatalFailureTest : public Test { 3381e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 3382e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Succeeds() {} 3383e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void FailsNonFatal() { 3384e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "some non-fatal failure"; 3385e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3386e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Fails() { 3387e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FAIL() << "some fatal failure"; 3388e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3389e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3390e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoAssertNoFatalFailureOnFails() { 3391e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Fails()); 3392e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "shold not reach here."; 3393e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3394e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3395e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoExpectNoFatalFailureOnFails() { 3396e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Fails()); 3397e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "other failure"; 3398e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3399e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 3400e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3401e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NoFailure) { 3402e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Succeeds()); 3403e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Succeeds()); 3404e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3405e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3406e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NonFatalIsNoFailure) { 3407e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3408e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FailsNonFatal()), 3409e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3410e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3411e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FailsNonFatal()), 3412e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3413e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3414e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3415e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) { 3416e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3417e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3418e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3419e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoAssertNoFatalFailureOnFails(); 3420e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3421e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3422e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3423e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3424e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3425e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3426e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3427e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3428e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3429e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3430e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3431e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3432e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) { 3433e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3434e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3435e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3436e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoExpectNoFatalFailureOnFails(); 3437e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3438e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(3, gtest_failures.size()); 3439e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3440e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3441e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3442e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3443e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3444e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).type()); 3445e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3446e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3447e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3448e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3449e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure", 3450e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).message()); 3451e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3452e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3453e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, MessageIsStreamable) { 3454e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3455e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3456e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3457e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message"; 3458e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3459e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3460e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3461e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3462e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3463e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3464e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo", 3465e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3466e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message", 3467e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3468e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3469e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests non-string assertions. 3471d201456903f3ecae1f7794edfab0d5678e64226shiqian 3472d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EqFailure(), used for implementing *EQ* assertions. 3473d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, EqFailure) { 3474d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo_val("5"), bar_val("6"); 3475d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg1( 3476d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", foo_val, bar_val, false) 3477d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3478d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3479d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3480d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3481d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3482d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3483d201456903f3ecae1f7794edfab0d5678e64226shiqian msg1.c_str()); 3484d201456903f3ecae1f7794edfab0d5678e64226shiqian 3485d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg2( 3486d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "6", foo_val, bar_val, false) 3487d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3488d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3489d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3490d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3491d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3492d201456903f3ecae1f7794edfab0d5678e64226shiqian msg2.c_str()); 3493d201456903f3ecae1f7794edfab0d5678e64226shiqian 3494d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg3( 3495d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "bar", foo_val, bar_val, false) 3496d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3497d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3498d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3499d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3500d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3501d201456903f3ecae1f7794edfab0d5678e64226shiqian msg3.c_str()); 3502d201456903f3ecae1f7794edfab0d5678e64226shiqian 3503d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg4( 3504d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 3505d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3506d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3507d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3508d201456903f3ecae1f7794edfab0d5678e64226shiqian msg4.c_str()); 3509d201456903f3ecae1f7794edfab0d5678e64226shiqian 3510d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg5( 3511d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", 3512d201456903f3ecae1f7794edfab0d5678e64226shiqian String("\"x\""), String("\"y\""), 3513d201456903f3ecae1f7794edfab0d5678e64226shiqian true).failure_message()); 3514d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3515d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3516d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"y\"\n" 3517d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo (ignoring case)\n" 3518d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"x\"", 3519d201456903f3ecae1f7794edfab0d5678e64226shiqian msg5.c_str()); 3520d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3521d201456903f3ecae1f7794edfab0d5678e64226shiqian 3522d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests AppendUserMessage(), used for implementing the *EQ* macros. 3523d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AppendUserMessage) { 3524d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 3525d201456903f3ecae1f7794edfab0d5678e64226shiqian 35269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3527d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", 3528d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3529d201456903f3ecae1f7794edfab0d5678e64226shiqian 3530d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << "bar"; 3531d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo\nbar", 3532d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3533d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3534d201456903f3ecae1f7794edfab0d5678e64226shiqian 3535c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3536c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3537c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3538c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3539c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3540d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_TRUE. 3541d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_TRUE) { 3542d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(2 > 1); // NOLINT 3543d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 3544d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 1"); 3545d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3546d201456903f3ecae1f7794edfab0d5678e64226shiqian 3547bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult. 3548bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionTest, AssertTrueWithAssertionResult) { 3549bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_TRUE(ResultIsEven(2)); 3550d21c142eb89ce42817165368641329072e2ad8fbvladlosev#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 3551d21c142eb89ce42817165368641329072e2ad8fbvladlosev // ICE's in C++Builder 2007. 3552bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)), 3553bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(3)\n" 3554bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 3555bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 3556d21c142eb89ce42817165368641329072e2ad8fbvladlosev#endif 3557bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_TRUE(ResultIsEvenNoExplanation(2)); 3558bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)), 3559bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(3)\n" 3560bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 3561bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 3562bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 3563bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 3564d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_FALSE. 3565d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_FALSE) { 3566d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(2 < 1); // NOLINT 3567d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 3568d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3569d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3570d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3571d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3572d201456903f3ecae1f7794edfab0d5678e64226shiqian 3573bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult. 3574bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionTest, AssertFalseWithAssertionResult) { 3575bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_FALSE(ResultIsEven(3)); 3576d21c142eb89ce42817165368641329072e2ad8fbvladlosev#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 3577d21c142eb89ce42817165368641329072e2ad8fbvladlosev // ICE's in C++Builder 2007. 3578bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)), 3579bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(2)\n" 3580bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true (2 is even)\n" 3581bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 3582d21c142eb89ce42817165368641329072e2ad8fbvladlosev#endif 3583bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_FALSE(ResultIsEvenNoExplanation(3)); 3584bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)), 3585bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(2)\n" 3586bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true\n" 3587bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 3588bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 3589bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 3590c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3591c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3592c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 3593c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3594c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3595d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ASSERT_EQ on double values. The purpose is to make 3596d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3597d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3598d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_Double) { 3599d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3600d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5.6, 5.6); 3601d201456903f3ecae1f7794edfab0d5678e64226shiqian 3602d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3603d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 3604d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3605d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3606d201456903f3ecae1f7794edfab0d5678e64226shiqian 3607d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ. 3608d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ) { 3609d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5, 2 + 3); 3610d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 3611d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3612d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3613d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3614d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3615d201456903f3ecae1f7794edfab0d5678e64226shiqian 3616d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(NULL, pointer). 361706d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 3618d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ_NULL) { 3619d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3620d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3621e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Some older GCC versions may issue a spurious waring in this or the next 3622e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 3623e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 3624e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 3625d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(NULL, p); 3626d201456903f3ecae1f7794edfab0d5678e64226shiqian 3627d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3628d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 3629d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 3630d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3631d201456903f3ecae1f7794edfab0d5678e64226shiqian} 363206d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 3633d201456903f3ecae1f7794edfab0d5678e64226shiqian 3634d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 3635d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3636d201456903f3ecae1f7794edfab0d5678e64226shiqian// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 3637d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 3638d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_0) { 3639d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3640d201456903f3ecae1f7794edfab0d5678e64226shiqian 3641d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3642d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0, n); 3643d201456903f3ecae1f7794edfab0d5678e64226shiqian 3644d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 3646d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3647d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3648d201456903f3ecae1f7794edfab0d5678e64226shiqian 3649d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NE. 3650d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_NE) { 3651d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(6, 7); 3652d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 3653d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3654d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3655d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3656d201456903f3ecae1f7794edfab0d5678e64226shiqian 3657d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LE. 3658d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LE) { 3659d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 3); 3660d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 2); 3661d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 3662d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3663d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3664d201456903f3ecae1f7794edfab0d5678e64226shiqian 3665d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LT. 3666d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LT) { 3667d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(2, 3); 3668d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 3669d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3670d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3671d201456903f3ecae1f7794edfab0d5678e64226shiqian 3672d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GE. 3673d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GE) { 3674d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 1); 3675d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 2); 3676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 3677d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3678d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3679d201456903f3ecae1f7794edfab0d5678e64226shiqian 3680d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GT. 3681d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GT) { 3682d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(2, 1); 3683d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 3684d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3685d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3686d201456903f3ecae1f7794edfab0d5678e64226shiqian 368736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 368836865d8d354465e3461eedf2949a4b7799985d5dshiqian 3689886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wanvoid ThrowNothing() {} 3690886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan 369136865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_THROW. 369236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_THROW) { 369336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int); 3694d21c142eb89ce42817165368641329072e2ad8fbvladlosev 3695d21c142eb89ce42817165368641329072e2ad8fbvladlosev#ifndef __BORLANDC__ 3696d21c142eb89ce42817165368641329072e2ad8fbvladlosev // ICE's in C++Builder 2007 and 2009. 3697886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3698886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowAnInteger(), bool), 3699886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of type bool.\n" 3700886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws a different type."); 3701c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3702d21c142eb89ce42817165368641329072e2ad8fbvladlosev 3703886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3704886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowNothing(), bool), 3705886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3706886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 370736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 370836865d8d354465e3461eedf2949a4b7799985d5dshiqian 370936865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_NO_THROW. 371036865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_NO_THROW) { 3711886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()); 371236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 3713886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an exception." 371436865d8d354465e3461eedf2949a4b7799985d5dshiqian "\n Actual: it throws."); 371536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 371636865d8d354465e3461eedf2949a4b7799985d5dshiqian 371736865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_ANY_THROW. 371836865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_ANY_THROW) { 371936865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()); 3720886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3721886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_ANY_THROW(ThrowNothing()), 3722886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3723886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 372436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 372536865d8d354465e3461eedf2949a4b7799985d5dshiqian 372636865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 372736865d8d354465e3461eedf2949a4b7799985d5dshiqian 3728d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure we deal with the precedence of <<. This test should 3729d201456903f3ecae1f7794edfab0d5678e64226shiqian// compile. 3730d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertPrecedence) { 3731d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1 < 2, true); 373248b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan bool false_value = false; 373348b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan ASSERT_EQ(true && false_value, false); 3734d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3735d201456903f3ecae1f7794edfab0d5678e64226shiqian 3736d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3737d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestEq1(int x) { 3738d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, x); 3739d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3740d201456903f3ecae1f7794edfab0d5678e64226shiqian 3741d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests calling a test subroutine that's not part of a fixture. 3742d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, NonFixtureSubroutine) { 3743d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestEq1(2), 3744d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: x"); 3745d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3746d201456903f3ecae1f7794edfab0d5678e64226shiqian 3747d201456903f3ecae1f7794edfab0d5678e64226shiqian// An uncopyable class. 3748d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Uncopyable { 3749d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3750d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit Uncopyable(int a_value) : value_(a_value) {} 3751d201456903f3ecae1f7794edfab0d5678e64226shiqian 3752d201456903f3ecae1f7794edfab0d5678e64226shiqian int value() const { return value_; } 3753d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator==(const Uncopyable& rhs) const { 3754d201456903f3ecae1f7794edfab0d5678e64226shiqian return value() == rhs.value(); 3755d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3756d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3757d201456903f3ecae1f7794edfab0d5678e64226shiqian // This constructor deliberately has no implementation, as we don't 3758d201456903f3ecae1f7794edfab0d5678e64226shiqian // want this class to be copyable. 3759d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable(const Uncopyable&); // NOLINT 3760d201456903f3ecae1f7794edfab0d5678e64226shiqian 3761d201456903f3ecae1f7794edfab0d5678e64226shiqian int value_; 3762d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3763d201456903f3ecae1f7794edfab0d5678e64226shiqian 3764d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 3765d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << value.value(); 3766d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3767d201456903f3ecae1f7794edfab0d5678e64226shiqian 3768d201456903f3ecae1f7794edfab0d5678e64226shiqian 3769d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositiveUncopyable(const Uncopyable& x) { 3770d201456903f3ecae1f7794edfab0d5678e64226shiqian return x.value() > 0; 3771d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3772d201456903f3ecae1f7794edfab0d5678e64226shiqian 3773d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3774d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertNonPositive() { 3775d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3776d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, y); 3777d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3778d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3779d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertEqualsUncopyable() { 3780d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3781d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3782d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, y); 3783d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3784d201456903f3ecae1f7794edfab0d5678e64226shiqian 3785d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in assertions. 3786d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertWorksWithUncopyableObject) { 3787d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3788d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, x); 3789d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, x); 3790d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 3791d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3792d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 3793d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3794d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3795d201456903f3ecae1f7794edfab0d5678e64226shiqian 3796d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in expects. 3797d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 3798d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3799d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsPositiveUncopyable, x); 3800d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3801d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 3802d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3803d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(x, x); 3804d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 3805d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3806d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3807d201456903f3ecae1f7794edfab0d5678e64226shiqian 38085c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wanenum NamedEnum { 38095c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kE1 = 0, 38105c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kE2 = 1, 38115c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan}; 38125c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan 38135c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wanTEST(AssertionTest, NamedEnum) { 38145c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(kE1, kE1); 38155c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LT(kE1, kE2); 38165c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0"); 38175c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1"); 38185c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan} 3819d201456903f3ecae1f7794edfab0d5678e64226shiqian 3820d201456903f3ecae1f7794edfab0d5678e64226shiqian// The version of gcc used in XCode 2.2 has a bug and doesn't allow 38216a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// anonymous enums in assertions. Therefore the following test is not 38226a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// done on Mac. 3823cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev// Sun Studio also rejects this code. 3824cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) 3825d201456903f3ecae1f7794edfab0d5678e64226shiqian 3826d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using assertions with anonymous enums. 3827d201456903f3ecae1f7794edfab0d5678e64226shiqianenum { 38285c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseA = -1, 38290af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 3830d201456903f3ecae1f7794edfab0d5678e64226shiqian // We want to test the case where the size of the anonymous enum is 3831d201456903f3ecae1f7794edfab0d5678e64226shiqian // larger than sizeof(int), to make sure our implementation of the 3832d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions doesn't truncate the enums. However, MSVC 3833d201456903f3ecae1f7794edfab0d5678e64226shiqian // (incorrectly) doesn't allow an enum value to exceed the range of 3834d201456903f3ecae1f7794edfab0d5678e64226shiqian // an int, so this has to be conditionally compiled. 3835d201456903f3ecae1f7794edfab0d5678e64226shiqian // 38365c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan // On Linux, kCaseB and kCaseA have the same value when truncated to 3837d201456903f3ecae1f7794edfab0d5678e64226shiqian // int size. We want to test whether this will confuse the 3838d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions. 38395c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseB = testing::internal::kMaxBiggestInt, 3840d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 38415c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseB = INT_MAX, 3842d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 38435c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseC = 42, 3844d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3845d201456903f3ecae1f7794edfab0d5678e64226shiqian 3846d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AnonymousEnum) { 38470af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 38485c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB)); 3849d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 3850d201456903f3ecae1f7794edfab0d5678e64226shiqian 38515c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(kCaseA, kCaseA); 38525c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NE(kCaseA, kCaseB); 38535c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LT(kCaseA, kCaseB); 38545c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LE(kCaseA, kCaseB); 38555c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_GT(kCaseB, kCaseA); 38565c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_GE(kCaseA, kCaseA); 38575c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB), 38585c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "(kCaseA) >= (kCaseB)"); 38595c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC), 38605c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "-1 vs 42"); 38615c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan 38625c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_EQ(kCaseA, kCaseA); 38635c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_NE(kCaseA, kCaseB); 38645c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_LT(kCaseA, kCaseB); 38655c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_LE(kCaseA, kCaseB); 38665c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_GT(kCaseB, kCaseA); 38675c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_GE(kCaseA, kCaseA); 38685c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), 38695c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Value of: kCaseB"); 38705c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 38715c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Actual: 42"); 38725c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 38735c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Which is: -1"); 3874d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3875d201456903f3ecae1f7794edfab0d5678e64226shiqian 3876cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC) 3877d201456903f3ecae1f7794edfab0d5678e64226shiqian 38780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 3879d201456903f3ecae1f7794edfab0d5678e64226shiqian 3880d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT UnexpectedHRESULTFailure() { 3881d201456903f3ecae1f7794edfab0d5678e64226shiqian return E_UNEXPECTED; 3882d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3883d201456903f3ecae1f7794edfab0d5678e64226shiqian 3884d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT OkHRESULTSuccess() { 3885d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_OK; 3886d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3887d201456903f3ecae1f7794edfab0d5678e64226shiqian 3888d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT FalseHRESULTSuccess() { 3889d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_FALSE; 3890d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3891d201456903f3ecae1f7794edfab0d5678e64226shiqian 3892d201456903f3ecae1f7794edfab0d5678e64226shiqian// HRESULT assertion tests test both zero and non-zero 3893d201456903f3ecae1f7794edfab0d5678e64226shiqian// success codes as well as failure message for each. 3894d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3895d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows CE doesn't support message texts. 3896d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 3897d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK); 3898d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_FALSE); 3899d201456903f3ecae1f7794edfab0d5678e64226shiqian 3900d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3901ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3902ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3903d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3904d201456903f3ecae1f7794edfab0d5678e64226shiqian 3905d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 3906d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK); 3907d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_FALSE); 3908d201456903f3ecae1f7794edfab0d5678e64226shiqian 3909d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3910ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3911ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3912d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3913d201456903f3ecae1f7794edfab0d5678e64226shiqian 3914d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 3915d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED); 3916d201456903f3ecae1f7794edfab0d5678e64226shiqian 3917d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 3918ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3919ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3920d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 3921ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3922ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3923d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3924d201456903f3ecae1f7794edfab0d5678e64226shiqian 3925d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 3926d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED); 3927d201456903f3ecae1f7794edfab0d5678e64226shiqian 3928c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3929c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3930d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 3931ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3932ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3933c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3934d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 3935ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3936ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3937d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3938d201456903f3ecae1f7794edfab0d5678e64226shiqian 3939d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that streaming to the HRESULT macros works. 3940d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, Streaming) { 3941d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3942d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3944d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3945d201456903f3ecae1f7794edfab0d5678e64226shiqian 3946d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3947d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3948d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3949d201456903f3ecae1f7794edfab0d5678e64226shiqian 3950c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3951c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3952d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3953d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3954d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3955c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3956d201456903f3ecae1f7794edfab0d5678e64226shiqian 3957d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3958d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 3959d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3960d201456903f3ecae1f7794edfab0d5678e64226shiqian 3961d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3962d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 3963d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3964d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3965d201456903f3ecae1f7794edfab0d5678e64226shiqian 39660af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_WINDOWS 3967d201456903f3ecae1f7794edfab0d5678e64226shiqian 3968c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3969c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3970c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3971c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3972c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3973d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros behave like single statements. 3974e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) { 3975f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 3976d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(false) << "This should never be executed; " 3977d201456903f3ecae1f7794edfab0d5678e64226shiqian "It's a compilation test only."; 3978d201456903f3ecae1f7794edfab0d5678e64226shiqian 3979f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 3980d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false); 3981d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3982ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3983d201456903f3ecae1f7794edfab0d5678e64226shiqian 3984f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 3985d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 3); 3986d201456903f3ecae1f7794edfab0d5678e64226shiqian 3987f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 3988ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3989d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3990d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(3, 2) << ""; 3991e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 399236865d8d354465e3461eedf2949a4b7799985d5dshiqian 399336865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 399437504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the compiler will not complain about unreachable code in the 399537504994338c114247519331237831f88a9a7c40zhanyong.wan// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros. 399637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) { 399737504994338c114247519331237831f88a9a7c40zhanyong.wan int n = 0; 399837504994338c114247519331237831f88a9a7c40zhanyong.wan 399937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_THROW(throw 1, int); 400037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), ""); 400137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), ""); 400237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NO_THROW(n++); 400337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), ""); 400437504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_ANY_THROW(throw 1); 400537504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), ""); 400637504994338c114247519331237831f88a9a7c40zhanyong.wan} 400737504994338c114247519331237831f88a9a7c40zhanyong.wan 4008e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) { 4009f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4010886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool); 401136865d8d354465e3461eedf2949a4b7799985d5dshiqian 4012f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 401336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 401436865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4015ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 401636865d8d354465e3461eedf2949a4b7799985d5dshiqian 4017f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 401836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(ThrowAnInteger()); 401936865d8d354465e3461eedf2949a4b7799985d5dshiqian 4020f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 4021886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 402236865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4023ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 402436865d8d354465e3461eedf2949a4b7799985d5dshiqian 4025f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4026886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()); 402736865d8d354465e3461eedf2949a4b7799985d5dshiqian 4028f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 402936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 403036865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4031ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4032e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 403336865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 4034e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4035e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) { 4036f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4037e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. " 4038e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian << "It's a compilation test only."; 4039e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4040ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4041e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4042f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4043e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FAIL()) << ""; 4044e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4045ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4046e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4047f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 4048e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(SUCCEED()); 4049e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4050ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4051e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4052f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4053ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4054e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4055e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(SUCCEED()); 4056d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4057d201456903f3ecae1f7794edfab0d5678e64226shiqian 4058d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros work well with switch statements. 4059d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, WorksWithSwitch) { 4060d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 4061d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 4062d201456903f3ecae1f7794edfab0d5678e64226shiqian break; 4063d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 4064d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 4065d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4066d201456903f3ecae1f7794edfab0d5678e64226shiqian 4067d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 4068d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 4069d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 4070d201456903f3ecae1f7794edfab0d5678e64226shiqian 4071d201456903f3ecae1f7794edfab0d5678e64226shiqian // Binary assertions are implemented using a different code path 4072d201456903f3ecae1f7794edfab0d5678e64226shiqian // than the Boolean assertions. Hence we test them separately. 4073d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 4074d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 4075d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 4076d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 4077d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4078d201456903f3ecae1f7794edfab0d5678e64226shiqian 4079d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 4080d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 4081d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(1, 2); 4082d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4083d201456903f3ecae1f7794edfab0d5678e64226shiqian 408436865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 408536865d8d354465e3461eedf2949a4b7799985d5dshiqian 408636865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAString() { 408736865d8d354465e3461eedf2949a4b7799985d5dshiqian throw "String"; 408836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 408936865d8d354465e3461eedf2949a4b7799985d5dshiqian 409036865d8d354465e3461eedf2949a4b7799985d5dshiqian// Test that the exception assertion macros compile and work with const 409136865d8d354465e3461eedf2949a4b7799985d5dshiqian// type qualifier. 409236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionSyntaxTest, WorksWithConst) { 409336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAString(), const char*); 409436865d8d354465e3461eedf2949a4b7799985d5dshiqian 409536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAString(), const char*); 409636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 409736865d8d354465e3461eedf2949a4b7799985d5dshiqian 409836865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 409936865d8d354465e3461eedf2949a4b7799985d5dshiqian 4100d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4101d201456903f3ecae1f7794edfab0d5678e64226shiqian 4102d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 4103d201456903f3ecae1f7794edfab0d5678e64226shiqian 4104d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test tracks SUCCEED*. 4105d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, SUCCEED) { 4106d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 4107d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "OK"; 4108c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count()); 4109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4110d201456903f3ecae1f7794edfab0d5678e64226shiqian 4111d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_*. 4112d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT) { 4113d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true); 4114c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4115d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4116d201456903f3ecae1f7794edfab0d5678e64226shiqian 4117d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_STR*. 4118d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT_STR) { 4119d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", ""); 4120c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4121d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4122d201456903f3ecae1f7794edfab0d5678e64226shiqian 4123d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_*. 4124d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT) { 4125d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 4126c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4127d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4128d201456903f3ecae1f7794edfab0d5678e64226shiqian 4129d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_STR*. 4130d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT_STR) { 4131d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("", ""); 4132c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4133d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4134d201456903f3ecae1f7794edfab0d5678e64226shiqian 4135d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 4136d201456903f3ecae1f7794edfab0d5678e64226shiqian 4137d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 4138d201456903f3ecae1f7794edfab0d5678e64226shiqian 4139d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_TRUE. 4140d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_TRUE) { 4141d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(2 > 1); // NOLINT 4142d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 4143d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 < 1\n" 4144d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: false\n" 4145d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: true"); 4146d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 4147d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 > 3"); 4148d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4149d201456903f3ecae1f7794edfab0d5678e64226shiqian 4150bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult. 4151bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(ExpectTest, ExpectTrueWithAssertionResult) { 4152bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(ResultIsEven(2)); 4153bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)), 4154bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(3)\n" 4155bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 4156bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 4157bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(ResultIsEvenNoExplanation(2)); 4158bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)), 4159bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(3)\n" 4160bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 4161bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 4162bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4163bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4164d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_FALSE. 4165d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_FALSE) { 4166d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(2 < 1); // NOLINT 4167d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 4168d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 4169d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 4170d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 4171d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 4172d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 3"); 4173d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4174d201456903f3ecae1f7794edfab0d5678e64226shiqian 4175bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult. 4176bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(ExpectTest, ExpectFalseWithAssertionResult) { 4177bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(ResultIsEven(3)); 4178bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)), 4179bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(2)\n" 4180bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true (2 is even)\n" 4181bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 4182bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(ResultIsEvenNoExplanation(3)); 4183bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)), 4184bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(2)\n" 4185bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true\n" 4186bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 4187bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4188bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4189c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 4190c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 4191c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 4192c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 4193c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 4194d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ. 4195d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ) { 4196d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, 2 + 3); 4197d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 4198d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 4199d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 4200d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 4201d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 4202d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 - 3"); 4203d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4204d201456903f3ecae1f7794edfab0d5678e64226shiqian 4205d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using EXPECT_EQ on double values. The purpose is to make 4206d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 4207d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 4208d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_Double) { 4209d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4210d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5.6, 5.6); 4211d201456903f3ecae1f7794edfab0d5678e64226shiqian 4212d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4213d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 4214d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 4215d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4216d201456903f3ecae1f7794edfab0d5678e64226shiqian 421706d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 4218d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(NULL, pointer). 4219d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_NULL) { 4220d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4221d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 422248b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan // Some older GCC versions may issue a spurious warning in this or the next 4223e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 4224e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 4225e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 4226d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, p); 4227d201456903f3ecae1f7794edfab0d5678e64226shiqian 4228d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4229d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4230d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 4231d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 4232d201456903f3ecae1f7794edfab0d5678e64226shiqian} 423306d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 4234d201456903f3ecae1f7794edfab0d5678e64226shiqian 4235d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 4236d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 4237d201456903f3ecae1f7794edfab0d5678e64226shiqian// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 4238d201456903f3ecae1f7794edfab0d5678e64226shiqian// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 4239d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_0) { 4240d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4241d201456903f3ecae1f7794edfab0d5678e64226shiqian 4242d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4243d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, n); 4244d201456903f3ecae1f7794edfab0d5678e64226shiqian 4245d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 4247d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 4248d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4249d201456903f3ecae1f7794edfab0d5678e64226shiqian 4250d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NE. 4251d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_NE) { 4252d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(6, 7); 4253d201456903f3ecae1f7794edfab0d5678e64226shiqian 4254d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 4255d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 4256d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 4257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 4258d201456903f3ecae1f7794edfab0d5678e64226shiqian "2"); 4259d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4260d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 4261d201456903f3ecae1f7794edfab0d5678e64226shiqian "p0"); 4262d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4263d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4264d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4265d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4266d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4267d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4268d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 4269d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 4270d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4271d201456903f3ecae1f7794edfab0d5678e64226shiqian 4272d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LE. 4273d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LE) { 4274d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 3); 4275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 2); 4276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 4277d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 4278d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 4279d201456903f3ecae1f7794edfab0d5678e64226shiqian "(1.1) <= (0.9)"); 4280d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4281d201456903f3ecae1f7794edfab0d5678e64226shiqian 4282d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LT. 4283d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LT) { 4284d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(2, 3); 4285d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 4286d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 4287d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 4288d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) < (1)"); 4289d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4290d201456903f3ecae1f7794edfab0d5678e64226shiqian 4291d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GE. 4292d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GE) { 4293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 1); 4294d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 2); 4295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 4296d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 4297d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 4298d201456903f3ecae1f7794edfab0d5678e64226shiqian "(0.9) >= (1.1)"); 4299d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4300d201456903f3ecae1f7794edfab0d5678e64226shiqian 4301d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GT. 4302d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GT) { 4303d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(2, 1); 4304d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 4305d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 4306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 4307d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) > (3)"); 4308d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4309d201456903f3ecae1f7794edfab0d5678e64226shiqian 431036865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 431136865d8d354465e3461eedf2949a4b7799985d5dshiqian 431236865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_THROW. 431336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_THROW) { 431436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 431536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 4316886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of " 431736865d8d354465e3461eedf2949a4b7799985d5dshiqian "type bool.\n Actual: it throws a different type."); 4318886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 4319886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool), 4320886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 4321886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 432236865d8d354465e3461eedf2949a4b7799985d5dshiqian} 432336865d8d354465e3461eedf2949a4b7799985d5dshiqian 432436865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_NO_THROW. 432536865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_NO_THROW) { 4326886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 432736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 4328886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an " 432936865d8d354465e3461eedf2949a4b7799985d5dshiqian "exception.\n Actual: it throws."); 433036865d8d354465e3461eedf2949a4b7799985d5dshiqian} 433136865d8d354465e3461eedf2949a4b7799985d5dshiqian 433236865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_ANY_THROW. 433336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_ANY_THROW) { 433436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 4335886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 4336886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()), 4337886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 4338886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 433936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 434036865d8d354465e3461eedf2949a4b7799985d5dshiqian 434136865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 434236865d8d354465e3461eedf2949a4b7799985d5dshiqian 4343d201456903f3ecae1f7794edfab0d5678e64226shiqian// Make sure we deal with the precedence of <<. 4344d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ExpectPrecedence) { 4345d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1 < 2, true); 4346d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 4347d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true && false"); 4348d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4349d201456903f3ecae1f7794edfab0d5678e64226shiqian 4350d201456903f3ecae1f7794edfab0d5678e64226shiqian 4351d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the StreamableToString() function. 4352d201456903f3ecae1f7794edfab0d5678e64226shiqian 4353d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a scalar. 4354d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Scalar) { 4355d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("5", StreamableToString(5).c_str()); 4356d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4357d201456903f3ecae1f7794edfab0d5678e64226shiqian 4358d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a non-char pointer. 4359d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Pointer) { 4360d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4361d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = &n; 4362d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 4363d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4364d201456903f3ecae1f7794edfab0d5678e64226shiqian 4365d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL non-char pointer. 4366d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullPointer) { 4367d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = NULL; 4368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4369d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4370d201456903f3ecae1f7794edfab0d5678e64226shiqian 4371d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a C string. 4372d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, CString) { 4373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 4374d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4375d201456903f3ecae1f7794edfab0d5678e64226shiqian 4376d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL C string. 4377d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullCString) { 4378d201456903f3ecae1f7794edfab0d5678e64226shiqian char* p = NULL; 4379d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4380d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4381d201456903f3ecae1f7794edfab0d5678e64226shiqian 4382d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using streamable values as assertion messages. 4383d201456903f3ecae1f7794edfab0d5678e64226shiqian 4384d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using std::string as an assertion message. 4385d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, string) { 4386d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string str( 4387d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure message is a std::string, and is expected."); 4388d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << str, 4389d201456903f3ecae1f7794edfab0d5678e64226shiqian str.c_str()); 4390d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4391d201456903f3ecae1f7794edfab0d5678e64226shiqian 4392d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output strings containing embedded NULs. 4393d201456903f3ecae1f7794edfab0d5678e64226shiqian// Limited to Linux because we can only do this with std::string's. 4394d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, stringWithEmbeddedNUL) { 4395d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char char_array_with_nul[] = 4396d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\0 and some more string"; 4397d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string string_with_nul(char_array_with_nul, 4398d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(char_array_with_nul) 4399d201456903f3ecae1f7794edfab0d5678e64226shiqian - 1); // drops the trailing NUL 4400d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 4401d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\\0 and some more string"); 4402d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4403d201456903f3ecae1f7794edfab0d5678e64226shiqian 4404d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output a NUL char. 4405d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NULChar) { 4406d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4407d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "A NUL" << '\0' << " and some more string"; 4408d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "A NUL\\0 and some more string"); 4409d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4410d201456903f3ecae1f7794edfab0d5678e64226shiqian 4411d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int as an assertion message. 4412d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, int) { 4413d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << 900913, 4414d201456903f3ecae1f7794edfab0d5678e64226shiqian "900913"); 4415d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4416d201456903f3ecae1f7794edfab0d5678e64226shiqian 4417d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using NULL char pointer as an assertion message. 4418d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4419d201456903f3ecae1f7794edfab0d5678e64226shiqian// In MSVC, streaming a NULL char * causes access violation. Google Test 4420d201456903f3ecae1f7794edfab0d5678e64226shiqian// implemented a workaround (substituting "(null)" for NULL). This 4421d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests whether the workaround works. 4422d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NullCharPtr) { 4423d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 4424d201456903f3ecae1f7794edfab0d5678e64226shiqian "(null)"); 4425d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4426d201456903f3ecae1f7794edfab0d5678e64226shiqian 4427d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that basic IO manipulators (endl, ends, and flush) can be 4428d201456903f3ecae1f7794edfab0d5678e64226shiqian// streamed to testing::Message. 4429d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, BasicIoManip) { 4430d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4431d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Line 1." << std::endl 4432d201456903f3ecae1f7794edfab0d5678e64226shiqian << "A NUL char " << std::ends << std::flush << " in line 2."; 4433d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Line 1.\nA NUL char \\0 in line 2."); 4434d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4435d201456903f3ecae1f7794edfab0d5678e64226shiqian 4436d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the macros that haven't been covered so far. 4437d201456903f3ecae1f7794edfab0d5678e64226shiqian 4438d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AddFailureHelper(bool* aborted) { 4439d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 4440d201456903f3ecae1f7794edfab0d5678e64226shiqian ADD_FAILURE() << "Failure"; 4441d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 4442d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4443d201456903f3ecae1f7794edfab0d5678e64226shiqian 4444d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ADD_FAILURE. 4445d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, ADD_FAILURE) { 4446d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 4447d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 4448d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failure"); 4449d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 4450d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4451d201456903f3ecae1f7794edfab0d5678e64226shiqian 44527c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan// Tests ADD_FAILURE_AT. 44537c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wanTEST(MacroTest, ADD_FAILURE_AT) { 44547c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and 44557c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // the failure message contains the user-streamed part. 44567c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!"); 44577c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 44587c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Verifies that the user-streamed part is optional. 44597c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed"); 44607c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 44617c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Unfortunately, we cannot verify that the failure message contains 44627c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // the right file path and line number the same way, as 44637c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and 44647c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // line number. Instead, we do that in gtest_output_test_.cc. 44657c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan} 44667c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 4467d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests FAIL. 4468d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, FAIL) { 4469d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL(), 4470d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failed"); 4471d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 4472d201456903f3ecae1f7794edfab0d5678e64226shiqian "Intentional failure."); 4473d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4474d201456903f3ecae1f7794edfab0d5678e64226shiqian 4475d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests SUCCEED 4476d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, SUCCEED) { 4477d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 4478d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "Explicit success."; 4479d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4480d201456903f3ecae1f7794edfab0d5678e64226shiqian 4481d201456903f3ecae1f7794edfab0d5678e64226shiqian 4482d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for EXPECT_EQ() and ASSERT_EQ(). 4483d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4484d201456903f3ecae1f7794edfab0d5678e64226shiqian// These tests fail *intentionally*, s.t. the failure messages can be 4485d201456903f3ecae1f7794edfab0d5678e64226shiqian// generated and tested. 4486d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4487d201456903f3ecae1f7794edfab0d5678e64226shiqian// We have different tests for different argument types. 4488d201456903f3ecae1f7794edfab0d5678e64226shiqian 4489d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using bool values in {EXPECT|ASSERT}_EQ. 4490d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Bool) { 4491d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(true, true); 449248b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan EXPECT_FATAL_FAILURE({ 449348b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan bool false_value = false; 449448b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan ASSERT_EQ(false_value, true); 449548b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan }, "Value of: true"); 4496d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4497d201456903f3ecae1f7794edfab0d5678e64226shiqian 4498d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int values in {EXPECT|ASSERT}_EQ. 4499d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Int) { 4500d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(32, 32); 4501d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 4502d201456903f3ecae1f7794edfab0d5678e64226shiqian "33"); 4503d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4504d201456903f3ecae1f7794edfab0d5678e64226shiqian 4505d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using time_t values in {EXPECT|ASSERT}_EQ. 4506d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Time_T) { 4507d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<time_t>(0), 4508d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(0)); 4509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 4510d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(1234)), 4511d201456903f3ecae1f7794edfab0d5678e64226shiqian "1234"); 4512d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4513d201456903f3ecae1f7794edfab0d5678e64226shiqian 4514d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char values in {EXPECT|ASSERT}_EQ. 4515d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Char) { 4516d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ('z', 'z'); 4517d201456903f3ecae1f7794edfab0d5678e64226shiqian const char ch = 'b'; 4518d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 4519d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4520d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 4521d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4522d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4523d201456903f3ecae1f7794edfab0d5678e64226shiqian 4524d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 4525d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideChar) { 4526d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L'b', L'b'); 4527d201456903f3ecae1f7794edfab0d5678e64226shiqian 4528d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 4529d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: L'x'\n" 4530d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L'x' (120, 0x78)\n" 4531d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: L'\0'\n" 4532d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L'\0' (0, 0x0)"); 4533d201456903f3ecae1f7794edfab0d5678e64226shiqian 4534d201456903f3ecae1f7794edfab0d5678e64226shiqian static wchar_t wchar; 4535d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'b'; 4536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 4537d201456903f3ecae1f7794edfab0d5678e64226shiqian "wchar"); 4538c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan wchar = 0x8119; 4539c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar), 4540d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: wchar"); 4541d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4542d201456903f3ecae1f7794edfab0d5678e64226shiqian 4543d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 4544d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdString) { 4545d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has identical 4546d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4547d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ("Test", ::std::string("Test")); 4548d201456903f3ecae1f7794edfab0d5678e64226shiqian 4549d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::strings. 4550d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str1("A * in the middle"); 4551d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str2(str1); 4552d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(str1, str2); 4553d201456903f3ecae1f7794edfab0d5678e64226shiqian 4554d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has different 4555d201456903f3ecae1f7794edfab0d5678e64226shiqian // content 4556d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 4557d201456903f3ecae1f7794edfab0d5678e64226shiqian "::std::string(\"test\")"); 4558d201456903f3ecae1f7794edfab0d5678e64226shiqian 4559d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::string to a char* that has different content. 4560d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = const_cast<char*>("foo"); 4561d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 4562d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 4563d201456903f3ecae1f7794edfab0d5678e64226shiqian 4564d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::strings that have different contents, one of 4565d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. This should fail. 4566d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::std::string str3(str1); 4567d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4568d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 4569d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: str3\n" 4570d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"A \\0 in the middle\""); 4571d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4572d201456903f3ecae1f7794edfab0d5678e64226shiqian 4573d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 4574d201456903f3ecae1f7794edfab0d5678e64226shiqian 4575d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 4576d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdWideString) { 4577d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::wstrings. 4578d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr1(L"A * in the middle"); 4579d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr2(wstr1); 4580d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(wstr1, wstr2); 4581d201456903f3ecae1f7794edfab0d5678e64226shiqian 4582c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Compares an std::wstring to a const wchar_t* that has identical 4583c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // content. 4584c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 4585c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119); 4586c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan 4587d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has different 4588d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4589c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 4590d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4591c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120); 4592c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan }, "kTestX8120"); 4593d201456903f3ecae1f7794edfab0d5678e64226shiqian 4594d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::wstrings that have different contents, one of 4595d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. 4596d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring wstr3(wstr1); 4597d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4598d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 4599d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4600d201456903f3ecae1f7794edfab0d5678e64226shiqian 4601d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to an std::wstring that has different 4602d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4603d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4604d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 4605d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4606d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4607d201456903f3ecae1f7794edfab0d5678e64226shiqian 4608d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 4609d201456903f3ecae1f7794edfab0d5678e64226shiqian 4610d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 4611d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::string values in {EXPECT|ASSERT}_EQ. 4612d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalString) { 4613d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to a ::string that has identical content. 4614d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ("Test", ::string("Test")); 4615d201456903f3ecae1f7794edfab0d5678e64226shiqian 4616d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::strings. 4617d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str1("A * in the middle"); 4618d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str2(str1); 4619d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(str1, str2); 4620d201456903f3ecae1f7794edfab0d5678e64226shiqian 4621d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a const char* that has different content. 4622d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 4623d201456903f3ecae1f7794edfab0d5678e64226shiqian "test"); 4624d201456903f3ecae1f7794edfab0d5678e64226shiqian 4625d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::strings that have different contents, one of which 4626d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4627d201456903f3ecae1f7794edfab0d5678e64226shiqian ::string str3(str1); 4628d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4629d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 4630d201456903f3ecae1f7794edfab0d5678e64226shiqian "str3"); 4631d201456903f3ecae1f7794edfab0d5678e64226shiqian 4632d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a char* that has different content. 4633d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4634d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 4635d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4636d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4637d201456903f3ecae1f7794edfab0d5678e64226shiqian 4638d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 4639d201456903f3ecae1f7794edfab0d5678e64226shiqian 4640d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_WSTRING 4641d201456903f3ecae1f7794edfab0d5678e64226shiqian 4642d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 4643d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalWideString) { 4644d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::wstrings. 4645d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr1(L"A * in the middle"); 4646d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr2(wstr1); 4647d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(wstr1, wstr2); 4648d201456903f3ecae1f7794edfab0d5678e64226shiqian 4649c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Compares a const wchar_t* to a ::wstring that has identical content. 4650c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 4651c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan ASSERT_EQ(kTestX8119, ::wstring(kTestX8119)); 4652c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan 4653d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has different 4654d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4655c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 4656d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4657c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(kTestX8120, ::wstring(kTestX8119)); 4658d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Test\\x8119"); 4659d201456903f3ecae1f7794edfab0d5678e64226shiqian 4660d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to a ::wstring that has different content. 4661d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 4662d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 4663d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar"); 4664d201456903f3ecae1f7794edfab0d5678e64226shiqian 4665d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::wstrings that have different contents, one of which 4666d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4667d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::wstring wstr3; 4668d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3 = wstr1; 4669d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4670d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 4671d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4672d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4673d201456903f3ecae1f7794edfab0d5678e64226shiqian 4674d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 4675d201456903f3ecae1f7794edfab0d5678e64226shiqian 4676d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char pointers in {EXPECT|ASSERT}_EQ. 4677d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, CharPointer) { 4678d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4679d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4680d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4681d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4682d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4683d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4684d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4685d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4686d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p2 = reinterpret_cast<char*>(pv2); 4687d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(p1, p1); 4688d201456903f3ecae1f7794edfab0d5678e64226shiqian 4689d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4690d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4691d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4692d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4693d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 4694d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<char*>(0xABC0)), 4695d201456903f3ecae1f7794edfab0d5678e64226shiqian "ABC0"); 4696d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4697d201456903f3ecae1f7794edfab0d5678e64226shiqian 4698d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 4699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideCharPointer) { 4700d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p0 = NULL; 4701d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4702d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4703d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4704d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4705d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4706d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4707d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 4708d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 4709d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(p0, p0); 4710d201456903f3ecae1f7794edfab0d5678e64226shiqian 4711d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4712d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4713d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4714d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4715d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv3 = (void*)0x1234; // NOLINT 4716d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv4 = (void*)0xABC0; // NOLINT 4717d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 4718d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 4719d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 4720d201456903f3ecae1f7794edfab0d5678e64226shiqian "p4"); 4721d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4722d201456903f3ecae1f7794edfab0d5678e64226shiqian 4723d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 4724d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, OtherPointer) { 4725d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(static_cast<const int*>(NULL), 4726d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<const int*>(NULL)); 4727d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 4728d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<const int*>(0x1234)), 4729d201456903f3ecae1f7794edfab0d5678e64226shiqian "0x1234"); 4730d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4731d201456903f3ecae1f7794edfab0d5678e64226shiqian 4732e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// A class that supports binary comparison operators but not streaming. 4733e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wanclass UnprintableChar { 4734e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan public: 4735e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan explicit UnprintableChar(char ch) : char_(ch) {} 4736e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4737e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator==(const UnprintableChar& rhs) const { 4738e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ == rhs.char_; 4739e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4740e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator!=(const UnprintableChar& rhs) const { 4741e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ != rhs.char_; 4742e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4743e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator<(const UnprintableChar& rhs) const { 4744e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ < rhs.char_; 4745e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4746e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator<=(const UnprintableChar& rhs) const { 4747e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ <= rhs.char_; 4748e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4749e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator>(const UnprintableChar& rhs) const { 4750e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ > rhs.char_; 4751e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4752e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator>=(const UnprintableChar& rhs) const { 4753e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ >= rhs.char_; 4754e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4755e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4756e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan private: 4757e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan char char_; 4758e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan}; 4759e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4760e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// Tests that ASSERT_EQ() and friends don't require the arguments to 4761e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// be printable. 4762e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wanTEST(ComparisonAssertionTest, AcceptsUnprintableArgs) { 4763e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan const UnprintableChar x('x'), y('y'); 4764e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_EQ(x, x); 4765e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NE(x, y); 4766e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_LT(x, y); 4767e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_LE(x, y); 4768e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_GT(y, x); 4769e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_GE(x, x); 4770e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4771e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>"); 4772e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>"); 4773e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>"); 4774e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>"); 4775e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>"); 4776e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4777e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan // Code tested by EXPECT_FATAL_FAILURE cannot reference local 4778e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan // variables, so we have to write UnprintableChar('x') instead of x. 4779e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')), 4780e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4781e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 4782e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4783e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 4784e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <79>"); 4785e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 4786e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4787e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 4788e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <79>"); 4789e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan} 4790e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4791d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the FRIEND_TEST macro. 4792d201456903f3ecae1f7794edfab0d5678e64226shiqian 4793d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class has a private member we want to test. We will test it 4794d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a TEST and in a TEST_F. 4795d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Foo { 4796d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4797d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo() {} 4798d201456903f3ecae1f7794edfab0d5678e64226shiqian 4799d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4800d201456903f3ecae1f7794edfab0d5678e64226shiqian int Bar() const { return 1; } 4801d201456903f3ecae1f7794edfab0d5678e64226shiqian 4802d201456903f3ecae1f7794edfab0d5678e64226shiqian // Declares the friend tests that can access the private member 4803d201456903f3ecae1f7794edfab0d5678e64226shiqian // Bar(). 4804d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test, TEST); 4805d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 4806d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4807d201456903f3ecae1f7794edfab0d5678e64226shiqian 4808d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST to access a 4809d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4810d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(FRIEND_TEST_Test, TEST) { 4811d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, Foo().Bar()); 4812d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4813d201456903f3ecae1f7794edfab0d5678e64226shiqian 4814d201456903f3ecae1f7794edfab0d5678e64226shiqian// The fixture needed to test using FRIEND_TEST with TEST_F. 48159b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FRIEND_TEST_Test2 : public Test { 4816d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4817d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo foo; 4818d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4819d201456903f3ecae1f7794edfab0d5678e64226shiqian 4820d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 4821d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4822d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FRIEND_TEST_Test2, TEST_F) { 4823d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, foo.Bar()); 4824d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4825d201456903f3ecae1f7794edfab0d5678e64226shiqian 4826d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of Test objects. 4827d201456903f3ecae1f7794edfab0d5678e64226shiqian 4828d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing the life cycle of Test objects. 4829d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4830d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class counts the number of live test objects that uses this 4831d201456903f3ecae1f7794edfab0d5678e64226shiqian// fixture. 48329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestLifeCycleTest : public Test { 4833d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4834d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructor. Increments the number of test objects that uses 4835d201456903f3ecae1f7794edfab0d5678e64226shiqian // this fixture. 4836d201456903f3ecae1f7794edfab0d5678e64226shiqian TestLifeCycleTest() { count_++; } 4837d201456903f3ecae1f7794edfab0d5678e64226shiqian 4838d201456903f3ecae1f7794edfab0d5678e64226shiqian // Destructor. Decrements the number of test objects that uses this 4839d201456903f3ecae1f7794edfab0d5678e64226shiqian // fixture. 4840d201456903f3ecae1f7794edfab0d5678e64226shiqian ~TestLifeCycleTest() { count_--; } 4841d201456903f3ecae1f7794edfab0d5678e64226shiqian 4842d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the number of live test objects that uses this fixture. 4843d201456903f3ecae1f7794edfab0d5678e64226shiqian int count() const { return count_; } 4844d201456903f3ecae1f7794edfab0d5678e64226shiqian 4845d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4846d201456903f3ecae1f7794edfab0d5678e64226shiqian static int count_; 4847d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4848d201456903f3ecae1f7794edfab0d5678e64226shiqian 4849d201456903f3ecae1f7794edfab0d5678e64226shiqianint TestLifeCycleTest::count_ = 0; 4850d201456903f3ecae1f7794edfab0d5678e64226shiqian 4851d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4852d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test1) { 4853d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be only one test object in this test case that's 4854d201456903f3ecae1f7794edfab0d5678e64226shiqian // currently alive. 4855d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4856d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4857d201456903f3ecae1f7794edfab0d5678e64226shiqian 4858d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4859d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test2) { 4860d201456903f3ecae1f7794edfab0d5678e64226shiqian // After Test1 is done and Test2 is started, there should still be 4861d201456903f3ecae1f7794edfab0d5678e64226shiqian // only one live test object, as the object for Test1 should've been 4862d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 4863d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4864d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4865d201456903f3ecae1f7794edfab0d5678e64226shiqian 4866d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4867d201456903f3ecae1f7794edfab0d5678e64226shiqian 4868bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests that the copy constructor works when it is NOT optimized away by 4869bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// the compiler. 4870bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) { 4871bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // Checks that the copy constructor doesn't try to dereference NULL pointers 4872bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // in the source object. 4873bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess(); 4874bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = r1; 4875bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // The following line is added to prevent the compiler from optimizing 4876bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // away the constructor call. 4877bad778caa39a88b7c11b159e20730aeec4fd711evladlosev r1 << "abc"; 4878bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4879bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r3 = r1; 4880bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1)); 4881bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", r1.message()); 4882bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4883bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4884bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests that AssertionSuccess and AssertionFailure construct 4885bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// AssertionResult objects as expected. 4886bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, ConstructionWorks) { 4887bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess(); 4888bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(r1); 4889bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("", r1.message()); 4890bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4891bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = AssertionSuccess() << "abc"; 4892bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(r2); 4893bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", r2.message()); 4894bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4895bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r3 = AssertionFailure(); 4896bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r3); 4897bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("", r3.message()); 4898bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4899bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r4 = AssertionFailure() << "def"; 4900bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r4); 4901bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("def", r4.message()); 4902bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4903bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r5 = AssertionFailure(Message() << "ghi"); 4904bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r5); 4905bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("ghi", r5.message()); 4906bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4907bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 490825958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev// Tests that the negation flips the predicate result but keeps the message. 4909bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, NegationWorks) { 4910bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess() << "abc"; 4911bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(!r1); 4912bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", (!r1).message()); 4913bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4914bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = AssertionFailure() << "def"; 4915bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(!r2); 4916bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("def", (!r2).message()); 4917bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4918bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4919bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, StreamingWorks) { 4920bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r = AssertionSuccess(); 4921bad778caa39a88b7c11b159e20730aeec4fd711evladlosev r << "abc" << 'd' << 0 << true; 4922bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abcd0true", r.message()); 492325958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev} 492425958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev 492525958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosevTEST(AssertionResultTest, CanStreamOstreamManipulators) { 492625958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev AssertionResult r = AssertionSuccess(); 492725958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev r << "Data" << std::endl << std::flush << std::ends << "Will be visible"; 492825958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev EXPECT_STREQ("Data\n\\0Will be visible", r.message()); 4929bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4930bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4931d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator << are 4932d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in the global namespace. 4933d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Base { 4934d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4935d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit Base(int an_x) : x_(an_x) {} 4936d201456903f3ecae1f7794edfab0d5678e64226shiqian int x() const { return x_; } 4937d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4938d201456903f3ecae1f7794edfab0d5678e64226shiqian int x_; 4939d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4940d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4941d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base& val) { 4942d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4943d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4944d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4945d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base* pointer) { 4946d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4947d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4948d201456903f3ecae1f7794edfab0d5678e64226shiqian 4949d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 49509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4951d201456903f3ecae1f7794edfab0d5678e64226shiqian Base a(1); 4952d201456903f3ecae1f7794edfab0d5678e64226shiqian 4953d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 4954d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4955d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4956d201456903f3ecae1f7794edfab0d5678e64226shiqian 4957d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4958d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in an unnamed namespace. 4959d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 4960d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInUnnamedNameSpace : public Base { 4961d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4962d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {} 4963d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4964d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4965d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace& val) { 4966d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4967d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4968d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4969d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace* pointer) { 4970d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4971d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4972d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4973d201456903f3ecae1f7794edfab0d5678e64226shiqian 4974d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 49759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4976d201456903f3ecae1f7794edfab0d5678e64226shiqian MyTypeInUnnamedNameSpace a(1); 4977d201456903f3ecae1f7794edfab0d5678e64226shiqian 4978d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses <unnamed_namespace>::operator<<. 4979d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4980d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4981d201456903f3ecae1f7794edfab0d5678e64226shiqian 4982d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4983d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a user namespace. 4984d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace1 { 4985d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace1 : public Base { 4986d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4987d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInNameSpace1(int an_x): Base(an_x) {} 4988d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4989d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4990d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1& val) { 4991d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4992d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4993d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4994d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1* pointer) { 4995d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4996d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4997d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace1 4998d201456903f3ecae1f7794edfab0d5678e64226shiqian 4999d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 50009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5001d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace1::MyTypeInNameSpace1 a(1); 5002d201456903f3ecae1f7794edfab0d5678e64226shiqian 5003d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses namespace1::operator<<. 5004d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5005d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5006d201456903f3ecae1f7794edfab0d5678e64226shiqian 5007d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition is in a user namespace 5008d201456903f3ecae1f7794edfab0d5678e64226shiqian// but whose operator<< is in the global namespace. 5009d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace2 { 5010d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace2 : public ::Base { 5011d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 5012d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInNameSpace2(int an_x): Base(an_x) {} 5013d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5014d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace2 5015d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5016d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2& val) { 5017d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 5018d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5019d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5020d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2* pointer) { 5021d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 5022d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5023d201456903f3ecae1f7794edfab0d5678e64226shiqian 5024d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 50259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5026d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace2::MyTypeInNameSpace2 a(1); 5027d201456903f3ecae1f7794edfab0d5678e64226shiqian 5028d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 5029d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5030d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5031d201456903f3ecae1f7794edfab0d5678e64226shiqian 5032d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming NULL pointers to testing::Message. 5033d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, NullPointers) { 50349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5035d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = NULL; 5036d201456903f3ecae1f7794edfab0d5678e64226shiqian unsigned char* const p2 = NULL; 5037d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p3 = NULL; 5038d201456903f3ecae1f7794edfab0d5678e64226shiqian double* p4 = NULL; 5039d201456903f3ecae1f7794edfab0d5678e64226shiqian bool* p5 = NULL; 50409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message* p6 = NULL; 5041d201456903f3ecae1f7794edfab0d5678e64226shiqian 5042d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << p1 << p2 << p3 << p4 << p5 << p6; 5043d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 5044d201456903f3ecae1f7794edfab0d5678e64226shiqian msg.GetString().c_str()); 5045d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5046d201456903f3ecae1f7794edfab0d5678e64226shiqian 5047d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming wide strings to testing::Message. 5048d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, WideStrings) { 5049d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type const wchar_t*. 5050d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* const_wstr = NULL; 5051d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 5052d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 5053d201456903f3ecae1f7794edfab0d5678e64226shiqian 5054d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type wchar_t*. 5055d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* wstr = NULL; 5056d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 5057d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 5058d201456903f3ecae1f7794edfab0d5678e64226shiqian 5059d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type const wchar_t*. 5060d201456903f3ecae1f7794edfab0d5678e64226shiqian const_wstr = L"abc\x8119"; 5061d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 5062d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 5063d201456903f3ecae1f7794edfab0d5678e64226shiqian 5064d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type wchar_t*. 5065d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr = const_cast<wchar_t*>(const_wstr); 5066d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 5067d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 5068d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5069d201456903f3ecae1f7794edfab0d5678e64226shiqian 5070d201456903f3ecae1f7794edfab0d5678e64226shiqian 5071d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in the testing namespace. 5072d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 5073d201456903f3ecae1f7794edfab0d5678e64226shiqian 5074d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestInfo class. 5075d201456903f3ecae1f7794edfab0d5678e64226shiqian 50769b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestInfoTest : public Test { 5077d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5078b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan static const TestInfo* GetTestInfo(const char* test_name) { 5079b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestCase* const test_case = GetUnitTestImpl()-> 5080b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetTestCase("TestInfoTest", "", NULL, NULL); 5081b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 5082b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan for (int i = 0; i < test_case->total_test_count(); ++i) { 5083b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = test_case->GetTestInfo(i); 5084b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan if (strcmp(test_name, test_info->name()) == 0) 5085b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return test_info; 5086b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 5087b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return NULL; 5088d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5089d201456903f3ecae1f7794edfab0d5678e64226shiqian 5090d201456903f3ecae1f7794edfab0d5678e64226shiqian static const TestResult* GetTestResult( 50919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const TestInfo* test_info) { 5092d201456903f3ecae1f7794edfab0d5678e64226shiqian return test_info->result(); 5093d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5094d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5095d201456903f3ecae1f7794edfab0d5678e64226shiqian 5096d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::test_case_name() and TestInfo::name(). 5097d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, Names) { 5098b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("Names"); 5099d201456903f3ecae1f7794edfab0d5678e64226shiqian 5100d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 5101d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("Names", test_info->name()); 5102d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5103d201456903f3ecae1f7794edfab0d5678e64226shiqian 5104d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::result(). 5105d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, result) { 5106b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("result"); 5107d201456903f3ecae1f7794edfab0d5678e64226shiqian 5108d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initially, there is no TestPartResult for this test. 5109b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 5110d201456903f3ecae1f7794edfab0d5678e64226shiqian 5111d201456903f3ecae1f7794edfab0d5678e64226shiqian // After the previous assertion, there is still none. 5112b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 5113d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5114d201456903f3ecae1f7794edfab0d5678e64226shiqian 5115d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests setting up and tearing down a test case. 5116d201456903f3ecae1f7794edfab0d5678e64226shiqian 51179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SetUpTestCaseTest : public Test { 5118d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5119d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once before the first test in this test case 5120d201456903f3ecae1f7794edfab0d5678e64226shiqian // is run. 5121d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 5122d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Setting up the test case . . .\n"); 5123d201456903f3ecae1f7794edfab0d5678e64226shiqian 5124d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initializes some shared resource. In this simple example, we 5125d201456903f3ecae1f7794edfab0d5678e64226shiqian // just create a C string. More complex stuff can be done if 5126d201456903f3ecae1f7794edfab0d5678e64226shiqian // desired. 5127d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = "123"; 5128d201456903f3ecae1f7794edfab0d5678e64226shiqian 5129d201456903f3ecae1f7794edfab0d5678e64226shiqian // Increments the number of test cases that have been set up. 5130d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_++; 5131d201456903f3ecae1f7794edfab0d5678e64226shiqian 5132d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once. 5133d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 5134d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5135d201456903f3ecae1f7794edfab0d5678e64226shiqian 5136d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once after the last test in this test case is 5137d201456903f3ecae1f7794edfab0d5678e64226shiqian // run. 5138d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 5139d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Tearing down the test case . . .\n"); 5140d201456903f3ecae1f7794edfab0d5678e64226shiqian 5141d201456903f3ecae1f7794edfab0d5678e64226shiqian // Decrements the number of test cases that have been set up. 5142d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_--; 5143d201456903f3ecae1f7794edfab0d5678e64226shiqian 5144d201456903f3ecae1f7794edfab0d5678e64226shiqian // TearDownTestCase() should be called only once. 5145d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, counter_); 5146d201456903f3ecae1f7794edfab0d5678e64226shiqian 5147d201456903f3ecae1f7794edfab0d5678e64226shiqian // Cleans up the shared resource. 5148d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = NULL; 5149d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5150d201456903f3ecae1f7794edfab0d5678e64226shiqian 5151d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called before each test in this test case. 5152d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 5153d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once, so counter_ should 5154d201456903f3ecae1f7794edfab0d5678e64226shiqian // always be 1. 5155d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 5156d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5157d201456903f3ecae1f7794edfab0d5678e64226shiqian 5158d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of test cases that have been set up. 5159d201456903f3ecae1f7794edfab0d5678e64226shiqian static int counter_; 5160d201456903f3ecae1f7794edfab0d5678e64226shiqian 5161d201456903f3ecae1f7794edfab0d5678e64226shiqian // Some resource to be shared by all tests in this test case. 5162d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* shared_resource_; 5163d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5164d201456903f3ecae1f7794edfab0d5678e64226shiqian 5165d201456903f3ecae1f7794edfab0d5678e64226shiqianint SetUpTestCaseTest::counter_ = 0; 5166d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SetUpTestCaseTest::shared_resource_ = NULL; 5167d201456903f3ecae1f7794edfab0d5678e64226shiqian 5168d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test that uses the shared resource. 5169d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test1) { 5170d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(NULL, shared_resource_); 5171d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5172d201456903f3ecae1f7794edfab0d5678e64226shiqian 5173d201456903f3ecae1f7794edfab0d5678e64226shiqian// Another test that uses the shared resource. 5174d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test2) { 5175d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("123", shared_resource_); 5176d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5177d201456903f3ecae1f7794edfab0d5678e64226shiqian 5178d201456903f3ecae1f7794edfab0d5678e64226shiqian// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 5179d201456903f3ecae1f7794edfab0d5678e64226shiqian 5180d201456903f3ecae1f7794edfab0d5678e64226shiqian// The Flags struct stores a copy of all Google Test flags. 5181d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct Flags { 5182d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs a Flags struct where each flag has its default value. 5183fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags() : also_run_disabled_tests(false), 5184fe186c382905dcf57014985ccea8e067275e9f5fshiqian break_on_failure(false), 5185d201456903f3ecae1f7794edfab0d5678e64226shiqian catch_exceptions(false), 518653e0dc4041f660b6517b15b08b496e164be614f1shiqian death_test_use_fork(false), 5187d201456903f3ecae1f7794edfab0d5678e64226shiqian filter(""), 5188d201456903f3ecae1f7794edfab0d5678e64226shiqian list_tests(false), 5189d201456903f3ecae1f7794edfab0d5678e64226shiqian output(""), 5190f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan print_time(true), 51918bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan random_seed(0), 519240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan repeat(1), 51938bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan shuffle(false), 5194bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev stack_trace_depth(kMaxStackTraceDepth), 5195a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan stream_result_to(""), 519640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan throw_on_failure(false) {} 5197d201456903f3ecae1f7794edfab0d5678e64226shiqian 5198d201456903f3ecae1f7794edfab0d5678e64226shiqian // Factory methods. 5199d201456903f3ecae1f7794edfab0d5678e64226shiqian 5200fe186c382905dcf57014985ccea8e067275e9f5fshiqian // Creates a Flags struct where the gtest_also_run_disabled_tests flag has 5201fe186c382905dcf57014985ccea8e067275e9f5fshiqian // the given value. 5202fe186c382905dcf57014985ccea8e067275e9f5fshiqian static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { 5203fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags flags; 5204fe186c382905dcf57014985ccea8e067275e9f5fshiqian flags.also_run_disabled_tests = also_run_disabled_tests; 5205fe186c382905dcf57014985ccea8e067275e9f5fshiqian return flags; 5206fe186c382905dcf57014985ccea8e067275e9f5fshiqian } 5207fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5208d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_break_on_failure flag has 5209d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 5210d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags BreakOnFailure(bool break_on_failure) { 5211d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5212d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = break_on_failure; 5213d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5214d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5215d201456903f3ecae1f7794edfab0d5678e64226shiqian 5216d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_catch_exceptions flag has 5217d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 5218d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags CatchExceptions(bool catch_exceptions) { 5219d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5220d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.catch_exceptions = catch_exceptions; 5221d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5222d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5223d201456903f3ecae1f7794edfab0d5678e64226shiqian 522453e0dc4041f660b6517b15b08b496e164be614f1shiqian // Creates a Flags struct where the gtest_death_test_use_fork flag has 522553e0dc4041f660b6517b15b08b496e164be614f1shiqian // the given value. 522653e0dc4041f660b6517b15b08b496e164be614f1shiqian static Flags DeathTestUseFork(bool death_test_use_fork) { 522753e0dc4041f660b6517b15b08b496e164be614f1shiqian Flags flags; 522853e0dc4041f660b6517b15b08b496e164be614f1shiqian flags.death_test_use_fork = death_test_use_fork; 522953e0dc4041f660b6517b15b08b496e164be614f1shiqian return flags; 523053e0dc4041f660b6517b15b08b496e164be614f1shiqian } 523153e0dc4041f660b6517b15b08b496e164be614f1shiqian 5232d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_filter flag has the given 5233d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5234d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Filter(const char* filter) { 5235d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5236d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = filter; 5237d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5238d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5239d201456903f3ecae1f7794edfab0d5678e64226shiqian 5240d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_list_tests flag has the 5241d201456903f3ecae1f7794edfab0d5678e64226shiqian // given value. 5242d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags ListTests(bool list_tests) { 5243d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5244d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.list_tests = list_tests; 5245d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5246d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5247d201456903f3ecae1f7794edfab0d5678e64226shiqian 5248d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_output flag has the given 5249d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5250d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Output(const char* output) { 5251d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5252d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.output = output; 5253d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5254d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5255d201456903f3ecae1f7794edfab0d5678e64226shiqian 525615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // Creates a Flags struct where the gtest_print_time flag has the given 525715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // value. 525815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian static Flags PrintTime(bool print_time) { 525915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian Flags flags; 526015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian flags.print_time = print_time; 526115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian return flags; 526215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian } 526315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 52648bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_random_seed flag has 52658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 52668bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags RandomSeed(Int32 random_seed) { 52678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 52688bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.random_seed = random_seed; 52698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 52708bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 52718bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5272d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_repeat flag has the given 5273d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5274d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Repeat(Int32 repeat) { 5275d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5276d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.repeat = repeat; 5277d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5278d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5279d201456903f3ecae1f7794edfab0d5678e64226shiqian 52808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_shuffle flag has 52818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 52828bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags Shuffle(bool shuffle) { 52838bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 52848bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.shuffle = shuffle; 52858bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 52868bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 52878bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5288bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has 5289bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // the given value. 5290bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev static Flags StackTraceDepth(Int32 stack_trace_depth) { 5291bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags flags; 5292bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev flags.stack_trace_depth = stack_trace_depth; 5293bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev return flags; 5294bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev } 5295bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5296a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has 5297a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan // the given value. 5298a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan static Flags StreamResultTo(const char* stream_result_to) { 5299a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan Flags flags; 5300a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan flags.stream_result_to = stream_result_to; 5301a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan return flags; 5302a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan } 5303a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 530440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // Creates a Flags struct where the gtest_throw_on_failure flag has 530540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // the given value. 530640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan static Flags ThrowOnFailure(bool throw_on_failure) { 530740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan Flags flags; 530840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan flags.throw_on_failure = throw_on_failure; 530940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan return flags; 531040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan } 531140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 5312d201456903f3ecae1f7794edfab0d5678e64226shiqian // These fields store the flag values. 5313fe186c382905dcf57014985ccea8e067275e9f5fshiqian bool also_run_disabled_tests; 5314d201456903f3ecae1f7794edfab0d5678e64226shiqian bool break_on_failure; 5315d201456903f3ecae1f7794edfab0d5678e64226shiqian bool catch_exceptions; 531653e0dc4041f660b6517b15b08b496e164be614f1shiqian bool death_test_use_fork; 5317d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* filter; 5318d201456903f3ecae1f7794edfab0d5678e64226shiqian bool list_tests; 5319d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* output; 532015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian bool print_time; 53218bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Int32 random_seed; 5322d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 repeat; 53238bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan bool shuffle; 5324bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Int32 stack_trace_depth; 5325a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* stream_result_to; 532640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan bool throw_on_failure; 5327d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5328d201456903f3ecae1f7794edfab0d5678e64226shiqian 5329d201456903f3ecae1f7794edfab0d5678e64226shiqian// Fixture for testing InitGoogleTest(). 53309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass InitGoogleTestTest : public Test { 5331d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5332d201456903f3ecae1f7794edfab0d5678e64226shiqian // Clears the flags before each test. 5333d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 5334fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 5335d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(break_on_failure) = false; 5336d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(catch_exceptions) = false; 533753e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 5338d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(filter) = ""; 5339d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(list_tests) = false; 5340d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(output) = ""; 5341f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 53428bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 5343d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(repeat) = 1; 53448bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 5345bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 5346a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = ""; 534740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 5348d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5349d201456903f3ecae1f7794edfab0d5678e64226shiqian 5350d201456903f3ecae1f7794edfab0d5678e64226shiqian // Asserts that two narrow or wide string arrays are equal. 5351d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 5352d201456903f3ecae1f7794edfab0d5678e64226shiqian static void AssertStringArrayEq(size_t size1, CharType** array1, 5353d201456903f3ecae1f7794edfab0d5678e64226shiqian size_t size2, CharType** array2) { 5354d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(size1, size2) << " Array sizes different."; 5355d201456903f3ecae1f7794edfab0d5678e64226shiqian 5356d201456903f3ecae1f7794edfab0d5678e64226shiqian for (size_t i = 0; i != size1; i++) { 5357d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 5358d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5359d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5360d201456903f3ecae1f7794edfab0d5678e64226shiqian 5361d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the flag values match the expected values. 5362d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CheckFlags(const Flags& expected) { 5363fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_EQ(expected.also_run_disabled_tests, 5364fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests)); 5365d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 5366d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 536753e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork)); 5368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 5369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 5370d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 537115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 53728bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed)); 5373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 53748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle)); 5375bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth)); 5376a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_STREQ(expected.stream_result_to, 5377a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to).c_str()); 5378a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure)); 5379d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5380d201456903f3ecae1f7794edfab0d5678e64226shiqian 5381d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses a command line (specified by argc1 and argv1), then 5382d201456903f3ecae1f7794edfab0d5678e64226shiqian // verifies that the flag values are expected and that the 5383d201456903f3ecae1f7794edfab0d5678e64226shiqian // recognized flags are removed from the command line. 5384d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 5385d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TestParsingFlags(int argc1, const CharType** argv1, 5386d201456903f3ecae1f7794edfab0d5678e64226shiqian int argc2, const CharType** argv2, 5387bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const Flags& expected, bool should_print_help) { 5388bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const bool saved_help_flag = ::testing::internal::g_help_flag; 5389bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev ::testing::internal::g_help_flag = false; 5390bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 539135c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 539281e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan CaptureStdout(); 539335c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 539481e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 5395d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses the command line. 53961998cf5d32a19aaffe8652545802744d9133022dvladlosev internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); 5397d201456903f3ecae1f7794edfab0d5678e64226shiqian 539835c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 539981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan const String captured_stdout = GetCapturedStdout(); 540035c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 540181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 5402d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies the flag values. 5403d201456903f3ecae1f7794edfab0d5678e64226shiqian CheckFlags(expected); 5404d201456903f3ecae1f7794edfab0d5678e64226shiqian 5405d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the recognized flags are removed from the command 5406d201456903f3ecae1f7794edfab0d5678e64226shiqian // line. 5407d201456903f3ecae1f7794edfab0d5678e64226shiqian AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 5408bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5409bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the 5410bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // help message for the flags it recognizes. 5411bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag); 5412bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 541335c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 541481e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan const char* const expected_help_fragment = 541581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan "This program contains tests written using"; 541681e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan if (should_print_help) { 541781e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout); 541881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan } else { 541981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan EXPECT_PRED_FORMAT2(IsNotSubstring, 542081e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan expected_help_fragment, captured_stdout); 542181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan } 542235c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif // GTEST_HAS_STREAM_REDIRECTION 5423bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5424bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev ::testing::internal::g_help_flag = saved_help_flag; 5425d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5426d201456903f3ecae1f7794edfab0d5678e64226shiqian 5427d201456903f3ecae1f7794edfab0d5678e64226shiqian // This macro wraps TestParsingFlags s.t. the user doesn't need 5428d201456903f3ecae1f7794edfab0d5678e64226shiqian // to specify the array sizes. 5429bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \ 5430d201456903f3ecae1f7794edfab0d5678e64226shiqian TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 5431bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev sizeof(argv2)/sizeof(*argv2) - 1, argv2, \ 5432bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev expected, should_print_help) 5433d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5434d201456903f3ecae1f7794edfab0d5678e64226shiqian 5435d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty command line. 5436d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Empty) { 5437d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5438d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5439d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5440d201456903f3ecae1f7794edfab0d5678e64226shiqian 5441d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5442d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5443d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5444d201456903f3ecae1f7794edfab0d5678e64226shiqian 5445bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 5446d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5447d201456903f3ecae1f7794edfab0d5678e64226shiqian 5448d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a command line that has no flag. 5449d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, NoFlag) { 5450d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5451d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5452d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5453d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5454d201456903f3ecae1f7794edfab0d5678e64226shiqian 5455d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5456d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5457d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5458d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5459d201456903f3ecae1f7794edfab0d5678e64226shiqian 5460bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 5461d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5462d201456903f3ecae1f7794edfab0d5678e64226shiqian 5463d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a bad --gtest_filter flag. 5464d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterBad) { 5465d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5466d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5467d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 5468d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5469d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5470d201456903f3ecae1f7794edfab0d5678e64226shiqian 5471d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5472d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5473d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 5474d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5475d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5476d201456903f3ecae1f7794edfab0d5678e64226shiqian 5477bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true); 5478d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5479d201456903f3ecae1f7794edfab0d5678e64226shiqian 5480d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty --gtest_filter flag. 5481d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterEmpty) { 5482d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5483d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5484d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=", 5485d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5486d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5487d201456903f3ecae1f7794edfab0d5678e64226shiqian 5488d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5489d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5490d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5491d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5492d201456903f3ecae1f7794edfab0d5678e64226shiqian 5493bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false); 5494d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5495d201456903f3ecae1f7794edfab0d5678e64226shiqian 5496d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a non-empty --gtest_filter flag. 5497d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterNonEmpty) { 5498d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5499d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5500d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=abc", 5501d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5502d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5503d201456903f3ecae1f7794edfab0d5678e64226shiqian 5504d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5505d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5506d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5507d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5508d201456903f3ecae1f7794edfab0d5678e64226shiqian 5509bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); 5510d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5511d201456903f3ecae1f7794edfab0d5678e64226shiqian 5512d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure. 55138bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) { 5514d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5515d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5516d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 5517d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5518d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5519d201456903f3ecae1f7794edfab0d5678e64226shiqian 5520d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5521d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5522d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5523d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5524d201456903f3ecae1f7794edfab0d5678e64226shiqian 5525bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 5526d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5527d201456903f3ecae1f7794edfab0d5678e64226shiqian 5528d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=0. 5529d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 5530d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5531d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5532d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=0", 5533d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5534d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5535d201456903f3ecae1f7794edfab0d5678e64226shiqian 5536d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5537d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5538d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5539d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5540d201456903f3ecae1f7794edfab0d5678e64226shiqian 5541bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5542d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5543d201456903f3ecae1f7794edfab0d5678e64226shiqian 5544d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=f. 5545d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 5546d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5547d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5548d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=f", 5549d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5550d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5551d201456903f3ecae1f7794edfab0d5678e64226shiqian 5552d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5553d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5554d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5555d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5556d201456903f3ecae1f7794edfab0d5678e64226shiqian 5557bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5558d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5559d201456903f3ecae1f7794edfab0d5678e64226shiqian 5560d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 5561d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 5562d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5563d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5564d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=F", 5565d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5566d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5567d201456903f3ecae1f7794edfab0d5678e64226shiqian 5568d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5569d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5570d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5571d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5572d201456903f3ecae1f7794edfab0d5678e64226shiqian 5573bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5574d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5575d201456903f3ecae1f7794edfab0d5678e64226shiqian 5576d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a --gtest_break_on_failure flag that has a "true" 5577d201456903f3ecae1f7794edfab0d5678e64226shiqian// definition. 5578d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 5579d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5580d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5581d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=1", 5582d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5583d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5584d201456903f3ecae1f7794edfab0d5678e64226shiqian 5585d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5586d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5587d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5588d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5589d201456903f3ecae1f7794edfab0d5678e64226shiqian 5590bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 5591d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5592d201456903f3ecae1f7794edfab0d5678e64226shiqian 5593d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_catch_exceptions. 5594d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, CatchExceptions) { 5595d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5596d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5597d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_catch_exceptions", 5598d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5599d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5600d201456903f3ecae1f7794edfab0d5678e64226shiqian 5601d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5602d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5603d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5604d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5605d201456903f3ecae1f7794edfab0d5678e64226shiqian 5606bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false); 5607d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5608d201456903f3ecae1f7794edfab0d5678e64226shiqian 560953e0dc4041f660b6517b15b08b496e164be614f1shiqian// Tests parsing --gtest_death_test_use_fork. 561053e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(InitGoogleTestTest, DeathTestUseFork) { 561153e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv[] = { 561253e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 561353e0dc4041f660b6517b15b08b496e164be614f1shiqian "--gtest_death_test_use_fork", 561453e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 561553e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 561653e0dc4041f660b6517b15b08b496e164be614f1shiqian 561753e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv2[] = { 561853e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 561953e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 562053e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 562153e0dc4041f660b6517b15b08b496e164be614f1shiqian 5622bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false); 562353e0dc4041f660b6517b15b08b496e164be614f1shiqian} 562453e0dc4041f660b6517b15b08b496e164be614f1shiqian 5625d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having the same flag twice with different values. The 5626d201456903f3ecae1f7794edfab0d5678e64226shiqian// expected behavior is that the one coming last takes precedence. 5627d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, DuplicatedFlags) { 5628d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5629d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5630d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=a", 5631d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5632d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5633d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5634d201456903f3ecae1f7794edfab0d5678e64226shiqian 5635d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5636d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5637d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5638d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5639d201456903f3ecae1f7794edfab0d5678e64226shiqian 5640bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false); 5641d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5642d201456903f3ecae1f7794edfab0d5678e64226shiqian 5643d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having an unrecognized flag on the command line. 5644d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 5645d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5646d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5647d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 5648d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", // Unrecognized by Google Test. 5649d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5650d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5651d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5652d201456903f3ecae1f7794edfab0d5678e64226shiqian 5653d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5654d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5655d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", 5656d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5657d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5658d201456903f3ecae1f7794edfab0d5678e64226shiqian 5659d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5660d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = true; 5661d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = "b"; 5662bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false); 5663d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5664d201456903f3ecae1f7794edfab0d5678e64226shiqian 5665d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag 5666d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFlag) { 5667d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5668d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5669d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests", 5670d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5671d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5672d201456903f3ecae1f7794edfab0d5678e64226shiqian 5673d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5674d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5675d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5676d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5677d201456903f3ecae1f7794edfab0d5678e64226shiqian 5678bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 5679d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5680d201456903f3ecae1f7794edfab0d5678e64226shiqian 5681d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "true" value 5682d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsTrue) { 5683d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5684d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5685d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=1", 5686d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5687d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5688d201456903f3ecae1f7794edfab0d5678e64226shiqian 5689d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5690d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5691d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5692d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5693d201456903f3ecae1f7794edfab0d5678e64226shiqian 5694bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 5695d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5696d201456903f3ecae1f7794edfab0d5678e64226shiqian 5697d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "false" value 5698d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse) { 5699d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5700d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5701d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=0", 5702d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5703d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5704d201456903f3ecae1f7794edfab0d5678e64226shiqian 5705d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5706d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5707d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5708d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5709d201456903f3ecae1f7794edfab0d5678e64226shiqian 5710bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 5711d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5712d201456903f3ecae1f7794edfab0d5678e64226shiqian 5713d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_list_tests=f. 5714d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 5715d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5716d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5717d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=f", 5718d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5719d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5720d201456903f3ecae1f7794edfab0d5678e64226shiqian 5721d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5722d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5723d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5724d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5725d201456903f3ecae1f7794edfab0d5678e64226shiqian 5726bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 5727d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5728d201456903f3ecae1f7794edfab0d5678e64226shiqian 57298bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_list_tests=F. 5730d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 5731d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5732d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5733d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=F", 5734d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5735d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5736d201456903f3ecae1f7794edfab0d5678e64226shiqian 5737d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5738d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5739d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5740d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5741d201456903f3ecae1f7794edfab0d5678e64226shiqian 5742bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 5743d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5744d201456903f3ecae1f7794edfab0d5678e64226shiqian 5745d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output (invalid). 5746d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputEmpty) { 5747d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5748d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5749d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 5750d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5751d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5752d201456903f3ecae1f7794edfab0d5678e64226shiqian 5753d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5754d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5755d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 5756d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5757d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5758d201456903f3ecae1f7794edfab0d5678e64226shiqian 5759bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true); 5760d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5761d201456903f3ecae1f7794edfab0d5678e64226shiqian 5762d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml 5763d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXml) { 5764d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5765d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5766d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml", 5767d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5768d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5769d201456903f3ecae1f7794edfab0d5678e64226shiqian 5770d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5771d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5772d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5773d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5774d201456903f3ecae1f7794edfab0d5678e64226shiqian 5775bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false); 5776d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5777d201456903f3ecae1f7794edfab0d5678e64226shiqian 5778d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:file 5779d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlFile) { 5780d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5781d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5782d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:file", 5783d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5784d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5785d201456903f3ecae1f7794edfab0d5678e64226shiqian 5786d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5787d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5788d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5789d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5790d201456903f3ecae1f7794edfab0d5678e64226shiqian 5791bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false); 5792d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5793d201456903f3ecae1f7794edfab0d5678e64226shiqian 5794d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:directory/path/ 5795d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 5796d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5797d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5798d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:directory/path/", 5799d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5800d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5801d201456903f3ecae1f7794edfab0d5678e64226shiqian 5802d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5803d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5804d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5805d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5806d201456903f3ecae1f7794edfab0d5678e64226shiqian 5807bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 5808bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::Output("xml:directory/path/"), false); 5809d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5810d201456903f3ecae1f7794edfab0d5678e64226shiqian 581115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag 581215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFlag) { 581315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 581415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 581515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time", 581615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 581715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 581815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 581915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 582015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 582115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 582215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 582315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5824bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 582515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 582615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 582715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "true" value 582815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeTrue) { 582915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 583015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 583115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=1", 583215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 583315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 583415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 583515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 583615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 583715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 583815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 583915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5840bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 584115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 584215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 584315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "false" value 584415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse) { 584515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 584615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 584715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=0", 584815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 584915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 585015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 585115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 585215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 585315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 585415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 585515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5856bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 585715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 585815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 585915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=f. 586015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 586115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 586215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 586315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=f", 586415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 586515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 586615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 586715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 586815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 586915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 587015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 587115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5872bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 587315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 587415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 587515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=F. 587615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 587715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 587815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 587915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=F", 588015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 588115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 588215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 588315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 588415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 588515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 588615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 588715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5888bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 588915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 589015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 58918bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_random_seed=number 58928bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, RandomSeed) { 58938bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 58948bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 58958bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_random_seed=1000", 58968bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 58978bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 58988bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 58998bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 59008bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 59018bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 59028bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 59038bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5904bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false); 59058bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 59068bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5907d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_repeat=number 5908d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Repeat) { 5909d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5910d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5911d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_repeat=1000", 5912d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5913d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5914d201456903f3ecae1f7794edfab0d5678e64226shiqian 5915d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5916d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5917d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5918d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5919d201456903f3ecae1f7794edfab0d5678e64226shiqian 5920bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false); 5921d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5922d201456903f3ecae1f7794edfab0d5678e64226shiqian 5923fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag 5924fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { 5925fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5926fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5927fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests", 5928fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5929fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5930fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5931fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5932fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5933fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5934fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5935fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5936bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 5937bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(true), false); 5938fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5939fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5940fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "true" value 5941fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { 5942fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5943fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5944fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=1", 5945fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5946fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5947fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5948fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5949fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5950fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5951fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5952fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5953bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 5954bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(true), false); 5955fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5956fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5957fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "false" value 5958fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { 5959fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5960fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5961fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=0", 5962fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5963fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5964fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5965fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5966fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5967fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5968fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5969fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5970bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 5971bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(false), false); 5972fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5973fe186c382905dcf57014985ccea8e067275e9f5fshiqian 59748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle. 59758bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleWithoutValue) { 59768bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 59778bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 59788bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle", 59798bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 59808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan}; 59818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 59828bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 59838bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 59848bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 59858bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 59868bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5987bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 59888bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 59898bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 59908bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle=0. 59918bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleFalse_0) { 59928bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 59938bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 59948bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=0", 59958bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 59968bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 59978bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 59988bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 59998bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 60008bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 60018bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 60028bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6003bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false); 60048bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 60058bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 60068bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing a --gtest_shuffle flag that has a "true" 60078bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// definition. 60088bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleTrue) { 60098bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 60108bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 60118bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=1", 60128bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 60138bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 60148bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 60158bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 60168bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 60178bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 60188bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 60198bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6020bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 6021bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev} 6022bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6023bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev// Tests parsing --gtest_stack_trace_depth=number. 6024bf26ca01f23e432f8b2355fd700707ba217a7605vladlosevTEST_F(InitGoogleTestTest, StackTraceDepth) { 6025bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const char* argv[] = { 6026bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "foo.exe", 6027bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "--gtest_stack_trace_depth=5", 6028bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev NULL 6029bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev }; 6030bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6031bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const char* argv2[] = { 6032bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "foo.exe", 6033bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev NULL 6034bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev }; 6035bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6036bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false); 60378bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 603840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6039a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wanTEST_F(InitGoogleTestTest, StreamResultTo) { 6040a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* argv[] = { 6041a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "foo.exe", 6042a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "--gtest_stream_result_to=localhost:1234", 6043a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan NULL 6044a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan }; 6045a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 6046a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* argv2[] = { 6047a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "foo.exe", 6048a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan NULL 6049a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan }; 6050a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 6051a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_TEST_PARSING_FLAGS_( 6052a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan argv, argv2, Flags::StreamResultTo("localhost:1234"), false); 6053a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan} 6054a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 605540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure. 60568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) { 605740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 605840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 605940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure", 606040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 606140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan}; 606240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 606340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 606440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 606540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 606640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 606740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6068bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 606940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 607040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 607140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure=0. 607240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { 607340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 607440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 607540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=0", 607640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 607740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 607840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 607940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 608040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 608140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 608240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 608340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6084bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false); 608540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 608640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 608740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing a --gtest_throw_on_failure flag that has a "true" 608840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// definition. 608940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { 609040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 609140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 609240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=1", 609340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 609440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 609540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 609640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 609740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 609840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 609940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 610040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6101bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 610240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 610340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 61040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 6105d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing wide strings. 6106d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, WideStrings) { 6107d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv[] = { 6108d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 6109d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_filter=Foo*", 6110d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_list_tests=1", 6111d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_break_on_failure", 6112d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 6113d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6114d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6115d201456903f3ecae1f7794edfab0d5678e64226shiqian 6116d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv2[] = { 6117d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 6118d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 6119d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6120d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6121d201456903f3ecae1f7794edfab0d5678e64226shiqian 6122d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags expected_flags; 6123d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.break_on_failure = true; 6124d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.filter = "Foo*"; 6125d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.list_tests = true; 6126d201456903f3ecae1f7794edfab0d5678e64226shiqian 6127bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false); 6128d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6129d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 6130d201456903f3ecae1f7794edfab0d5678e64226shiqian 6131d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests current_test_info() in UnitTest. 6132d201456903f3ecae1f7794edfab0d5678e64226shiqianclass CurrentTestInfoTest : public Test { 6133d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 6134d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL before the first test in 6135d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case is run. 6136d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 6137d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be no tests running at this point. 6138d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6139d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6140e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 6141d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 6142d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6143d201456903f3ecae1f7794edfab0d5678e64226shiqian 6144d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL after the last test in 6145d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case has run. 6146d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 6147d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6148d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6149e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 6150d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 6151d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6152d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 6153d201456903f3ecae1f7794edfab0d5678e64226shiqian 6154d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 6155d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. 6156d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 6157d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6158d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6159d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 6160d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 6161d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 6162d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 6163d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 6164d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 6165d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6166d201456903f3ecae1f7794edfab0d5678e64226shiqian 6167d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 6168d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. We 6169d201456903f3ecae1f7794edfab0d5678e64226shiqian// use this test to see that the TestInfo object actually changed from 6170d201456903f3ecae1f7794edfab0d5678e64226shiqian// the previous invocation. 6171d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 6172d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6173d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6174d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 6175d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 6176d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 6177d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 6178d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 6179d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 6180d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6181d201456903f3ecae1f7794edfab0d5678e64226shiqian 6182d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 6183d201456903f3ecae1f7794edfab0d5678e64226shiqian 6184d201456903f3ecae1f7794edfab0d5678e64226shiqian// These two lines test that we can define tests in a namespace that 6185d201456903f3ecae1f7794edfab0d5678e64226shiqian// has the name "testing" and is nested in another namespace. 6186d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace my_namespace { 6187d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 6188d201456903f3ecae1f7794edfab0d5678e64226shiqian 6189d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that TEST knows to use ::testing::Test instead of 6190d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Test. 6191d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Test {}; 6192d201456903f3ecae1f7794edfab0d5678e64226shiqian 6193d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use ::testing::Message instead of 6194d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Message. 6195d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message {}; 6196d201456903f3ecae1f7794edfab0d5678e64226shiqian 6197d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use 6198d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::testing::AssertionResult instead of 6199d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::AssertionResult. 6200d201456903f3ecae1f7794edfab0d5678e64226shiqianclass AssertionResult {}; 6201d201456903f3ecae1f7794edfab0d5678e64226shiqian 6202d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should succeed works as expected. 6203d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Success) { 6204d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "This shouldn't fail."; 6205d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6206d201456903f3ecae1f7794edfab0d5678e64226shiqian 6207d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should fail works as expected. 6208d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Failure) { 6209d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 6210d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is expected."); 6211d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6212d201456903f3ecae1f7794edfab0d5678e64226shiqian 6213d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 6214d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace my_namespace 6215d201456903f3ecae1f7794edfab0d5678e64226shiqian 6216d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that one can call superclass SetUp and TearDown methods-- 6217d201456903f3ecae1f7794edfab0d5678e64226shiqian// that is, that they are not private. 6218d201456903f3ecae1f7794edfab0d5678e64226shiqian// No tests are based on this fixture; the test "passes" if it compiles 6219d201456903f3ecae1f7794edfab0d5678e64226shiqian// successfully. 62209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass ProtectedFixtureMethodsTest : public Test { 6221d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 6222d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 62239b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::SetUp(); 6224d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6225d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 62269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::TearDown(); 6227d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6228d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 6229d201456903f3ecae1f7794edfab0d5678e64226shiqian 6230d201456903f3ecae1f7794edfab0d5678e64226shiqian// StreamingAssertionsTest tests the streaming versions of a representative 6231d201456903f3ecae1f7794edfab0d5678e64226shiqian// sample of assertions. 6232d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Unconditional) { 6233d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "expected success"; 6234d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 6235d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6236d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 6237d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6238d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6239d201456903f3ecae1f7794edfab0d5678e64226shiqian 6240c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 6241c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 6242c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 6243c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 6244c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 6245d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth) { 6246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true) << "unexpected failure"; 6247d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true) << "unexpected failure"; 6248d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 6249d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6250d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 6251d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6252d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6253d201456903f3ecae1f7794edfab0d5678e64226shiqian 6254d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth2) { 6255d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "unexpected failure"; 6256d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(false) << "unexpected failure"; 6257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 6258d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6259d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 6260d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6261d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6262d201456903f3ecae1f7794edfab0d5678e64226shiqian 6263c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 6264c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 6265c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 6266c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 6267c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 6268d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerEquals) { 6269d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "unexpected failure"; 6270d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "unexpected failure"; 6271d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 6272d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6273d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 6274d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6275d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6276d201456903f3ecae1f7794edfab0d5678e64226shiqian 6277d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerLessThan) { 6278d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(1, 2) << "unexpected failure"; 6279d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 2) << "unexpected failure"; 6280d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 6281d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6282d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 6283d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6284d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6285d201456903f3ecae1f7794edfab0d5678e64226shiqian 6286d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqual) { 6287d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", "foo") << "unexpected failure"; 6288d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("foo", "foo") << "unexpected failure"; 6289d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 6290d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6291d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 6292d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6293d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6294d201456903f3ecae1f7794edfab0d5678e64226shiqian 6295d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsNotEqual) { 6296d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("foo", "bar") << "unexpected failure"; 6297d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("foo", "bar") << "unexpected failure"; 6298d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 6299d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6300d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 6301d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6302d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6303d201456903f3ecae1f7794edfab0d5678e64226shiqian 6304d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 6305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 6306d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 6307d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 6308d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6309d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 6310d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6311d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6312d201456903f3ecae1f7794edfab0d5678e64226shiqian 6313d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 6314d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 6315d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 6316d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 6317d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6318d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 6319d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6320d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6321d201456903f3ecae1f7794edfab0d5678e64226shiqian 6322d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, FloatingPointEquals) { 6323d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 6324d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 6325d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 6326d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6327d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 6328d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6329d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6330d201456903f3ecae1f7794edfab0d5678e64226shiqian 633136865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 633236865d8d354465e3461eedf2949a4b7799985d5dshiqian 633336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, Throw) { 633436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 633536865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 633636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 633736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 633836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 633936865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 634036865d8d354465e3461eedf2949a4b7799985d5dshiqian} 634136865d8d354465e3461eedf2949a4b7799985d5dshiqian 634236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, NoThrow) { 6343886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure"; 6344886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure"; 634536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 634636865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 634736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 634836865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 634936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 635036865d8d354465e3461eedf2949a4b7799985d5dshiqian 635136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, AnyThrow) { 635236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 635336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 6354886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) << 635536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 6356886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << 635736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 635836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 635936865d8d354465e3461eedf2949a4b7799985d5dshiqian 636036865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 636136865d8d354465e3461eedf2949a4b7799985d5dshiqian 6362d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test correctly decides whether to use colors in the output. 6363d201456903f3ecae1f7794edfab0d5678e64226shiqian 6364d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 6365d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "yes"; 6366d201456903f3ecae1f7794edfab0d5678e64226shiqian 6367d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6370d201456903f3ecae1f7794edfab0d5678e64226shiqian 6371d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6372d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6374d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6375d201456903f3ecae1f7794edfab0d5678e64226shiqian 6376d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 6377d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6378d201456903f3ecae1f7794edfab0d5678e64226shiqian 6379d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "True"; 6380d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6381d201456903f3ecae1f7794edfab0d5678e64226shiqian 6382d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "t"; 6383d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6384d201456903f3ecae1f7794edfab0d5678e64226shiqian 6385d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "1"; 6386d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6387d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6388d201456903f3ecae1f7794edfab0d5678e64226shiqian 6389d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 6390d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "no"; 6391d201456903f3ecae1f7794edfab0d5678e64226shiqian 6392d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6393d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6394d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6395d201456903f3ecae1f7794edfab0d5678e64226shiqian 6396d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6397d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6398d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6399d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6400d201456903f3ecae1f7794edfab0d5678e64226shiqian 6401d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 6402d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6403d201456903f3ecae1f7794edfab0d5678e64226shiqian 6404d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "F"; 6405d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6406d201456903f3ecae1f7794edfab0d5678e64226shiqian 6407d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "0"; 6408d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6409d201456903f3ecae1f7794edfab0d5678e64226shiqian 6410d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "unknown"; 6411d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6412d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6413d201456903f3ecae1f7794edfab0d5678e64226shiqian 6414d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 6415d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 6416d201456903f3ecae1f7794edfab0d5678e64226shiqian 6417d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6418d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6419d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6420d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6421d201456903f3ecae1f7794edfab0d5678e64226shiqian 6422d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 6423d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 6424d201456903f3ecae1f7794edfab0d5678e64226shiqian 64250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 6426d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Windows, we ignore the TERM variable as it's usually not set. 6427d201456903f3ecae1f7794edfab0d5678e64226shiqian 6428d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); 6429d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6430d201456903f3ecae1f7794edfab0d5678e64226shiqian 6431d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", ""); 6432d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6433d201456903f3ecae1f7794edfab0d5678e64226shiqian 6434d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); 6435d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6436d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 6437d201456903f3ecae1f7794edfab0d5678e64226shiqian // On non-Windows platforms, we rely on TERM to determine if the 6438d201456903f3ecae1f7794edfab0d5678e64226shiqian // terminal supports colors. 6439d201456903f3ecae1f7794edfab0d5678e64226shiqian 6440d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6441d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6442d201456903f3ecae1f7794edfab0d5678e64226shiqian 6443d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "emacs"); // TERM doesn't support colors. 6444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6445d201456903f3ecae1f7794edfab0d5678e64226shiqian 6446d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "vt100"); // TERM doesn't support colors. 6447d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6448d201456903f3ecae1f7794edfab0d5678e64226shiqian 6449d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 6450d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6451d201456903f3ecae1f7794edfab0d5678e64226shiqian 6452d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6453d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6454d201456903f3ecae1f7794edfab0d5678e64226shiqian 6455d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-color"); // TERM supports colors. 6456d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 645789080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 6458e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "xterm-256color"); // TERM supports colors. 6459e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6460e05489605fc58736f837563db1fc33f9131ee810vladlosev 6461e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "screen"); // TERM supports colors. 6462e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6463e05489605fc58736f837563db1fc33f9131ee810vladlosev 646489080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan SetEnv("TERM", "linux"); // TERM supports colors. 646589080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6466e05489605fc58736f837563db1fc33f9131ee810vladlosev 6467e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "cygwin"); // TERM supports colors. 6468e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6469d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 6470d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6471d201456903f3ecae1f7794edfab0d5678e64226shiqian 647253e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a namespace scope. 647353e0dc4041f660b6517b15b08b496e164be614f1shiqian 647448b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wanstatic bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>(); 647548b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wanstatic bool dummy2 GTEST_ATTRIBUTE_UNUSED_ = 647648b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan StaticAssertTypeEq<const int, const int>(); 647753e0dc4041f660b6517b15b08b496e164be614f1shiqian 647853e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a class. 647953e0dc4041f660b6517b15b08b496e164be614f1shiqian 648053e0dc4041f660b6517b15b08b496e164be614f1shiqiantemplate <typename T> 648153e0dc4041f660b6517b15b08b496e164be614f1shiqianclass StaticAssertTypeEqTestHelper { 648253e0dc4041f660b6517b15b08b496e164be614f1shiqian public: 648353e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); } 648453e0dc4041f660b6517b15b08b496e164be614f1shiqian}; 648553e0dc4041f660b6517b15b08b496e164be614f1shiqian 648653e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, WorksInClass) { 648753e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper<bool>(); 648853e0dc4041f660b6517b15b08b496e164be614f1shiqian} 648953e0dc4041f660b6517b15b08b496e164be614f1shiqian 649053e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works inside a function. 649153e0dc4041f660b6517b15b08b496e164be614f1shiqian 649253e0dc4041f660b6517b15b08b496e164be614f1shiqiantypedef int IntAlias; 649353e0dc4041f660b6517b15b08b496e164be614f1shiqian 649453e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, CompilesForEqualTypes) { 649553e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int, IntAlias>(); 649653e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int*, IntAlias*>(); 649753e0dc4041f660b6517b15b08b496e164be614f1shiqian} 649853e0dc4041f660b6517b15b08b496e164be614f1shiqian 64993d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) { 65003d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev testing::UnitTest* const unit_test = testing::UnitTest::GetInstance(); 65013d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 65023d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // We don't have a stack walker in Google Test yet. 65033d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str()); 65043d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str()); 65053d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 6506c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6507c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) { 6508c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailure()); 6509c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6510c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6511c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic void FailFatally() { FAIL(); } 6512c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6513c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) { 6514c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6515c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6516c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6517c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(has_nonfatal_failure); 6518c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6519c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6520c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 6521c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6522c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6523c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6524c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6525c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6526c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6527c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 6528c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6529c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6530c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6531c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6532c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6533c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6534c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6535c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasNonfatalFailure outside of a test body. 6536c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasNonfatalFailureHelper() { 6537c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan return testing::Test::HasNonfatalFailure(); 6538c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6539c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6540c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) { 6541c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailureHelper()); 6542c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6543c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6544c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) { 6545c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6546c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailureHelper(); 6547c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6548c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6549c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6550c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6551c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) { 6552c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailure()); 6553c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6554c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6555c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) { 6556c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6557c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6558c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6559c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6560c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6561c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6562c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 6563c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6564c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6565c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6566c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6567c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6568c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6569c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 6570c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6571c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6572c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6573c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6574c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6575c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6576c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6577c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasFailure outside of a test body. 6578c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasFailureHelper() { return testing::Test::HasFailure(); } 6579c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6580c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody) { 6581c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailureHelper()); 6582c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6583c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6584c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody2) { 6585c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6586c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailureHelper(); 6587c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6588c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6589c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 659016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 659116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanclass TestListener : public EmptyTestEventListener { 659216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 659316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {} 659416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener(int* on_start_counter, bool* is_destroyed) 659516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan : on_start_counter_(on_start_counter), 659616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan is_destroyed_(is_destroyed) {} 659716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 659816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan virtual ~TestListener() { 659916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan if (is_destroyed_) 660016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *is_destroyed_ = true; 660116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 660216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 660316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan protected: 6604f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 660516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan if (on_start_counter_ != NULL) 660616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan (*on_start_counter_)++; 660716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 660816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 660916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan private: 661016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int* on_start_counter_; 661116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool* is_destroyed_; 661216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 661316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 661416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests the constructor. 6615f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, ConstructionWorks) { 6616f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 661716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6618f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL); 661916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 662016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 662116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 662216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6623f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that the TestEventListeners destructor deletes all the listeners it 662416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// owns. 6625f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, DestructionWorks) { 662616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool default_result_printer_is_destroyed = false; 662716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool default_xml_printer_is_destroyed = false; 662816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool extra_listener_is_destroyed = false; 662916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* default_result_printer = new TestListener( 663016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &default_result_printer_is_destroyed); 663116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* default_xml_printer = new TestListener( 663216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &default_xml_printer_is_destroyed); 663316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* extra_listener = new TestListener( 663416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &extra_listener_is_destroyed); 663516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 663616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 6637f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6638f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, 6639f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan default_result_printer); 6640f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, 6641f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan default_xml_printer); 664216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(extra_listener); 664316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 664416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(default_result_printer_is_destroyed); 664516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(default_xml_printer_is_destroyed); 664616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(extra_listener_is_destroyed); 664716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 664816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6649f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that a listener Append'ed to a TestEventListeners list starts 665016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events. 6651f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, Append) { 665216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 665316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 665416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 665516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 6656f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 665716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 6658f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 665916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 666016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 666116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 666216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 666316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 666416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6665f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// Tests that listeners receive events in the order they were appended to 6666f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// the list, except for *End requests, which must be received in the reverse 6667f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// order. 666816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanclass SequenceTestingListener : public EmptyTestEventListener { 666916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 66700d27868d0faef474594682f25336229daa89d6d7zhanyong.wan SequenceTestingListener(std::vector<String>* vector, const char* id) 6671f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan : vector_(vector), id_(id) {} 667216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 667316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan protected: 6674f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 66750d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestProgramStart")); 6676f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 6677f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 6678f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) { 66790d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestProgramEnd")); 6680f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 6681f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 6682f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, 6683f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan int /*iteration*/) { 66840d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestIterationStart")); 6685f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 6686f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 6687f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, 6688f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan int /*iteration*/) { 66890d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestIterationEnd")); 669016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 669116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 669216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan private: 6693f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan String GetEventDescription(const char* method) { 6694f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan Message message; 6695f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan message << id_ << "." << method; 6696f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan return message.GetString(); 6697f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 6698f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 66990d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<String>* vector_; 6700f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan const char* const id_; 67019f894c2b36e83e9414b3369f9a4974644d843d8dzhanyong.wan 67029f894c2b36e83e9414b3369f9a4974644d843d8dzhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener); 670316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 670416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 670516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, AppendKeepsOrder) { 67060d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<String> vec; 6707f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6708f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "1st")); 6709f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "2nd")); 6710f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "3rd")); 6711f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 6712f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 6713f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance()); 67140d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 67150d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str()); 67160d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str()); 67170d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str()); 6718f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 67190d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 6720f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd( 672116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 67220d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 67230d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str()); 67240d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str()); 67250d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str()); 6726f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 67270d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 6728f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart( 6729f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance(), 0); 67300d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 67310d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str()); 67320d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str()); 67330d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str()); 6734f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 67350d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 6736f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd( 6737f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance(), 0); 67380d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 67390d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str()); 67400d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str()); 67410d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str()); 674216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 674316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6744f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that a listener removed from a TestEventListeners list stops receiving 674516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// events and is not deleted when the list is destroyed. 6746f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, Release) { 674716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 674816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 674916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 675016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 675116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 675216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 675316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 6754f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 675516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 675616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 6757f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 675816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 675916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.Release(listener) == NULL); 676016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 676116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 676216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 676316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 676416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 676516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 676616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that no events are forwarded when event forwarding is disabled. 676716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, SuppressEventForwarding) { 676816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 676916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, NULL); 677016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6771f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 677216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 6773f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 6774f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SuppressEventForwarding(&listeners); 6775f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 6776f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 677716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 677816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 677916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 678016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 678116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that events generated by Google Test are not forwarded in 678216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// death test subprocesses. 678316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) { 6784b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED({ 6785f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled( 678616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *GetUnitTestImpl()->listeners())) << "expected failure";}, 678716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan "expected failure"); 678816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 678916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 679016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that a listener installed via SetDefaultResultPrinter() starts 679116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events and is returned via default_result_printer() and that 679216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// the previous default_result_printer is removed from the list and deleted. 679316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, default_result_printer) { 679416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 679516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 679616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 679716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6798f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6799f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 680016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 680116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.default_result_printer()); 680216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6803f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 680416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 680516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 680616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 680716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 680816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Replacing default_result_printer with something else should remove it 680916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // from the list and destroy it. 6810f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL); 681116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 681216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 681316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 681416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 681516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // After broadcasting an event the counter is still the same, indicating 681616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the listener is not in the list anymore. 6817f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 681816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 681916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 682016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 682116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 682216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that the default_result_printer listener stops receiving events 682316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// when removed via Release and that is not owned by the list anymore. 682416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, RemovingDefaultResultPrinterWorks) { 682516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 682616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 682716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 682816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 682916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 683016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 683116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 6832f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6833f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 683416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 683516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 683616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 683716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 683816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 683916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Broadcasting events now should not affect default_result_printer. 6840f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 684116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 684216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 684316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 684416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Destroying the list should not affect the listener now, too. 684516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 684616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 684716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 684816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 684916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that a listener installed via SetDefaultXmlGenerator() starts 685016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events and is returned via default_xml_generator() and that 685116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// the previous default_xml_generator is removed from the list and deleted. 685216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, default_xml_generator) { 685316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 685416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 685516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 685616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6857f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6858f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 685916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 686016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.default_xml_generator()); 686116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 6862f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 686316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 686416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 686516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 686616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 686716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Replacing default_xml_generator with something else should remove it 686816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // from the list and destroy it. 6869f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL); 687016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 687116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 687216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 687316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 687416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // After broadcasting an event the counter is still the same, indicating 687516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the listener is not in the list anymore. 6876f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 687716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 687816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 687916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 688016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 688116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that the default_xml_generator listener stops receiving events 688216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// when removed via Release and that is not owned by the list anymore. 688316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) { 688416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 688516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 688616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 688716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 688816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 688916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 689016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 6891f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 6892f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 689316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 689416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 689516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 689616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 689716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 689816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Broadcasting events now should not affect default_xml_generator. 6899f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 690016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 690116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 690216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 690316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Destroying the list should not affect the listener now, too. 690416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 690516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 690616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 69071b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan 69081b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// Sanity tests to ensure that the alternative, verbose spellings of 69091b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// some of the macros work. We don't test them thoroughly as that 69101b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// would be quite involved. Since their implementations are 69111b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// straightforward, and they are rarely used, we'll just rely on the 69121b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// users to tell us when they are broken. 69131b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wanGTEST_TEST(AlternativeNameTest, Works) { // GTEST_TEST is the same as TEST. 69141b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan GTEST_SUCCEED() << "OK"; // GTEST_SUCCEED is the same as SUCCEED. 69151b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan 69161b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan // GTEST_FAIL is the same as FAIL. 69171b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure", 69181b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan "An expected failure"); 6919345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6920345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan // GTEST_ASSERT_XY is the same as ASSERT_XY. 6921345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6922345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_EQ(0, 0); 6923345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure", 6924345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6925345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure", 6926345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6927345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6928345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_NE(0, 1); 6929345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_NE(1, 0); 6930345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure", 6931345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6932345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6933345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LE(0, 0); 6934345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LE(0, 1); 6935345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure", 6936345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6937345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6938345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LT(0, 1); 6939345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure", 6940345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6941345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure", 6942345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6943345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6944345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GE(0, 0); 6945345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GE(1, 0); 6946345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure", 6947345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6948345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 6949345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GT(1, 0); 6950345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure", 6951345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 6952345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure", 6953345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 69541b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan} 69552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests for internal utilities necessary for implementation of the universal 69572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// printing. 69582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// TODO(vladl@google.com): Find a better home for them. 69592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass ConversionHelperBase {}; 69612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass ConversionHelperDerived : public ConversionHelperBase {}; 69622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is a compile-time constant. 69642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) { 69652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value, 69662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const_true); 69672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false); 69682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 69692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is true when T is 697135c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan// proto2::Message or a sub-class of it. 69722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) { 69732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value); 69742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value); 69752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 69762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is false when T is neither 69782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// ProtocolMessage nor a sub-class of it. 69792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) { 69802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(IsAProtocolMessage<int>::value); 69812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value); 69822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 69832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that CompileAssertTypesEqual compiles when the type arguments are 69852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// equal. 69862ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) { 69872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<void, void>(); 69882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int*, int*>(); 69892ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 69902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveReference does not affect non-reference types. 69922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) { 69932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveReference<int>::type>(); 69942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char, RemoveReference<const char>::type>(); 69952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 69962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 69972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveReference removes reference from reference types. 69982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, RemovesReference) { 69992ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveReference<int&>::type>(); 70002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>(); 70012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70022ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REMOVE_REFERENCE_. 70042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 70062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestRemoveReference() { 70072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>(); 70082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, MacroVersion) { 70112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveReference<int, int>(); 70122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveReference<const char, const char&>(); 70132ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveConst does not affect non-const types. 70172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, DoesNotAffectNonConstType) { 70182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveConst<int>::type>(); 70192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char&, RemoveConst<char&>::type>(); 70202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveConst removes const from const types. 70232ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, RemovesConst) { 70242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveConst<const int>::type>(); 70252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>(); 70262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>(); 70272ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70282ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REMOVE_CONST_. 70302ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70312ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 70322ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestRemoveConst() { 70332ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>(); 70342ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70352ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70362ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, MacroVersion) { 70372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<int, int>(); 70382ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<double&, double&>(); 70392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<char, const char>(); 70402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 704255d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan// Tests GTEST_REMOVE_REFERENCE_AND_CONST_. 704355d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 704455d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wantemplate <typename T1, typename T2> 704555d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wanvoid TestGTestRemoveReferenceAndConst() { 704655d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>(); 704755d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan} 704855d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 704955d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wanTEST(RemoveReferenceToConstTest, Works) { 705055d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<int, int>(); 705155d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<double, double&>(); 705255d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<char, const char>(); 705355d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<char, const char&>(); 705455d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<const char*, const char*>(); 705555d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan} 705655d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 70572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that AddReference does not affect reference types. 70582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, DoesNotAffectReferenceType) { 70592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int&, AddReference<int&>::type>(); 70602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char&, AddReference<const char&>::type>(); 70612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that AddReference adds reference to non-reference types. 70642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, AddsReference) { 70652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int&, AddReference<int>::type>(); 70662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char&, AddReference<const char>::type>(); 70672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_ADD_REFERENCE_. 70702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 70722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestAddReference() { 70732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>(); 70742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, MacroVersion) { 70772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestAddReference<int&, int>(); 70782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestAddReference<const char&, const char&>(); 70792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REFERENCE_TO_CONST_. 70822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 70842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestReferenceToConst() { 70852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>(); 70862ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(GTestReferenceToConstTest, Works) { 70892ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const char&, char>(); 70902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const int&, const int>(); 70912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const double&, double>(); 70922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const String&, const String&>(); 70932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 70942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 70952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant. 70962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) { 70972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true); 70982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value), 70992ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const_false); 71002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71022ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can 71032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// be implicitly converted to T2. 71042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) { 71052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int, double>::value)); 71062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<double, int>::value)); 71072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value)); 71082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value)); 71092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&, 71102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const ConversionHelperBase&>::value)); 71112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase, 71122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ConversionHelperBase>::value)); 71132ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1 71162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// cannot be implicitly converted to T2. 71172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) { 71182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value)); 71192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value)); 71202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value)); 71212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&, 71222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ConversionHelperDerived&>::value)); 71232ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests IsContainerTest. 71262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71272ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass NonContainer {}; 71282ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsContainerTestTest, WorksForNonContainer) { 71302ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0))); 71312ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0))); 71322ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0))); 71332ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71342ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71352ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsContainerTestTest, WorksForContainer) { 71362ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsContainer), 71372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan sizeof(IsContainerTest<std::vector<bool> >(0))); 71382ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsContainer), 71392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan sizeof(IsContainerTest<std::map<int, double> >(0))); 71402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests ArrayEq(). 71432ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForDegeneratedArrays) { 71452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(5, 5L)); 71462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq('a', 0)); 71472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForOneDimensionalArrays) { 71502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[] = { 0, 1 }; 71512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan long b[] = { 0, 1 }; 71522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 71532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, 2, b)); 71542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan b[0] = 2; 71562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, b)); 71572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, 1, b)); 71582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForTwoDimensionalArrays) { 71612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[][3] = { "hi", "lo" }; 71622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char b[][3] = { "hi", "lo" }; 71632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char c[][3] = { "hi", "li" }; 71642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 71662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, 2, b)); 71672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, c)); 71692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, 2, c)); 71702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests ArrayAwareFind(). 71732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayAwareFindTest, WorksForOneDimensionalArray) { 71752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[] = "hello"; 71762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o')); 71772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x')); 71782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) { 71812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } }; 71822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b[2] = { 2, 3 }; 71832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b)); 71842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int c[2] = { 6, 7 }; 71862ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c)); 71872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71892ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests CopyArray(). 71902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForDegeneratedArrays) { 71922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int n = 0; 71932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray('a', &n); 71942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ('a', n); 71952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 71962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 71972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForOneDimensionalArrays) { 71982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[3] = "hi"; 71992ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int b[3]; 72002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, &b); 72012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 72022ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int c[3]; 72042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, 3, c); 72052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, c)); 72062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForTwoDimensionalArrays) { 72092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; 72102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int b[2][3]; 72112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, &b); 72122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 72132ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int c[2][3]; 72152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, 2, c); 72162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, c)); 72172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests NativeArray. 72202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, ConstructorFromArrayWorks) { 72222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[3] = { 0, 1, 2 }; 72232ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int> na(a, 3, kReference); 72242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(3U, na.size()); 72252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a, na.begin()); 72262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72272ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72282ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) { 72292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan typedef int Array[2]; 72302ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan Array* a = new Array[1]; 72312ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan (*a)[0] = 0; 72322ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan (*a)[1] = 1; 72332ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int> na(*a, 2, kCopy); 72342ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_NE(*a, na.begin()); 72352ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan delete[] a; 72362ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(0, na.begin()[0]); 72372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(1, na.begin()[1]); 72382ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan // We rely on the heap checker to verify that na deletes the copy of 72402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan // array. 72412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72432ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, TypeMembersAreCorrect) { 72442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<char, NativeArray<char>::value_type>(); 72452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>(); 72462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>(); 72482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>(); 72492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, MethodsWork) { 72522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[3] = { 0, 1, 2 }; 72532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int> na(a, 3, kCopy); 72542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ASSERT_EQ(3U, na.size()); 72552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(3, na.end() - na.begin()); 72562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int>::const_iterator it = na.begin(); 72582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(0, *it); 72592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ++it; 72602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(1, *it); 72612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan it++; 72622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(2, *it); 72632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ++it; 72642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(na.end(), it); 72652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(na == na); 72672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int> na2(a, 3, kReference); 72692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(na == na2); 72702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b1[3] = { 0, 1, 1 }; 72722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b2[4] = { 0, 1, 2, 3 }; 72732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(na == NativeArray<int>(b1, 3, kReference)); 72742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(na == NativeArray<int>(b2, 4, kCopy)); 72752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 72762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 72772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, WorksForTwoDimensionalArray) { 72782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[2][3] = { "hi", "lo" }; 72792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<char[3]> na(a, 2, kReference); 72802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ASSERT_EQ(2U, na.size()); 72812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a, na.begin()); 72822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 7283985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7284985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan// Tests SkipPrefix(). 7285985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7286985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanTEST(SkipPrefixTest, SkipsWhenPrefixMatches) { 7287985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* const str = "hello"; 7288985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7289985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* p = str; 7290985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_TRUE(SkipPrefix("", &p)); 7291985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7292985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7293985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan p = str; 7294985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_TRUE(SkipPrefix("hell", &p)); 7295985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str + 4, p); 7296985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan} 7297985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7298985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanTEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) { 7299985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* const str = "world"; 7300985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7301985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* p = str; 7302985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_FALSE(SkipPrefix("W", &p)); 7303985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7304985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7305985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan p = str; 7306985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_FALSE(SkipPrefix("world!", &p)); 7307985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7308985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan} 7309