gtest_unittest.cc revision 4853a503371f39aa22e14adcdecea71c09841e34
1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc. 2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved. 3d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without 5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are 6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met: 7d201456903f3ecae1f7794edfab0d5678e64226shiqian// 8d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions of source code must retain the above copyright 9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer. 10d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions in binary form must reproduce the above 11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer 12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the 13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution. 14d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Neither the name of Google Inc. nor the names of its 15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from 16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission. 17d201456903f3ecae1f7794edfab0d5678e64226shiqian// 18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29d201456903f3ecae1f7794edfab0d5678e64226shiqian// 30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Author: wan@google.com (Zhanyong Wan) 31d201456903f3ecae1f7794edfab0d5678e64226shiqian// 32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for Google Test itself. This verifies that the basic constructs of 33d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test work. 34d201456903f3ecae1f7794edfab0d5678e64226shiqian 35d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <gtest/gtest.h> 36ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 37ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Verifies that the command line flag variables can be accessed 38ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// in code once <gtest/gtest.h> has been #included. 39ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Do not move it after other #includes. 40ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wanTEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { 41ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) 42ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(break_on_failure) 43ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(catch_exceptions) 44ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(color) != "unknown" 45ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(filter) != "unknown" 46ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(list_tests) 47ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(output) != "unknown" 48ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(print_time) 49ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(repeat) > 0 50ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(show_internal_stack_frames) 5140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(stack_trace_depth) > 0 5240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(throw_on_failure); 53ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. 54ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan} 55ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 56d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <gtest/gtest-spi.h> 57d201456903f3ecae1f7794edfab0d5678e64226shiqian 58d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 59d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 60d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 61d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 62d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 630af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_IMPLEMENTATION_ 1 64d201456903f3ecae1f7794edfab0d5678e64226shiqian#include "src/gtest-internal-inl.h" 650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#undef GTEST_IMPLEMENTATION_ 66d201456903f3ecae1f7794edfab0d5678e64226shiqian 67ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan#include <limits.h> // For INT_MAX. 68d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 69c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <time.h> 70d201456903f3ecae1f7794edfab0d5678e64226shiqian 71e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_HAS_PTHREAD 72e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#include <pthread.h> 73e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_HAS_PTHREAD 74e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 75c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 76c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#include <map> 77c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 78c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 79d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 80d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 8164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianconst char* FormatTimeInMillisAsSeconds(TimeInMillis ms); 82d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32Flag(const char* str, const char* flag, Int32* value); 83d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 84d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 85d201456903f3ecae1f7794edfab0d5678e64226shiqian 8664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianusing testing::internal::FormatTimeInMillisAsSeconds; 87d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ParseInt32Flag; 88d201456903f3ecae1f7794edfab0d5678e64226shiqian 89d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 90d201456903f3ecae1f7794edfab0d5678e64226shiqian 91e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianGTEST_DECLARE_string_(output); 92e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianGTEST_DECLARE_string_(color); 93d201456903f3ecae1f7794edfab0d5678e64226shiqian 94d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 95d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ShouldUseColor(bool stdout_is_tty); 96d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 97d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 98d201456903f3ecae1f7794edfab0d5678e64226shiqian 999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionFailure; 1009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionResult; 1019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionSuccess; 1029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::DoubleLE; 1039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::FloatLE; 104fe186c382905dcf57014985ccea8e067275e9f5fshiqianusing testing::GTEST_FLAG(also_run_disabled_tests); 1059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(break_on_failure); 1069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(catch_exceptions); 10753e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::GTEST_FLAG(death_test_use_fork); 108d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::GTEST_FLAG(color); 1099b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(filter); 1109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(list_tests); 1119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(output); 1129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(print_time); 1139b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(repeat); 1149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(show_internal_stack_frames); 1159b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(stack_trace_depth); 11640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanusing testing::GTEST_FLAG(throw_on_failure); 1179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsNotSubstring; 1189b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsSubstring; 1199b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Message; 120d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::ScopedFakeTestPartResultReporter; 12153e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::StaticAssertTypeEq; 1229b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Test; 123d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResult; 124d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResultArray; 1259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_FATAL_FAILURE; 1269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_NONFATAL_FAILURE; 1279b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_SUCCESS; 128d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::UnitTest; 129c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::kTestTypeIdInGoogleTest; 130d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::AppendUserMessage; 131c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanusing testing::internal::ClearCurrentTestPartResults; 1320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::CodePointToUtf8; 133d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::EqFailure; 1349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::FloatingPoint; 1353d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetCurrentOsStackTraceExceptTop; 1363d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetFailedPartCount; 137c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTestTypeId; 138c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTypeId; 1399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::GTestFlagSaver; 140d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::Int32; 141cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::Int32FromEnvOrDie; 142d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::List; 143cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldRunTestOnShard; 144cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldShard; 145d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ShouldUseColor; 146d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::StreamableToString; 147d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::String; 148d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestProperty; 149d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestResult; 150e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianusing testing::internal::ThreadLocal; 151d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::UnitTestImpl; 1520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::WideStringToUtf8; 153d201456903f3ecae1f7794edfab0d5678e64226shiqian 154d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in an unnamed namespace. 155d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 156d201456903f3ecae1f7794edfab0d5678e64226shiqian 157c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Tests GetTypeId. 158c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 159c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsSameValueForSameType) { 160c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>()); 161c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>()); 162c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 163c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 164c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass SubClassOfTest : public Test {}; 165c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass AnotherSubClassOfTest : public Test {}; 166c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 167c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) { 168c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>()); 169c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<char>()); 170c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTestTypeId()); 171c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId()); 172c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId()); 173c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>()); 174c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 175c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 176c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Verifies that GetTestTypeId() returns the same value, no matter it 177c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// is called from inside Google Test or outside of it. 178c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) { 179c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId()); 180c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 181c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 18264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Tests FormatTimeInMillisAsSeconds(). 18364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 18464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsZero) { 18564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0", FormatTimeInMillisAsSeconds(0)); 18664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 18764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 18864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) { 18964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.003", FormatTimeInMillisAsSeconds(3)); 19064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.01", FormatTimeInMillisAsSeconds(10)); 19164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("0.2", FormatTimeInMillisAsSeconds(200)); 19264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("1.2", FormatTimeInMillisAsSeconds(1200)); 19364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("3", FormatTimeInMillisAsSeconds(3000)); 19464cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 19564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 19664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) { 19764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.003", FormatTimeInMillisAsSeconds(-3)); 19864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.01", FormatTimeInMillisAsSeconds(-10)); 19964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-0.2", FormatTimeInMillisAsSeconds(-200)); 20064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-1.2", FormatTimeInMillisAsSeconds(-1200)); 20164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian EXPECT_STREQ("-3", FormatTimeInMillisAsSeconds(-3000)); 20264cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 20364cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 2040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 205d201456903f3ecae1f7794edfab0d5678e64226shiqian// NULL testing does not work with Symbian compilers. 206d201456903f3ecae1f7794edfab0d5678e64226shiqian 207c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 208c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 209c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 210c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 211c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 212e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null 213d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 214d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsTrueForNullLiterals) { 215e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL)); 216e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0)); 217e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U)); 218e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L)); 219e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(false)); 220c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 221c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Some compilers may fail to detect some null pointer literals; 222c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // as long as users of the framework don't use such literals, this 223c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // is harmless. 224c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1)); 225e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(true && false)); 226c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 227d201456903f3ecae1f7794edfab0d5678e64226shiqian} 228d201456903f3ecae1f7794edfab0d5678e64226shiqian 229e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null 230d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 231d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 232e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1)); 233e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0)); 234e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a')); 235e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL))); 236d201456903f3ecae1f7794edfab0d5678e64226shiqian} 237d201456903f3ecae1f7794edfab0d5678e64226shiqian 238c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 239c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 240c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 241c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 242c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2430af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 2450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests CodePointToUtf8(). 246d201456903f3ecae1f7794edfab0d5678e64226shiqian 247d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the NUL character L'\0' is encoded correctly. 2480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeNul) { 2490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 2500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer)); 251d201456903f3ecae1f7794edfab0d5678e64226shiqian} 252d201456903f3ecae1f7794edfab0d5678e64226shiqian 253d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASCII characters are encoded correctly. 2540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeAscii) { 2550c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 2560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer)); 2570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer)); 2580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer)); 2590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer)); 260d201456903f3ecae1f7794edfab0d5678e64226shiqian} 261d201456903f3ecae1f7794edfab0d5678e64226shiqian 262d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 8 to 11 bits are encoded 263d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 110xxxxx 10xxxxxx. 2640c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 2650c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 266d201456903f3ecae1f7794edfab0d5678e64226shiqian // 000 1101 0011 => 110-00011 10-010011 2670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer)); 268d201456903f3ecae1f7794edfab0d5678e64226shiqian 269d201456903f3ecae1f7794edfab0d5678e64226shiqian // 101 0111 0110 => 110-10101 10-110110 2700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", CodePointToUtf8(L'\x576', buffer)); 271d201456903f3ecae1f7794edfab0d5678e64226shiqian} 272d201456903f3ecae1f7794edfab0d5678e64226shiqian 273d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 12 to 16 bits are encoded 274d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 1110xxxx 10xxxxxx 10xxxxxx. 2750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 2760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 277d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 2780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", CodePointToUtf8(L'\x8D3', buffer)); 279d201456903f3ecae1f7794edfab0d5678e64226shiqian 280d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 2810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer)); 282d201456903f3ecae1f7794edfab0d5678e64226shiqian} 283d201456903f3ecae1f7794edfab0d5678e64226shiqian 2840af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 285d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests in this group require a wchar_t to hold > 16 bits, and thus 286e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 2870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 16-bit wide. This code may not compile on those systems. 288d201456903f3ecae1f7794edfab0d5678e64226shiqian 289d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 17 to 21 bits are encoded 290d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 2910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 2920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 293d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 2940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer)); 2950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 2970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer)); 298d201456903f3ecae1f7794edfab0d5678e64226shiqian 2990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 3000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer)); 301d201456903f3ecae1f7794edfab0d5678e64226shiqian} 302d201456903f3ecae1f7794edfab0d5678e64226shiqian 303d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that encoding an invalid code-point generates the expected result. 3040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 3050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)", 3070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev CodePointToUtf8(L'\x1234ABCD', buffer)); 3080c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 3110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests WideStringToUtf8(). 3130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the NUL character L'\0' is encoded correctly. 3150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeNul) { 3160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 3170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 3180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that ASCII strings are encoded correctly. 3210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeAscii) { 3220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 3230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 3240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 3250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 3260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 8 to 11 bits are encoded 3290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 110xxxxx 10xxxxxx. 3300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 3310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 000 1101 0011 => 110-00011 10-010011 3320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 3330c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 3340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 101 0111 0110 => 110-10101 10-110110 3360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", 1).c_str()); 3370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", -1).c_str()); 3380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 12 to 16 bits are encoded 3410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 1110xxxx 10xxxxxx 10xxxxxx. 3420c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 3430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 3440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", 1).c_str()); 3450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", -1).c_str()); 3460c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 3480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", 1).c_str()); 3490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", -1).c_str()); 350d201456903f3ecae1f7794edfab0d5678e64226shiqian} 351d201456903f3ecae1f7794edfab0d5678e64226shiqian 3520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function encounters \0 character. 3530c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 3540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 3550c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function reaches the limit 3580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// specified by the 'length' parameter. 3590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 3600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 3610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3620c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3640af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 3650c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 17 to 21 bits are encoded 3660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 3670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// on the systems using UTF-16 encoding. 3680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 3690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 3700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 3710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 3720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 3740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 3750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 3760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid code-point generates the expected result. 3790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 3800c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 3810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xABCDFF", -1).c_str()); 3820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#else // !GTEST_WIDE_STRING_USES_UTF16_ 3840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that surrogate pairs are encoded correctly on the systems using 3850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// UTF-16 encoding in the wide strings. 3860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 3870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", 3880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xD801\xDC00", -1).c_str()); 3890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid UTF-16 surrogate pair 3920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// generates the expected result. 3930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 3940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is at the end of the string. 3950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(L"\xD800", -1).c_str()); 3960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is not followed by the trailing surrogate. 3970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80$", WideStringToUtf8(L"\xD800$", -1).c_str()); 3980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Trailing surrogate appearas without a leading surrogate. 3990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str()); 4000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4010af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 4020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 4030c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that codepoint concatenation works correctly. 4040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 4050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 4060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 4070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4" 4080c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" 4090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\n" 4100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xD5\xB6" 4110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xE0\xA3\x93" 4120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4", 4130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\x108634\xC74D\n\x576\x8D3\x108634", -1).c_str()); 4140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 4160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 4170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 4180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 4190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str()); 4200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 4210af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 422d201456903f3ecae1f7794edfab0d5678e64226shiqian 423d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the List template class. 424d201456903f3ecae1f7794edfab0d5678e64226shiqian 425d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests List::PushFront(). 426d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, PushFront) { 427d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 428d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, a.size()); 429d201456903f3ecae1f7794edfab0d5678e64226shiqian 430d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on an empty list. 431d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(1); 432d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, a.size()); 433d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 434d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(a.Head(), a.Last()); 435d201456903f3ecae1f7794edfab0d5678e64226shiqian 436d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on a singleton list. 437d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 438d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 439d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->element()); 440d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 441d201456903f3ecae1f7794edfab0d5678e64226shiqian 442d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on a list with more than one elements. 443d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 444d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 445d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Head()->element()); 446d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 447d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 448d201456903f3ecae1f7794edfab0d5678e64226shiqian} 449d201456903f3ecae1f7794edfab0d5678e64226shiqian 450d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests List::PopFront(). 451d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, PopFront) { 452d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 453d201456903f3ecae1f7794edfab0d5678e64226shiqian 454d201456903f3ecae1f7794edfab0d5678e64226shiqian // Popping on an empty list should fail. 455d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(NULL)); 456d201456903f3ecae1f7794edfab0d5678e64226shiqian 457d201456903f3ecae1f7794edfab0d5678e64226shiqian // Popping again on an empty list should fail, and the result element 458d201456903f3ecae1f7794edfab0d5678e64226shiqian // shouldn't be overwritten. 459d201456903f3ecae1f7794edfab0d5678e64226shiqian int element = 1; 460d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(&element)); 461d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, element); 462d201456903f3ecae1f7794edfab0d5678e64226shiqian 463d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 464d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 465d201456903f3ecae1f7794edfab0d5678e64226shiqian 466d201456903f3ecae1f7794edfab0d5678e64226shiqian // PopFront() should pop the element in the front of the list. 467d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(&element)); 468d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, element); 469d201456903f3ecae1f7794edfab0d5678e64226shiqian 470d201456903f3ecae1f7794edfab0d5678e64226shiqian // After popping the last element, the list should be empty. 471d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(NULL)); 472d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, a.size()); 473d201456903f3ecae1f7794edfab0d5678e64226shiqian} 474d201456903f3ecae1f7794edfab0d5678e64226shiqian 475d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests inserting at the beginning using List::InsertAfter(). 476d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, InsertAfterAtBeginning) { 477d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 478d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, a.size()); 479d201456903f3ecae1f7794edfab0d5678e64226shiqian 480d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts into an empty list. 481d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 1); 482d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, a.size()); 483d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 484d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(a.Head(), a.Last()); 485d201456903f3ecae1f7794edfab0d5678e64226shiqian 486d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the beginning of a singleton list. 487d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 2); 488d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 489d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->element()); 490d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 491d201456903f3ecae1f7794edfab0d5678e64226shiqian 492d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the beginning of a list with more than one elements. 493d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 3); 494d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 495d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Head()->element()); 496d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 497d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 498d201456903f3ecae1f7794edfab0d5678e64226shiqian} 499d201456903f3ecae1f7794edfab0d5678e64226shiqian 500d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests inserting at a location other than the beginning using 501d201456903f3ecae1f7794edfab0d5678e64226shiqian// List::InsertAfter(). 502d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, InsertAfterNotAtBeginning) { 503d201456903f3ecae1f7794edfab0d5678e64226shiqian // Prepares a singleton list. 504d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 505d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushBack(1); 506d201456903f3ecae1f7794edfab0d5678e64226shiqian 507d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the end of a singleton list. 508d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Last(), 2); 509d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 510d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 511d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Last()->element()); 512d201456903f3ecae1f7794edfab0d5678e64226shiqian 513d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the end of a list with more than one elements. 514d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Last(), 3); 515d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 516d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 517d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 518d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Last()->element()); 519d201456903f3ecae1f7794edfab0d5678e64226shiqian 520d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts in the middle of a list. 521d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Head(), 4); 522d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(4u, a.size()); 523d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 524d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a.Head()->next()->element()); 525d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->next()->element()); 526d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Last()->element()); 527d201456903f3ecae1f7794edfab0d5678e64226shiqian} 528d201456903f3ecae1f7794edfab0d5678e64226shiqian 529d201456903f3ecae1f7794edfab0d5678e64226shiqian 530d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the String class. 531d201456903f3ecae1f7794edfab0d5678e64226shiqian 532d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String's constructors. 533d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Constructors) { 534d201456903f3ecae1f7794edfab0d5678e64226shiqian // Default ctor. 535d201456903f3ecae1f7794edfab0d5678e64226shiqian String s1; 536bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing 537bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // pointers with NULL isn't supported on all platforms. 538bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(NULL == s1.c_str()); 539d201456903f3ecae1f7794edfab0d5678e64226shiqian 540d201456903f3ecae1f7794edfab0d5678e64226shiqian // Implicitly constructs from a C-string. 541d201456903f3ecae1f7794edfab0d5678e64226shiqian String s2 = "Hi"; 542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Hi", s2.c_str()); 543d201456903f3ecae1f7794edfab0d5678e64226shiqian 544d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs from a C-string and a length. 545d201456903f3ecae1f7794edfab0d5678e64226shiqian String s3("hello", 3); 546d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s3.c_str()); 547d201456903f3ecae1f7794edfab0d5678e64226shiqian 548d201456903f3ecae1f7794edfab0d5678e64226shiqian // Copy ctor. 549d201456903f3ecae1f7794edfab0d5678e64226shiqian String s4 = s3; 550d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s4.c_str()); 551d201456903f3ecae1f7794edfab0d5678e64226shiqian} 552d201456903f3ecae1f7794edfab0d5678e64226shiqian 5531998cf5d32a19aaffe8652545802744d9133022dvladlosev#if GTEST_HAS_STD_STRING 5541998cf5d32a19aaffe8652545802744d9133022dvladlosev 5551998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromStdString) { 5561998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty std::string. 5571998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src1(""); 5581998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 5591998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 5601998cf5d32a19aaffe8652545802744d9133022dvladlosev 5611998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal std::string. 5621998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string src2("Hi"); 5631998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 5641998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 5651998cf5d32a19aaffe8652545802744d9133022dvladlosev 5661998cf5d32a19aaffe8652545802744d9133022dvladlosev // An std::string with an embedded NUL character. 5671998cf5d32a19aaffe8652545802744d9133022dvladlosev const char src3[] = "Hello\0world."; 5681998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = std::string(src3, sizeof(src3)); 5691998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hello", dest3.c_str()); 5701998cf5d32a19aaffe8652545802744d9133022dvladlosev} 5711998cf5d32a19aaffe8652545802744d9133022dvladlosev 5721998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToStdString) { 5731998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 5741998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 5751998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest1 = src1; 5761998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 5771998cf5d32a19aaffe8652545802744d9133022dvladlosev 5781998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 5791998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 5801998cf5d32a19aaffe8652545802744d9133022dvladlosev const std::string dest2 = src2; 5811998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 5821998cf5d32a19aaffe8652545802744d9133022dvladlosev} 5831998cf5d32a19aaffe8652545802744d9133022dvladlosev 5841998cf5d32a19aaffe8652545802744d9133022dvladlosev#endif // GTEST_HAS_STD_STRING 5851998cf5d32a19aaffe8652545802744d9133022dvladlosev 5861998cf5d32a19aaffe8652545802744d9133022dvladlosev#if GTEST_HAS_GLOBAL_STRING 5871998cf5d32a19aaffe8652545802744d9133022dvladlosev 5881998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsFromGlobalString) { 5891998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty ::string. 5901998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src1(""); 5911998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest1 = src1; 5921998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("", dest1.c_str()); 5931998cf5d32a19aaffe8652545802744d9133022dvladlosev 5941998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal ::string. 5951998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string src2("Hi"); 5961998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest2 = src2; 5971998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hi", dest2.c_str()); 5981998cf5d32a19aaffe8652545802744d9133022dvladlosev 5991998cf5d32a19aaffe8652545802744d9133022dvladlosev // An ::string with an embedded NUL character. 6001998cf5d32a19aaffe8652545802744d9133022dvladlosev const char src3[] = "Hello\0world."; 6011998cf5d32a19aaffe8652545802744d9133022dvladlosev const String dest3 = ::string(src3, sizeof(src3)); 6021998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_STREQ("Hello", dest3.c_str()); 6031998cf5d32a19aaffe8652545802744d9133022dvladlosev} 6041998cf5d32a19aaffe8652545802744d9133022dvladlosev 6051998cf5d32a19aaffe8652545802744d9133022dvladlosevTEST(StringTest, ConvertsToGlobalString) { 6061998cf5d32a19aaffe8652545802744d9133022dvladlosev // An empty String. 6071998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src1(""); 6081998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest1 = src1; 6091998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("", dest1); 6101998cf5d32a19aaffe8652545802744d9133022dvladlosev 6111998cf5d32a19aaffe8652545802744d9133022dvladlosev // A normal String. 6121998cf5d32a19aaffe8652545802744d9133022dvladlosev const String src2("Hi"); 6131998cf5d32a19aaffe8652545802744d9133022dvladlosev const ::string dest2 = src2; 6141998cf5d32a19aaffe8652545802744d9133022dvladlosev EXPECT_EQ("Hi", dest2); 6151998cf5d32a19aaffe8652545802744d9133022dvladlosev} 6161998cf5d32a19aaffe8652545802744d9133022dvladlosev 6171998cf5d32a19aaffe8652545802744d9133022dvladlosev#endif // GTEST_HAS_GLOBAL_STRING 6181998cf5d32a19aaffe8652545802744d9133022dvladlosev 619d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCString(). 620d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCString) { 621d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", String::ShowCString(NULL)); 622d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowCString("")); 623d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowCString("foo")); 624d201456903f3ecae1f7794edfab0d5678e64226shiqian} 625d201456903f3ecae1f7794edfab0d5678e64226shiqian 626d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCStringQuoted(). 627d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCStringQuoted) { 628d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 629d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted(NULL).c_str()); 630d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"\"", 631d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("").c_str()); 632d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"foo\"", 633d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("foo").c_str()); 634d201456903f3ecae1f7794edfab0d5678e64226shiqian} 635d201456903f3ecae1f7794edfab0d5678e64226shiqian 636d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator==(). 637d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Equals) { 638d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 639d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null == NULL); // NOLINT 640d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == ""); // NOLINT 641d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == "bar"); // NOLINT 642d201456903f3ecae1f7794edfab0d5678e64226shiqian 643d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 644d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == NULL); // NOLINT 645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty == ""); // NOLINT 646d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == "bar"); // NOLINT 647d201456903f3ecae1f7794edfab0d5678e64226shiqian 648d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 649d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == NULL); // NOLINT 650d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == ""); // NOLINT 651d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == "bar"); // NOLINT 652d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo == "foo"); // NOLINT 653d201456903f3ecae1f7794edfab0d5678e64226shiqian} 654d201456903f3ecae1f7794edfab0d5678e64226shiqian 655d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator!=(). 656d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, NotEquals) { 657d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 658d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null != NULL); // NOLINT 659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != ""); // NOLINT 660d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != "bar"); // NOLINT 661d201456903f3ecae1f7794edfab0d5678e64226shiqian 662d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != NULL); // NOLINT 664d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty != ""); // NOLINT 665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != "bar"); // NOLINT 666d201456903f3ecae1f7794edfab0d5678e64226shiqian 667d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 668d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != NULL); // NOLINT 669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != ""); // NOLINT 670d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != "bar"); // NOLINT 671d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo != "foo"); // NOLINT 672d201456903f3ecae1f7794edfab0d5678e64226shiqian} 673d201456903f3ecae1f7794edfab0d5678e64226shiqian 674d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWith(). 675d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWith) { 676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("bar")); 677d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("")); 678d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWith("")); 679d201456903f3ecae1f7794edfab0d5678e64226shiqian 680d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWith("foo")); 681d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWith("foo")); 682d201456903f3ecae1f7794edfab0d5678e64226shiqian} 683d201456903f3ecae1f7794edfab0d5678e64226shiqian 684d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWithCaseInsensitive(). 685d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWithCaseInsensitive) { 686d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR")); 687d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar")); 688d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("")); 689d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWithCaseInsensitive("")); 690d201456903f3ecae1f7794edfab0d5678e64226shiqian 691d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo")); 692d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo")); 693d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo")); 694d201456903f3ecae1f7794edfab0d5678e64226shiqian} 695d201456903f3ecae1f7794edfab0d5678e64226shiqian 696c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// C++Builder's preprocessor is buggy; it fails to expand macros that 697c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// appear in macro parameters after wide char literals. Provide an alias 698c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// for NULL as a workaround. 699c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic const wchar_t* const kNull = NULL; 700c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 701a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests String::CaseInsensitiveWideCStringEquals 702a2b1a8556ea64014606d78b09333d9c522430a25shiqianTEST(StringTest, CaseInsensitiveWideCStringEquals) { 703a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 704c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"")); 705c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull)); 706c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar")); 707c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull)); 708a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 709a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 710a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 711a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 712a2b1a8556ea64014606d78b09333d9c522430a25shiqian 713d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that NULL can be assigned to a String. 714d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNULL) { 715d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(NULL); 716d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 717d201456903f3ecae1f7794edfab0d5678e64226shiqian 718d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 719d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(NULL, dest.c_str()); 720d201456903f3ecae1f7794edfab0d5678e64226shiqian} 721d201456903f3ecae1f7794edfab0d5678e64226shiqian 722d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the empty string "" can be assigned to a String. 723d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedEmpty) { 724d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(""); 725d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 726d201456903f3ecae1f7794edfab0d5678e64226shiqian 727d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 728d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", dest.c_str()); 729d201456903f3ecae1f7794edfab0d5678e64226shiqian} 730d201456903f3ecae1f7794edfab0d5678e64226shiqian 731d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a non-empty string can be assigned to a String. 732d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNonEmpty) { 733d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src("hello"); 734d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 735d201456903f3ecae1f7794edfab0d5678e64226shiqian 736d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 737d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 738d201456903f3ecae1f7794edfab0d5678e64226shiqian} 739d201456903f3ecae1f7794edfab0d5678e64226shiqian 740d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a String can be assigned to itself. 741d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedSelf) { 742d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest("hello"); 743d201456903f3ecae1f7794edfab0d5678e64226shiqian 744d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = dest; 745d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 746d201456903f3ecae1f7794edfab0d5678e64226shiqian} 747d201456903f3ecae1f7794edfab0d5678e64226shiqian 7480af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 749d201456903f3ecae1f7794edfab0d5678e64226shiqian 750d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCString(). 751d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCString) { 752d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 753d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCString(NULL).c_str()); 754d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 755d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 756d201456903f3ecae1f7794edfab0d5678e64226shiqian} 757d201456903f3ecae1f7794edfab0d5678e64226shiqian 758d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCStringQuoted(). 759d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCStringQuoted) { 760d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 761d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(NULL).c_str()); 762d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"\"", 763d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"").c_str()); 764d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"foo\"", 765d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"foo").c_str()); 766d201456903f3ecae1f7794edfab0d5678e64226shiqian} 767d201456903f3ecae1f7794edfab0d5678e64226shiqian 768bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#ifdef _WIN32_WCE 769bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16Null) { 770bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 771bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 772bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 773bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 774bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertBasic) { 775bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L"str"); 776bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ("str", ansi); 777bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 778bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16("str"); 779ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L"str", utf16, 3)); 780bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 781bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 782bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 783bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 784bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 785bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ(".:\\ \"*?", ansi); 786bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 787bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 788ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3)); 789bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 790bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 791bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#endif // _WIN32_WCE 792bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 793d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 794d201456903f3ecae1f7794edfab0d5678e64226shiqian 795d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty construction. 796d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, StringValue) { 797d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 798d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key", property.key()); 799d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 800d201456903f3ecae1f7794edfab0d5678e64226shiqian} 801d201456903f3ecae1f7794edfab0d5678e64226shiqian 802d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty replacing a value. 803d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, ReplaceStringValue) { 804d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 805d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 806d201456903f3ecae1f7794edfab0d5678e64226shiqian property.SetValue("2"); 807d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", property.value()); 808d201456903f3ecae1f7794edfab0d5678e64226shiqian} 809d201456903f3ecae1f7794edfab0d5678e64226shiqian 810c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// AddFatalFailure() and AddNonfatalFailure() must be stand-alone 811c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// functions (i.e. their definitions cannot be inlined at the call 812c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// sites), or C++Builder won't compile the code. 813c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddFatalFailure() { 814c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FAIL() << "Expected fatal failure."; 815c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 816c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 817c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddNonfatalFailure() { 818c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ADD_FAILURE() << "Expected non-fatal failure."; 819c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 820c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 821e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterTest : public Test { 8228de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 823e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian enum FailureMode { 824e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FATAL_FAILURE, 825e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NONFATAL_FAILURE 826e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }; 827e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailure(FailureMode failure) { 828e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (failure == FATAL_FAILURE) { 829c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 830e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } else { 831c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 832e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 833e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 834d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 835d201456903f3ecae1f7794edfab0d5678e64226shiqian 836e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that ScopedFakeTestPartResultReporter intercepts test 837e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// failures. 838e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 839e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 840e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 841e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 842e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 843e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &results); 844e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 845e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 846e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 847d201456903f3ecae1f7794edfab0d5678e64226shiqian 848e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(2, results.size()); 849e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 850e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 851d201456903f3ecae1f7794edfab0d5678e64226shiqian} 852d201456903f3ecae1f7794edfab0d5678e64226shiqian 853e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) { 854e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 855e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 856e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Tests, that the deprecated constructor still works. 857e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter(&results); 858e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 859e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 860e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(1, results.size()); 861d201456903f3ecae1f7794edfab0d5678e64226shiqian} 862d201456903f3ecae1f7794edfab0d5678e64226shiqian 863e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 864e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 865e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterWithThreadsTest 866e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian : public ScopedFakeTestPartResultReporterTest { 867e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 868e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailureInOtherThread(FailureMode failure) { 869e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_t tid; 870e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_create(&tid, 871e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NULL, 872e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporterWithThreadsTest:: 873e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FailureThread, 874e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &failure); 875e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian pthread_join(tid, NULL); 876e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 877e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian private: 878e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void* FailureThread(void* attr) { 879e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FailureMode* failure = static_cast<FailureMode*>(attr); 880e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(*failure); 881e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian return NULL; 882e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 883e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 884e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 885e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterWithThreadsTest, 886e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian InterceptsTestFailuresInAllThreads) { 887e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 888e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 889e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 890e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results); 891e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 892e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 893e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE); 894e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(FATAL_FAILURE); 895e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 896e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 897e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(4, results.size()); 898e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 899e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 900e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed()); 901e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed()); 902d201456903f3ecae1f7794edfab0d5678e64226shiqian} 903d201456903f3ecae1f7794edfab0d5678e64226shiqian 904e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 905e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 906c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they 907c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// work even if the failure is generated in a called function rather than 908c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// the current context. 909e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 91037504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest; 911e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 91237504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) { 913c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure."); 914d201456903f3ecae1f7794edfab0d5678e64226shiqian} 915d201456903f3ecae1f7794edfab0d5678e64226shiqian 91637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) { 91737504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches fatal 91837504994338c114247519331237831f88a9a7c40zhanyong.wan // failures generated on another thread. 919c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(), 920e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 921d201456903f3ecae1f7794edfab0d5678e64226shiqian} 922d201456903f3ecae1f7794edfab0d5678e64226shiqian 923c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 924c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true" 925c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc 926c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 927c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 92837504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void 92937504994338c114247519331237831f88a9a7c40zhanyong.wan// function even when the statement in it contains ASSERT_*. 93037504994338c114247519331237831f88a9a7c40zhanyong.wan 93137504994338c114247519331237831f88a9a7c40zhanyong.wanint NonVoidFunction() { 93237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 93337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 93437504994338c114247519331237831f88a9a7c40zhanyong.wan return 0; 93537504994338c114247519331237831f88a9a7c40zhanyong.wan} 93637504994338c114247519331237831f88a9a7c40zhanyong.wan 93737504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) { 93837504994338c114247519331237831f88a9a7c40zhanyong.wan NonVoidFunction(); 93937504994338c114247519331237831f88a9a7c40zhanyong.wan} 94037504994338c114247519331237831f88a9a7c40zhanyong.wan 94137504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the 94237504994338c114247519331237831f88a9a7c40zhanyong.wan// current function even though 'statement' generates a fatal failure. 94337504994338c114247519331237831f88a9a7c40zhanyong.wan 94437504994338c114247519331237831f88a9a7c40zhanyong.wanvoid DoesNotAbortHelper(bool* aborted) { 94537504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 94637504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 94737504994338c114247519331237831f88a9a7c40zhanyong.wan 94837504994338c114247519331237831f88a9a7c40zhanyong.wan *aborted = false; 94937504994338c114247519331237831f88a9a7c40zhanyong.wan} 95037504994338c114247519331237831f88a9a7c40zhanyong.wan 951c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 952c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 953c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 954c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 955c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 95637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, DoesNotAbort) { 95737504994338c114247519331237831f88a9a7c40zhanyong.wan bool aborted = true; 95837504994338c114247519331237831f88a9a7c40zhanyong.wan DoesNotAbortHelper(&aborted); 95937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FALSE(aborted); 960d201456903f3ecae1f7794edfab0d5678e64226shiqian} 961d201456903f3ecae1f7794edfab0d5678e64226shiqian 96237504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a 96337504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 96437504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 965d201456903f3ecae1f7794edfab0d5678e64226shiqian 966e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianstatic int global_var = 0; 967e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++ 968d201456903f3ecae1f7794edfab0d5678e64226shiqian 96937504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 970c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 971c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007. 972e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE({ 973e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 974c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 975e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 976c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 977d201456903f3ecae1f7794edfab0d5678e64226shiqian 978e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS({ 979e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 980c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 981e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 98237504994338c114247519331237831f88a9a7c40zhanyong.wan} 98337504994338c114247519331237831f88a9a7c40zhanyong.wan 98437504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}. 98537504994338c114247519331237831f88a9a7c40zhanyong.wan 98637504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest; 98737504994338c114247519331237831f88a9a7c40zhanyong.wan 98837504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) { 989c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 99037504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 99137504994338c114247519331237831f88a9a7c40zhanyong.wan} 992d201456903f3ecae1f7794edfab0d5678e64226shiqian 99337504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) { 99437504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches 99537504994338c114247519331237831f88a9a7c40zhanyong.wan // non-fatal failures generated on another thread. 996c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(), 99737504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 99837504994338c114247519331237831f88a9a7c40zhanyong.wan} 99937504994338c114247519331237831f88a9a7c40zhanyong.wan 100037504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a 100137504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 100237504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 100337504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1004e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE({ 1005e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1006c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1007e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1008d201456903f3ecae1f7794edfab0d5678e64226shiqian 1009e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({ 1010e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1011c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1012e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1013d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1014d201456903f3ecae1f7794edfab0d5678e64226shiqian 1015e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#if GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1016d201456903f3ecae1f7794edfab0d5678e64226shiqian 1017e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqiantypedef ScopedFakeTestPartResultReporterWithThreadsTest 1018e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ExpectFailureWithThreadsTest; 1019d201456903f3ecae1f7794edfab0d5678e64226shiqian 1020e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) { 1021e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE), 1022e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1023e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 1024e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1025e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) { 1026e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS( 1027e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure."); 1028d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1029d201456903f3ecae1f7794edfab0d5678e64226shiqian 1030e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#endif // GTEST_IS_THREADSAFE && GTEST_HAS_PTHREAD 1031e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1032d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestResult class 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian 1034d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestResult. 10359b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestResultTest : public Test { 1036d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1037d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef List<TestPartResult> TPRList; 1038d201456903f3ecae1f7794edfab0d5678e64226shiqian 1039d201456903f3ecae1f7794edfab0d5678e64226shiqian // We make use of 2 TestPartResult objects, 1040d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult * pr1, * pr2; 1041d201456903f3ecae1f7794edfab0d5678e64226shiqian 1042d201456903f3ecae1f7794edfab0d5678e64226shiqian // ... and 3 TestResult objects. 1043d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult * r0, * r1, * r2; 1044d201456903f3ecae1f7794edfab0d5678e64226shiqian 1045d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 1046d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr1 is for success. 10479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr1 = new TestPartResult(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"); 1048d201456903f3ecae1f7794edfab0d5678e64226shiqian 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr2 is for fatal failure. 10509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr2 = new TestPartResult(TPRT_FATAL_FAILURE, "foo/bar.cc", 10519b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian -1, // This line number means "unknown" 10529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "Failure!"); 1053d201456903f3ecae1f7794edfab0d5678e64226shiqian 1054d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates the TestResult objects. 1055d201456903f3ecae1f7794edfab0d5678e64226shiqian r0 = new TestResult(); 1056d201456903f3ecae1f7794edfab0d5678e64226shiqian r1 = new TestResult(); 1057d201456903f3ecae1f7794edfab0d5678e64226shiqian r2 = new TestResult(); 1058d201456903f3ecae1f7794edfab0d5678e64226shiqian 1059d201456903f3ecae1f7794edfab0d5678e64226shiqian // In order to test TestResult, we need to modify its internal 1060d201456903f3ecae1f7794edfab0d5678e64226shiqian // state, in particular the TestPartResult list it holds. 1061d201456903f3ecae1f7794edfab0d5678e64226shiqian // test_part_results() returns a const reference to this list. 1062d201456903f3ecae1f7794edfab0d5678e64226shiqian // We cast it to a non-const object s.t. it can be modified (yes, 1063d201456903f3ecae1f7794edfab0d5678e64226shiqian // this is a hack). 1064d201456903f3ecae1f7794edfab0d5678e64226shiqian TPRList * list1, * list2; 1065d201456903f3ecae1f7794edfab0d5678e64226shiqian list1 = const_cast<List<TestPartResult> *>( 1066d201456903f3ecae1f7794edfab0d5678e64226shiqian & r1->test_part_results()); 1067d201456903f3ecae1f7794edfab0d5678e64226shiqian list2 = const_cast<List<TestPartResult> *>( 1068d201456903f3ecae1f7794edfab0d5678e64226shiqian & r2->test_part_results()); 1069d201456903f3ecae1f7794edfab0d5678e64226shiqian 1070d201456903f3ecae1f7794edfab0d5678e64226shiqian // r0 is an empty TestResult. 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian 1072d201456903f3ecae1f7794edfab0d5678e64226shiqian // r1 contains a single SUCCESS TestPartResult. 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian list1->PushBack(*pr1); 1074d201456903f3ecae1f7794edfab0d5678e64226shiqian 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian // r2 contains a SUCCESS, and a FAILURE. 1076d201456903f3ecae1f7794edfab0d5678e64226shiqian list2->PushBack(*pr1); 1077d201456903f3ecae1f7794edfab0d5678e64226shiqian list2->PushBack(*pr2); 1078d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian 1080d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 1081d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr1; 1082d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr2; 1083d201456903f3ecae1f7794edfab0d5678e64226shiqian 1084d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r0; 1085d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r1; 1086d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r2; 1087d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1088d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1089d201456903f3ecae1f7794edfab0d5678e64226shiqian 1090d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_part_results() 1091d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, test_part_results) { 1092d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->test_part_results().size()); 1093d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->test_part_results().size()); 1094d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, r2->test_part_results().size()); 1095d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1096d201456903f3ecae1f7794edfab0d5678e64226shiqian 1097d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::successful_part_count() 1098d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, successful_part_count) { 1099d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->successful_part_count()); 1100d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->successful_part_count()); 1101d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r2->successful_part_count()); 1102d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1103d201456903f3ecae1f7794edfab0d5678e64226shiqian 1104d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::failed_part_count() 1105d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, failed_part_count) { 1106d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->failed_part_count()); 1107d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r1->failed_part_count()); 1108d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r2->failed_part_count()); 1109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1110d201456903f3ecae1f7794edfab0d5678e64226shiqian 11113d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev// Tests testing::internal::GetFailedPartCount(). 11123d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST_F(TestResultTest, GetFailedPartCount) { 11133d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ASSERT_EQ(0u, GetFailedPartCount(r0)); 11143d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ASSERT_EQ(0u, GetFailedPartCount(r1)); 11153d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev ASSERT_EQ(1u, GetFailedPartCount(r2)); 11163d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 11173d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 1118d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::total_part_count() 1119d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, total_part_count) { 1120d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->total_part_count()); 1121d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->total_part_count()); 1122d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, r2->total_part_count()); 1123d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1124d201456903f3ecae1f7794edfab0d5678e64226shiqian 1125d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::Passed() 1126d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Passed) { 1127d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r0->Passed()); 1128d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r1->Passed()); 1129d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r2->Passed()); 1130d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1131d201456903f3ecae1f7794edfab0d5678e64226shiqian 1132d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::Failed() 1133d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Failed) { 1134d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r0->Failed()); 1135d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r1->Failed()); 1136d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r2->Failed()); 1137d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1138d201456903f3ecae1f7794edfab0d5678e64226shiqian 1139d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has no properties when none are added. 1140d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 1141d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1142d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, test_result.test_properties().size()); 1143d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1144d201456903f3ecae1f7794edfab0d5678e64226shiqian 1145d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has the expected property when added. 1146d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 1147d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1148d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key_1", "1"); 1149d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property); 1150d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 1151d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, properties.size()); 1152d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property = properties.Head()->element(); 1153d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property.key()); 1154d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", actual_property.value()); 1155d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1156d201456903f3ecae1f7794edfab0d5678e64226shiqian 1157d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has multiple properties when added. 1158d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 1159d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1160d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1("key_1", "1"); 1161d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2("key_2", "2"); 1162d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1); 1163d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2); 1164d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 1165d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, properties.size()); 1166d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_1 = properties.Head()->element(); 1167d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property_1.key()); 1168d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", actual_property_1.value()); 1169d201456903f3ecae1f7794edfab0d5678e64226shiqian 1170d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_2 = properties.Last()->element(); 1171d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_2", actual_property_2.key()); 1172d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", actual_property_2.value()); 1173d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1174d201456903f3ecae1f7794edfab0d5678e64226shiqian 1175d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() overrides values for duplicate keys. 1176d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 1177d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1178d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_1("key_1", "1"); 1179d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_1("key_2", "2"); 1180d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_2("key_1", "12"); 1181d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_2("key_2", "22"); 1182d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1_1); 1183d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2_1); 1184d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1_2); 1185d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2_2); 1186d201456903f3ecae1f7794edfab0d5678e64226shiqian 1187d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 1188d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, properties.size()); 1189d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_1 = properties.Head()->element(); 1190d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property_1.key()); 1191d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("12", actual_property_1.value()); 1192d201456903f3ecae1f7794edfab0d5678e64226shiqian 1193d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_2 = properties.Last()->element(); 1194d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_2", actual_property_2.key()); 1195d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("22", actual_property_2.value()); 1196d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1197d201456903f3ecae1f7794edfab0d5678e64226shiqian 1198d201456903f3ecae1f7794edfab0d5678e64226shiqian// When a property using a reserved key is supplied to this function, it tests 1199d201456903f3ecae1f7794edfab0d5678e64226shiqian// that a non-fatal failure is added, a fatal failure is not added, and that the 1200d201456903f3ecae1f7794edfab0d5678e64226shiqian// property is not recorded. 1201d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) { 1202d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 12034b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan TestProperty property(key, "1"); 1204d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(test_result.RecordProperty(property), "Reserved key"); 1205d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(test_result.test_properties().IsEmpty()) << "Not recorded"; 1206d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1207d201456903f3ecae1f7794edfab0d5678e64226shiqian 1208d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "name" 1209d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1210d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) { 1211d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("name"); 1212d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1213d201456903f3ecae1f7794edfab0d5678e64226shiqian 1214d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "status" 1215d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1216d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) { 1217d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("status"); 1218d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1219d201456903f3ecae1f7794edfab0d5678e64226shiqian 1220d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "time" 1221d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1222d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) { 1223d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("time"); 1224d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1225d201456903f3ecae1f7794edfab0d5678e64226shiqian 1226d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "classname" 1227d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 1228d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) { 1229d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname"); 1230d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1231d201456903f3ecae1f7794edfab0d5678e64226shiqian 1232d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTestFlagSaver works on Windows and Mac. 1233d201456903f3ecae1f7794edfab0d5678e64226shiqian 12349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass GTestFlagSaverTest : public Test { 1235d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1236d201456903f3ecae1f7794edfab0d5678e64226shiqian // Saves the Google Test flags such that we can restore them later, and 1237d201456903f3ecae1f7794edfab0d5678e64226shiqian // then sets them to their default values. This will be called 1238d201456903f3ecae1f7794edfab0d5678e64226shiqian // before the first test in this test case is run. 1239d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 12409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian saver_ = new GTestFlagSaver; 12419b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1242fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 12439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = false; 12449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = false; 124553e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 12469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "auto"; 12479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = ""; 12489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = false; 12499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = ""; 1250f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 12519b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 1; 125240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 1253d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1254d201456903f3ecae1f7794edfab0d5678e64226shiqian 1255d201456903f3ecae1f7794edfab0d5678e64226shiqian // Restores the Google Test flags that the tests have modified. This will 1256d201456903f3ecae1f7794edfab0d5678e64226shiqian // be called after the last test in this test case is run. 1257d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 1258d201456903f3ecae1f7794edfab0d5678e64226shiqian delete saver_; 1259d201456903f3ecae1f7794edfab0d5678e64226shiqian saver_ = NULL; 1260d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1261d201456903f3ecae1f7794edfab0d5678e64226shiqian 1262d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the Google Test flags have their default values, and then 1263d201456903f3ecae1f7794edfab0d5678e64226shiqian // modifies each of them. 1264d201456903f3ecae1f7794edfab0d5678e64226shiqian void VerifyAndModifyFlags() { 1265fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests)); 12669b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 12679b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 12689b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 126953e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_FALSE(GTEST_FLAG(death_test_use_fork)); 12709b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 12719b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(list_tests)); 12729b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 1273f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan EXPECT_TRUE(GTEST_FLAG(print_time)); 12749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(1, GTEST_FLAG(repeat)); 127540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_FALSE(GTEST_FLAG(throw_on_failure)); 12769b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1277fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = true; 12789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = true; 12799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = true; 12809b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "no"; 128153e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = true; 12829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = "abc"; 12839b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = true; 12849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = "xml:foo.xml"; 1285f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = false; 12869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 100; 128740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = true; 1288d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1289d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1290d201456903f3ecae1f7794edfab0d5678e64226shiqian // For saving Google Test flags during this test case. 12919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian static GTestFlagSaver* saver_; 1292d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1293d201456903f3ecae1f7794edfab0d5678e64226shiqian 12949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 1295d201456903f3ecae1f7794edfab0d5678e64226shiqian 1296d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test doesn't guarantee the order of tests. The following two 1297d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests are designed to work regardless of their order. 1298d201456903f3ecae1f7794edfab0d5678e64226shiqian 1299d201456903f3ecae1f7794edfab0d5678e64226shiqian// Modifies the Google Test flags in the test body. 1300d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 1301d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1302d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1303d201456903f3ecae1f7794edfab0d5678e64226shiqian 1304d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that the Google Test flags in the body of the previous test were 1305d201456903f3ecae1f7794edfab0d5678e64226shiqian// restored to their original values. 1306d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 1307d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1308d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1309d201456903f3ecae1f7794edfab0d5678e64226shiqian 1310d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets an environment variable with the given name to the given 1311d201456903f3ecae1f7794edfab0d5678e64226shiqian// value. If the value argument is "", unsets the environment 1312d201456903f3ecae1f7794edfab0d5678e64226shiqian// variable. The caller must ensure that both arguments are not NULL. 1313d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic void SetEnv(const char* name, const char* value) { 1314d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef _WIN32_WCE 1315d201456903f3ecae1f7794edfab0d5678e64226shiqian // Environment variables are not supported on Windows CE. 1316d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1317c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#elif defined(__BORLANDC__) 1318c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder's putenv only stores a pointer to its parameter; we have to 1319c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ensure that the string remains valid as long as it might be needed. 1320c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We use an std::map to do so. 1321c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static std::map<String, String*> added_env; 1322c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1323c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Because putenv stores a pointer to the string buffer, we can't delete the 1324c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // previous string (if present) until after it's replaced. 1325c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan String *prev_env = NULL; 1326c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan if (added_env.find(name) != added_env.end()) { 1327c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan prev_env = added_env[name]; 1328c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 1329c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan added_env[name] = new String((Message() << name << "=" << value).GetString()); 1330c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan putenv(added_env[name]->c_str()); 1331c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan delete prev_env; 1332c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 13330af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#elif GTEST_OS_WINDOWS // If we are on Windows proper. 13349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian _putenv((Message() << name << "=" << value).GetString().c_str()); 1335d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1336d201456903f3ecae1f7794edfab0d5678e64226shiqian if (*value == '\0') { 1337d201456903f3ecae1f7794edfab0d5678e64226shiqian unsetenv(name); 1338d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1339d201456903f3ecae1f7794edfab0d5678e64226shiqian setenv(name, value, 1); 1340d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1341d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 1342d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1343d201456903f3ecae1f7794edfab0d5678e64226shiqian 1344d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef _WIN32_WCE 1345d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variables are not supported on Windows CE. 1346d201456903f3ecae1f7794edfab0d5678e64226shiqian 13479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::Int32FromGTestEnv; 1348d201456903f3ecae1f7794edfab0d5678e64226shiqian 1349d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests Int32FromGTestEnv(). 1350d201456903f3ecae1f7794edfab0d5678e64226shiqian 1351d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1352d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable is not set. 1353d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 13540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", ""); 1355d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 1356d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1357d201456903f3ecae1f7794edfab0d5678e64226shiqian 1358d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1359d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable overflows as an Int32. 1360d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 1361d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1362d201456903f3ecae1f7794edfab0d5678e64226shiqian 13630af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321"); 1364d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 1365d201456903f3ecae1f7794edfab0d5678e64226shiqian 13660af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321"); 1367d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 1368d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1369d201456903f3ecae1f7794edfab0d5678e64226shiqian 1370d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1371d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable does not represent a valid decimal integer. 1372d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 1373d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1374d201456903f3ecae1f7794edfab0d5678e64226shiqian 13750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1"); 1376d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 1377d201456903f3ecae1f7794edfab0d5678e64226shiqian 13780af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X"); 1379d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 1380d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1381d201456903f3ecae1f7794edfab0d5678e64226shiqian 1382d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() parses and returns the value of the 1383d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable when it represents a valid decimal integer in 1384d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1385d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 13860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123"); 1387d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 1388d201456903f3ecae1f7794edfab0d5678e64226shiqian 13890af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321"); 1390d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 1391d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1392d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // !defined(_WIN32_WCE) 1393d201456903f3ecae1f7794edfab0d5678e64226shiqian 1394d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ParseInt32Flag(). 1395d201456903f3ecae1f7794edfab0d5678e64226shiqian 1396d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1397d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag has wrong format 1398d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 1399d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1400d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 1401d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1402d201456903f3ecae1f7794edfab0d5678e64226shiqian 1403d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 1404d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1405d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1406d201456903f3ecae1f7794edfab0d5678e64226shiqian 1407d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1408d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag overflows as an Int32. 1409d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 1410d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1411d201456903f3ecae1f7794edfab0d5678e64226shiqian 1412d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1413d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 1414d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1415d201456903f3ecae1f7794edfab0d5678e64226shiqian 1416d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 1417d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1418d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1419d201456903f3ecae1f7794edfab0d5678e64226shiqian 1420d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1421d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag does not represent a valid decimal 1422d201456903f3ecae1f7794edfab0d5678e64226shiqian// integer. 1423d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 1424d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1425d201456903f3ecae1f7794edfab0d5678e64226shiqian 1426d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1427d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 1428d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1429d201456903f3ecae1f7794edfab0d5678e64226shiqian 1430d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 1431d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1432d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1433d201456903f3ecae1f7794edfab0d5678e64226shiqian 1434d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() parses the value of the flag and 1435d201456903f3ecae1f7794edfab0d5678e64226shiqian// returns true when the flag represents a valid decimal integer in 1436d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1437d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 1438d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 14390af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value)); 1440d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(456, value); 1441d201456903f3ecae1f7794edfab0d5678e64226shiqian 1442c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", 1443c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "abc", &value)); 1444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-789, value); 1445d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1446d201456903f3ecae1f7794edfab0d5678e64226shiqian 1447cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() parses the value of the var or 1448cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// returns the correct default. 14494853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 14504853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1451cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { 14520af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 14530af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); 14540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 14550af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123"); 14560af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 1457cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 14584853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif // _WIN32_WCE 1459cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 14600af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 1461cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1462cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1463cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable is not an Int32. 1464cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) { 14650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx"); 14660af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123);}, 1467cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1468cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1469cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1470cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1471cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable cannot be represnted by an Int32. 1472cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) { 14730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234"); 14740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_DEATH({Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123);}, 1475cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1476cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1477cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1478cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan#endif // GTEST_HAS_DEATH_TEST 1479cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1480cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1481cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard() selects all tests 1482cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// where there is 1 shard. 1483cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) { 1484cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0)); 1485cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1)); 1486cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2)); 1487cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3)); 1488cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4)); 1489cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1490cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1491cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanclass ShouldShardTest : public testing::Test { 1492cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan protected: 1493cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void SetUp() { 14940af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX"; 14950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL"; 1496cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1497cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1498cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void TearDown() { 1499cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1500cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1501cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1502cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1503cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* index_var_; 1504cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* total_var_; 1505cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan}; 1506cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1507cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is disabled if neither of the environment variables 1508cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// are set. 1509cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) { 1510cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1511cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1512cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1513cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1514cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1515cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1516cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1517cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is not enabled if total_shards == 1. 1518cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) { 1519cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1520cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "1"); 1521cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1522cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1523cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1524cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1525cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is enabled if total_shards > 1 and 1526cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// we are not in a death test subprocess. 15274853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 15284853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#ifndef _WIN32_WCE 1529cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { 1530cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1531cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "22"); 1532cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1533cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1534cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1535cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "8"); 1536cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1537cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1538cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1539cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1540cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1541cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1542cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1543cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1544cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 15454853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan#endif // _WIN32_WCE 1546cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 15470af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_DEATH_TEST 1548cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1549cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that we exit in error if the sharding values are not valid. 1550cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, AbortsWhenShardingEnvVarsAreInvalid) { 1551cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1552cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "4"); 1553cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_DEATH({ShouldShard(total_var_, index_var_, false);}, 1554cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1555cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1556cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1557cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "-2"); 1558cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_DEATH({ShouldShard(total_var_, index_var_, false);}, 1559cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1560cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1561cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "5"); 1562cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1563cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_DEATH({ShouldShard(total_var_, index_var_, false);}, 1564cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1565cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1566cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1567cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "5"); 1568cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_DEATH({ShouldShard(total_var_, index_var_, false);}, 1569cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ".*"); 1570cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1571cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1572cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan#endif // GTEST_HAS_DEATH_TEST 1573cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1574cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard is a partition when 5 1575cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// shards are used. 1576cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { 1577cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Choose an arbitrary number of tests and shards. 1578cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_tests = 17; 1579cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_shards = 5; 1580cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1581cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check partitioning: each test should be on exactly 1 shard. 1582cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1583cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int prev_selected_shard_index = -1; 1584cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1585cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) { 1586cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (prev_selected_shard_index < 0) { 1587cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan prev_selected_shard_index = shard_index; 1588cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } else { 1589cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and " 1590cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan << shard_index << " are both selected to run test " << test_id; 1591cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1592cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1593cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1594cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1595cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1596cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check balance: This is not required by the sharding protocol, but is a 1597cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // desirable property for performance. 1598cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1599cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int num_tests_on_shard = 0; 1600cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1601cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan num_tests_on_shard += 1602cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ShouldRunTestOnShard(num_shards, shard_index, test_id); 1603cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1604cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_GE(num_tests_on_shard, num_tests / num_shards); 1605cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1606cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1607cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1608d201456903f3ecae1f7794edfab0d5678e64226shiqian// For the same reason we are not explicitly testing everything in the 1609019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Test class, there are no separate tests for the following classes 1610019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// (except for some trivial cases): 1611d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1612d201456903f3ecae1f7794edfab0d5678e64226shiqian// TestCase, UnitTest, UnitTestResultPrinter. 1613d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1614d201456903f3ecae1f7794edfab0d5678e64226shiqian// Similarly, there are no separate tests for the following macros: 1615d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1616d201456903f3ecae1f7794edfab0d5678e64226shiqian// TEST, TEST_F, RUN_ALL_TESTS 1617d201456903f3ecae1f7794edfab0d5678e64226shiqian 1618019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST(UnitTestTest, CanGetOriginalWorkingDir) { 1619019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 1620019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 1621019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 1622019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 1623d201456903f3ecae1f7794edfab0d5678e64226shiqian// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 1624d201456903f3ecae1f7794edfab0d5678e64226shiqian// of various arities. They do not attempt to be exhaustive. Rather, 1625d201456903f3ecae1f7794edfab0d5678e64226shiqian// view them as smoke tests that can be easily reviewed and verified. 1626d201456903f3ecae1f7794edfab0d5678e64226shiqian// A more complete set of tests for predicate assertions can be found 1627d201456903f3ecae1f7794edfab0d5678e64226shiqian// in gtest_pred_impl_unittest.cc. 1628d201456903f3ecae1f7794edfab0d5678e64226shiqian 1629d201456903f3ecae1f7794edfab0d5678e64226shiqian// First, some predicates and predicate-formatters needed by the tests. 1630d201456903f3ecae1f7794edfab0d5678e64226shiqian 1631d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the argument is an even number. 1632d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsEven(int n) { 1633d201456903f3ecae1f7794edfab0d5678e64226shiqian return (n % 2) == 0; 1634d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1635d201456903f3ecae1f7794edfab0d5678e64226shiqian 1636d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the argument is an even number. 1637d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct IsEvenFunctor { 1638d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n) { return IsEven(n); } 1639d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1640d201456903f3ecae1f7794edfab0d5678e64226shiqian 1641d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the argument is an even 1642d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 16439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertIsEven(const char* expr, int n) { 1644d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(n)) { 16459b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1646d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1647d201456903f3ecae1f7794edfab0d5678e64226shiqian 16489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1649d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << expr << " evaluates to " << n << ", which is not even."; 16509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1651d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1652d201456903f3ecae1f7794edfab0d5678e64226shiqian 1653d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the argument is an even 1654d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1655d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertIsEvenFunctor { 16569b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()(const char* expr, int n) { 1657d201456903f3ecae1f7794edfab0d5678e64226shiqian return AssertIsEven(expr, n); 1658d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1659d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1660d201456903f3ecae1f7794edfab0d5678e64226shiqian 1661d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the sum of the arguments is an even number. 1662d201456903f3ecae1f7794edfab0d5678e64226shiqianbool SumIsEven2(int n1, int n2) { 1663d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2); 1664d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1665d201456903f3ecae1f7794edfab0d5678e64226shiqian 1666d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the sum of the arguments is an even 1667d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1668d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct SumIsEven3Functor { 1669d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n1, int n2, int n3) { 1670d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2 + n3); 1671d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1672d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1673d201456903f3ecae1f7794edfab0d5678e64226shiqian 1674d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the sum of the 1675d201456903f3ecae1f7794edfab0d5678e64226shiqian// arguments is an even number. 16769b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertSumIsEven4( 16779b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 16789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian int n1, int n2, int n3, int n4) { 1679d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4; 1680d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 16819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1682d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1683d201456903f3ecae1f7794edfab0d5678e64226shiqian 16849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1685d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 1686d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 1687d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 16889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1689d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1690d201456903f3ecae1f7794edfab0d5678e64226shiqian 1691d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the sum of the arguments 1692d201456903f3ecae1f7794edfab0d5678e64226shiqian// is an even number. 1693d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertSumIsEven5Functor { 16949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()( 16959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 16969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e5, int n1, int n2, int n3, int n4, int n5) { 1697d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4 + n5; 1698d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 16999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1700d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1701d201456903f3ecae1f7794edfab0d5678e64226shiqian 17029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1703d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 1704d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" 1705d201456903f3ecae1f7794edfab0d5678e64226shiqian << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 1706d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 17079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1708d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1709d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1710d201456903f3ecae1f7794edfab0d5678e64226shiqian 1711d201456903f3ecae1f7794edfab0d5678e64226shiqian 1712d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions. 1713d201456903f3ecae1f7794edfab0d5678e64226shiqian 1714d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that don't use a custom formatter. 1715d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithoutFormat) { 1716d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1717d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 1718d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsEven, 4); 1719d201456903f3ecae1f7794edfab0d5678e64226shiqian 1720d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1721d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1722d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 1723d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1724d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 1725d201456903f3ecae1f7794edfab0d5678e64226shiqian "evaluates to false"); 1726d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1727d201456903f3ecae1f7794edfab0d5678e64226shiqian 1728d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that use a custom formatter. 1729d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithFormat) { 1730d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1731d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(AssertIsEven, 2); 1732d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 1733d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 1734d201456903f3ecae1f7794edfab0d5678e64226shiqian 1735d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1736d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n = 5; 1737d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 1738d201456903f3ecae1f7794edfab0d5678e64226shiqian "n evaluates to 5, which is not even."); 1739d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1740d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 1741d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1742d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1743d201456903f3ecae1f7794edfab0d5678e64226shiqian 1744d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that unary predicate assertions evaluates their arguments 1745d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 1746d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, SingleEvaluationOnFailure) { 1747d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 1748d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 1749d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, n++); 1750d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 1751d201456903f3ecae1f7794edfab0d5678e64226shiqian 1752d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 1753d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1754d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 1755d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1756d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1757d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 1758d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1759d201456903f3ecae1f7794edfab0d5678e64226shiqian 1760d201456903f3ecae1f7794edfab0d5678e64226shiqian 1761d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions whose arity is >= 2. 1762d201456903f3ecae1f7794edfab0d5678e64226shiqian 1763d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that don't use a custom formatter. 1764d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithoutFormat) { 1765d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1766d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 1767d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 1768d201456903f3ecae1f7794edfab0d5678e64226shiqian 1769d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1770d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 1771d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 1772d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1773d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 1774d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1775d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1776d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 1777d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to false"); 1778d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1779d201456903f3ecae1f7794edfab0d5678e64226shiqian 1780d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that use a custom formatter. 1781d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithFormat) { 1782d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1783d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 1784d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is UNEXPECTED!"; 1785d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 1786d201456903f3ecae1f7794edfab0d5678e64226shiqian 1787d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1788d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 1789d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 1790d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n3 = 4; 1791d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n4 = 6; 1792d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1793d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 1794d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 13, which is not even."); 1795d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1796d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 1797d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1798d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1799d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1800d201456903f3ecae1f7794edfab0d5678e64226shiqian 1801d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that predicate assertions evaluates their arguments 1802d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 1803d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, SingleEvaluationOnFailure) { 1804d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 1805d201456903f3ecae1f7794edfab0d5678e64226shiqian int n1 = 0; 1806d201456903f3ecae1f7794edfab0d5678e64226shiqian int n2 = 0; 1807d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1++, n2++); 1808d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1809d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1810d201456903f3ecae1f7794edfab0d5678e64226shiqian 1811d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another success case. 1812d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = 0; 1813d201456903f3ecae1f7794edfab0d5678e64226shiqian int n3 = 0; 1814d201456903f3ecae1f7794edfab0d5678e64226shiqian int n4 = 0; 1815d201456903f3ecae1f7794edfab0d5678e64226shiqian int n5 = 0; 1816d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1817d201456903f3ecae1f7794edfab0d5678e64226shiqian n1++, n2++, n3++, n4++, n5++) 1818d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 1819d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1820d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1821d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1822d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 1823d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 1824d201456903f3ecae1f7794edfab0d5678e64226shiqian 1825d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 1826d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = 0; 1827d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1828d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 1829d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1830d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1831d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1832d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1833d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1834d201456903f3ecae1f7794edfab0d5678e64226shiqian 1835d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another failure case. 1836d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = n4 = 0; 1837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1838d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 1839d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 1, which is not even."); 1840d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1841d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1842d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1843d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 1844d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1845d201456903f3ecae1f7794edfab0d5678e64226shiqian 1846d201456903f3ecae1f7794edfab0d5678e64226shiqian 1847d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 1848d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PREDn and EXPECT_PREDn. 1849d201456903f3ecae1f7794edfab0d5678e64226shiqian 1850d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(int n) { 1851d201456903f3ecae1f7794edfab0d5678e64226shiqian return n > 0; 1852d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1853d201456903f3ecae1f7794edfab0d5678e64226shiqian 1854d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(double x) { 1855d201456903f3ecae1f7794edfab0d5678e64226shiqian return x > 0; 1856d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1857d201456903f3ecae1f7794edfab0d5678e64226shiqian 1858d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 1859d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsNegative(T x) { 1860d201456903f3ecae1f7794edfab0d5678e64226shiqian return x < 0; 1861d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1862d201456903f3ecae1f7794edfab0d5678e64226shiqian 1863d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 1864d201456903f3ecae1f7794edfab0d5678e64226shiqianbool GreaterThan(T1 x1, T2 x2) { 1865d201456903f3ecae1f7794edfab0d5678e64226shiqian return x1 > x2; 1866d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1867d201456903f3ecae1f7794edfab0d5678e64226shiqian 1868d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED* as long as 1869d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 1870d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 1871c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder requires C-style casts rather than static_cast. 1872c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT 1873c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT 1874d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1875d201456903f3ecae1f7794edfab0d5678e64226shiqian 1876d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED* as long as 1877d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 1878d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 1879d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsNegative<int>, -5); 1880d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes sure that we can handle templates with more than one 1881d201456903f3ecae1f7794edfab0d5678e64226shiqian // parameter. 1882d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 1883d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1884d201456903f3ecae1f7794edfab0d5678e64226shiqian 1885d201456903f3ecae1f7794edfab0d5678e64226shiqian 1886d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 1887d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 1888d201456903f3ecae1f7794edfab0d5678e64226shiqian 18894b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, int n) { 18909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return n > 0 ? AssertionSuccess() : 18919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1892d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1893d201456903f3ecae1f7794edfab0d5678e64226shiqian 18944b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, double x) { 18959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x > 0 ? AssertionSuccess() : 18969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1897d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1898d201456903f3ecae1f7794edfab0d5678e64226shiqian 1899d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 19004b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsNegativeFormat(const char* /* expr */, T x) { 19019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x < 0 ? AssertionSuccess() : 19029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1903d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1904d201456903f3ecae1f7794edfab0d5678e64226shiqian 1905d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 19064b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */, 19079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const T1& x1, const T2& x2) { 19089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x1 == x2 ? AssertionSuccess() : 19099b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1910d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1911d201456903f3ecae1f7794edfab0d5678e64226shiqian 1912d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED_FORMAT* 19134b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan// without explicitly specifying their types. 1914d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 1915d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 1916d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 1917d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1918d201456903f3ecae1f7794edfab0d5678e64226shiqian 1919d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED_FORMAT* without 1920d201456903f3ecae1f7794edfab0d5678e64226shiqian// explicitly specifying their types. 1921d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 1922d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 1923d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 1924d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1925d201456903f3ecae1f7794edfab0d5678e64226shiqian 1926d201456903f3ecae1f7794edfab0d5678e64226shiqian 1927d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests string assertions. 1928d201456903f3ecae1f7794edfab0d5678e64226shiqian 1929d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with non-NULL arguments. 1930d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ) { 1931d201456903f3ecae1f7794edfab0d5678e64226shiqian const char * const p1 = "good"; 1932d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p1); 1933d201456903f3ecae1f7794edfab0d5678e64226shiqian 1934d201456903f3ecae1f7794edfab0d5678e64226shiqian // Let p2 have the same content as p1, but be at a different address. 1935d201456903f3ecae1f7794edfab0d5678e64226shiqian const char p2[] = "good"; 1936d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p2); 1937d201456903f3ecae1f7794edfab0d5678e64226shiqian 1938d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 1939d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: \"bad\""); 1940d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1941d201456903f3ecae1f7794edfab0d5678e64226shiqian 1942d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 1943d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null) { 1944d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 1945d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 1946d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 1947d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1948d201456903f3ecae1f7794edfab0d5678e64226shiqian 1949d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 1950d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 1951d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 1952d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 1953d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1954d201456903f3ecae1f7794edfab0d5678e64226shiqian 1955d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRNE. 1956d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRNE) { 1957d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("hi", "Hi"); 1958d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", NULL); 1959d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, "Hi"); 1960d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", NULL); 1961d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, ""); 1962d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", "Hi"); 1963d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", ""); 1964d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 1965d201456903f3ecae1f7794edfab0d5678e64226shiqian "\"Hi\" vs \"Hi\""); 1966d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1967d201456903f3ecae1f7794edfab0d5678e64226shiqian 1968d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASEEQ. 1969d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 1970d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("hi", "Hi"); 1971d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 1972d201456903f3ecae1f7794edfab0d5678e64226shiqian 1973d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("", ""); 1974d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 1975d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 1976d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1977d201456903f3ecae1f7794edfab0d5678e64226shiqian 1978d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASENE. 1979d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASENE) { 1980d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("hi1", "Hi2"); 1981d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", NULL); 1982d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, "Hi"); 1983d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", NULL); 1984d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, ""); 1985d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", "Hi"); 1986d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", ""); 1987d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 1988d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 1989d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1990d201456903f3ecae1f7794edfab0d5678e64226shiqian 1991d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STREQ on wide strings. 1992d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STREQ_Wide) { 1993d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 1994d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 1995d201456903f3ecae1f7794edfab0d5678e64226shiqian 1996d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 1997d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(L"", L""); 1998d201456903f3ecae1f7794edfab0d5678e64226shiqian 1999d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2000d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 2001d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2002d201456903f3ecae1f7794edfab0d5678e64226shiqian 2003d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2004d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(L"Hi", L"Hi"); 2005d201456903f3ecae1f7794edfab0d5678e64226shiqian 2006d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2007d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 2008d201456903f3ecae1f7794edfab0d5678e64226shiqian "Abc"); 2009d201456903f3ecae1f7794edfab0d5678e64226shiqian 2010d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 2012d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2013d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2014d201456903f3ecae1f7794edfab0d5678e64226shiqian 2015d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STRNE on wide strings. 2016d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STRNE_Wide) { 2017d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2018d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2019d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 2020d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 2021d201456903f3ecae1f7794edfab0d5678e64226shiqian 2022d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2023d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 2024d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"\""); 2025d201456903f3ecae1f7794edfab0d5678e64226shiqian 2026d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2027d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(L"non-null", NULL); 2028d201456903f3ecae1f7794edfab0d5678e64226shiqian 2029d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2030d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 2031d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"Hi\""); 2032d201456903f3ecae1f7794edfab0d5678e64226shiqian 2033d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2034d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(L"abc", L"Abc"); 2035d201456903f3ecae1f7794edfab0d5678e64226shiqian 2036d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2037d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 2038d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2039d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2040d201456903f3ecae1f7794edfab0d5678e64226shiqian 2041d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsSubstring(). 2042d201456903f3ecae1f7794edfab0d5678e64226shiqian 2043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2044d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2045d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 2046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 2047d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 2048d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 2049d201456903f3ecae1f7794edfab0d5678e64226shiqian 2050d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 2051d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 2052d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2053d201456903f3ecae1f7794edfab0d5678e64226shiqian 2054d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2055d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2056d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 2057c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", kNull, L"a")); 2058c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", L"b", kNull)); 2059d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 2060d201456903f3ecae1f7794edfab0d5678e64226shiqian 2061d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 2062d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 2063d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2064d201456903f3ecae1f7794edfab0d5678e64226shiqian 2065d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2066d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2067d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 2068d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2069d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2070d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2071d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"haystack\"", 20729b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring("needle_expr", "haystack_expr", 20739b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "needle", "haystack").failure_message()); 2074d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2075d201456903f3ecae1f7794edfab0d5678e64226shiqian 2076d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 2077d201456903f3ecae1f7794edfab0d5678e64226shiqian 2078d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2079d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2080d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 20819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 20829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 2083d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2084d201456903f3ecae1f7794edfab0d5678e64226shiqian 2085d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 2086d201456903f3ecae1f7794edfab0d5678e64226shiqian 2087d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2088d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2089d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2090d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 2091d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2092d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2093d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2094d201456903f3ecae1f7794edfab0d5678e64226shiqian 2095d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2096d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2097d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 2098d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2099d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2100d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2101d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"haystack\"", 21029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring( 2103d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2104d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring(L"needle"), L"haystack").failure_message()); 2105d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2106d201456903f3ecae1f7794edfab0d5678e64226shiqian 2107d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2108d201456903f3ecae1f7794edfab0d5678e64226shiqian 2109d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsNotSubstring(). 2110d201456903f3ecae1f7794edfab0d5678e64226shiqian 2111d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2112d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2113d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 2114d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 2115d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 2116d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2117d201456903f3ecae1f7794edfab0d5678e64226shiqian 2118d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2119d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2120d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 2121d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 2122d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 2123d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2124d201456903f3ecae1f7794edfab0d5678e64226shiqian 2125d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2126d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2127d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 2128d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2129d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2130d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2131d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"two needles\"", 21329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2133d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2134d201456903f3ecae1f7794edfab0d5678e64226shiqian L"needle", L"two needles").failure_message()); 2135d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2136d201456903f3ecae1f7794edfab0d5678e64226shiqian 2137d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 2138d201456903f3ecae1f7794edfab0d5678e64226shiqian 2139d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2140d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2141d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 2142d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 2143d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 2144d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2145d201456903f3ecae1f7794edfab0d5678e64226shiqian 2146d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2147d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2148d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 2149d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2150d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2151d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2152d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"two needles\"", 21539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2154d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2155d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::string("needle"), "two needles").failure_message()); 2156d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2157d201456903f3ecae1f7794edfab0d5678e64226shiqian 2158d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 2159d201456903f3ecae1f7794edfab0d5678e64226shiqian 2160d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2161d201456903f3ecae1f7794edfab0d5678e64226shiqian 2162d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2163d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2164d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 2165d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE( 2166d201456903f3ecae1f7794edfab0d5678e64226shiqian IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2167d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2168d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2169d201456903f3ecae1f7794edfab0d5678e64226shiqian 2170d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2171d201456903f3ecae1f7794edfab0d5678e64226shiqian 2172d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests floating-point assertions. 2173d201456903f3ecae1f7794edfab0d5678e64226shiqian 2174d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 21759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FloatingPointTest : public Test { 2176d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2177c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2178c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Pre-calculated numbers to be used by the tests. 2179c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan struct TestValues { 2180c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_positive_zero; 2181c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_negative_zero; 2182c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_negative_zero; 2183c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2184c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_one; 2185c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_one; 2186c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2187c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType infinity; 2188c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_infinity; 2189c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_infinity; 2190c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2191c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan1; 2192c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan2; 2193c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }; 2194c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2195d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename testing::internal::FloatingPoint<RawType> Floating; 2196d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename Floating::Bits Bits; 2197d201456903f3ecae1f7794edfab0d5678e64226shiqian 2198d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 2199d201456903f3ecae1f7794edfab0d5678e64226shiqian const size_t max_ulps = Floating::kMaxUlps; 2200d201456903f3ecae1f7794edfab0d5678e64226shiqian 2201d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 0.0. 2202d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits zero_bits = Floating(0).bits(); 2203d201456903f3ecae1f7794edfab0d5678e64226shiqian 2204d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 0.0. 2205c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_positive_zero = Floating::ReinterpretBits( 2206c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan zero_bits + max_ulps/2); 2207c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_negative_zero = -Floating::ReinterpretBits( 2208d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps - max_ulps/2); 2209c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_negative_zero = -Floating::ReinterpretBits( 2210d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps + 1 - max_ulps/2); 2211d201456903f3ecae1f7794edfab0d5678e64226shiqian 2212d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 1.0. 2213d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits one_bits = Floating(1).bits(); 2214d201456903f3ecae1f7794edfab0d5678e64226shiqian 2215d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 1.0. 2216c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps); 2217c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_one = Floating::ReinterpretBits( 2218c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan one_bits + max_ulps + 1); 2219d201456903f3ecae1f7794edfab0d5678e64226shiqian 2220d201456903f3ecae1f7794edfab0d5678e64226shiqian // +infinity. 2221c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.infinity = Floating::Infinity(); 2222d201456903f3ecae1f7794edfab0d5678e64226shiqian 2223d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent +infinity. 2224c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const Bits infinity_bits = Floating(values_.infinity).bits(); 2225d201456903f3ecae1f7794edfab0d5678e64226shiqian 2226d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to infinity. 2227c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_infinity = Floating::ReinterpretBits( 2228c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan infinity_bits - max_ulps); 2229c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_infinity = Floating::ReinterpretBits( 2230d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_bits - max_ulps - 1); 2231d201456903f3ecae1f7794edfab0d5678e64226shiqian 2232c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Makes some NAN's. Sets the most significant bit of the fraction so that 2233c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // our NaN's are quiet; trying to process a signaling NaN would raise an 2234c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // exception if our environment enables floating point exceptions. 2235c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask 2236c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1); 2237c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask 2238c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200); 2239d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2240d201456903f3ecae1f7794edfab0d5678e64226shiqian 2241d201456903f3ecae1f7794edfab0d5678e64226shiqian void TestSize() { 2242d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2243d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2244d201456903f3ecae1f7794edfab0d5678e64226shiqian 2245c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static TestValues values_; 2246d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2247d201456903f3ecae1f7794edfab0d5678e64226shiqian 2248d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 2249c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wantypename FloatingPointTest<RawType>::TestValues 2250c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FloatingPointTest<RawType>::values_; 2251d201456903f3ecae1f7794edfab0d5678e64226shiqian 2252d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 2253d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<float> FloatTest; 2254d201456903f3ecae1f7794edfab0d5678e64226shiqian 2255d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Float::Bits matches the size of float. 2256d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Size) { 2257d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2258d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2259d201456903f3ecae1f7794edfab0d5678e64226shiqian 2260d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2261d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Zeros) { 2262d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, -0.0); 2263d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 2264d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 2266d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.5"); 2267d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2268d201456903f3ecae1f7794edfab0d5678e64226shiqian 2269d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2270d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2271d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_FLOAT_EQ handles the sign correctly and no 2272d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2273d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2274d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, AlmostZeros) { 2275c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2276c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2277c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2278c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const FloatTest::TestValues& v(this->values_); 2279c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2280c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero); 2281c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero); 2282c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2283d201456903f3ecae1f7794edfab0d5678e64226shiqian 2284d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2285c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(v.close_to_positive_zero, 2286c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2287c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2288d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2289d201456903f3ecae1f7794edfab0d5678e64226shiqian 2290d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2291d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, SmallDiff) { 2292c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(1.0, values_.close_to_one); 2293c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one), 2294c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2295d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2296d201456903f3ecae1f7794edfab0d5678e64226shiqian 2297d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2298d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, LargeDiff) { 2299d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 2300d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2301d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2302d201456903f3ecae1f7794edfab0d5678e64226shiqian 2303d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2304d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2305d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2306d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2307d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Infinity) { 2308c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity); 2309c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity); 23100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2311e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2312c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity), 2313c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2314d201456903f3ecae1f7794edfab0d5678e64226shiqian 2315c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This is interesting as the representations of infinity and nan1 2316d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2317c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1), 2318c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 23190af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2320d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2321d201456903f3ecae1f7794edfab0d5678e64226shiqian 2322d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2323d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, NaN) { 23240af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2325e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Nokia's STLport crashes if we try to output infinity or NaN. 2326c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2327c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2328c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2329c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2330c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const FloatTest::TestValues& v(this->values_); 2331c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2332c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), 2333c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2334c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), 2335c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan2"); 2336c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), 2337c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2338c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2339c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), 2340c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 23410af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2342d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2343d201456903f3ecae1f7794edfab0d5678e64226shiqian 2344d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are reflexive. 2345d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Reflexive) { 2346d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, 0.0); 2347d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0); 2348c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(values_.infinity, values_.infinity); 2349d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2350d201456903f3ecae1f7794edfab0d5678e64226shiqian 2351d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are commutative. 2352d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Commutative) { 2353c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one). 2354c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.close_to_one, 1.0); 2355d201456903f3ecae1f7794edfab0d5678e64226shiqian 2356c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one). 2357c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0), 2358d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2359d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2360d201456903f3ecae1f7794edfab0d5678e64226shiqian 2361d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2362d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, EXPECT_NEAR) { 2363d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 2364d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0f, 3.0f, 1.0f); 2365d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 2366d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 2367d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 2368d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2369d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2370d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2371d201456903f3ecae1f7794edfab0d5678e64226shiqian 2372d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2373d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, ASSERT_NEAR) { 2374d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 2375d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0f, 3.0f, 1.0f); 2376d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 2377d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 2378d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 2379d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2380d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2381d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2382d201456903f3ecae1f7794edfab0d5678e64226shiqian 2383d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should succeed. 2384d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLESucceeds) { 23859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 23869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 2387d201456903f3ecae1f7794edfab0d5678e64226shiqian 2388d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2389c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f); 2390d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2391d201456903f3ecae1f7794edfab0d5678e64226shiqian 2392d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should fail. 2393d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLEFails) { 2394d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 23959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 2396d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0f) <= (1.0f)"); 2397d201456903f3ecae1f7794edfab0d5678e64226shiqian 2398d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2399d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2400c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f); 2401c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0f)"); 2402d201456903f3ecae1f7794edfab0d5678e64226shiqian 2403c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2404e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2405c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2406c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2408c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity); 2409c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2410d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2411c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1); 2412c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(-values_.infinity) <= (values_.nan1)"); 2413d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2414c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1); 2415c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2416c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2417d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2418d201456903f3ecae1f7794edfab0d5678e64226shiqian 2419d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 2420d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<double> DoubleTest; 2421d201456903f3ecae1f7794edfab0d5678e64226shiqian 2422d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Double::Bits matches the size of double. 2423d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Size) { 2424d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2425d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2426d201456903f3ecae1f7794edfab0d5678e64226shiqian 2427d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2428d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Zeros) { 2429d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, -0.0); 2430d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 2431d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2432d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 2433d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2434d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2435d201456903f3ecae1f7794edfab0d5678e64226shiqian 2436d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2437d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2438d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_DOUBLE_EQ handles the sign correctly and no 2439d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2440d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2441d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, AlmostZeros) { 2442c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2443c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2444c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2445c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const DoubleTest::TestValues& v(this->values_); 2446c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2447c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero); 2448c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero); 2449c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2450d201456903f3ecae1f7794edfab0d5678e64226shiqian 2451d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2452c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(v.close_to_positive_zero, 2453c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2454c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2455d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2456d201456903f3ecae1f7794edfab0d5678e64226shiqian 2457d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2458d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, SmallDiff) { 2459c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(1.0, values_.close_to_one); 2460c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one), 2461c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2462d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2463d201456903f3ecae1f7794edfab0d5678e64226shiqian 2464d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2465d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, LargeDiff) { 2466d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 2467d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2468d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2469d201456903f3ecae1f7794edfab0d5678e64226shiqian 2470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2471d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2472d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2473d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2474d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Infinity) { 2475c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity); 2476c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity); 24770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2478e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2479c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity), 2480c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2481d201456903f3ecae1f7794edfab0d5678e64226shiqian 2482d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 2483d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2484c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1), 2485c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 24860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2487d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2488d201456903f3ecae1f7794edfab0d5678e64226shiqian 2489d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2490d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, NaN) { 24910af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2492c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2493c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2494c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2495c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static const DoubleTest::TestValues& v(this->values_); 2496c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2497e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2498c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), 2499c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2500c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2"); 2501c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1"); 2502c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), 2503c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 25040af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2505d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2506d201456903f3ecae1f7794edfab0d5678e64226shiqian 2507d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are reflexive. 2508d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Reflexive) { 2509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, 0.0); 2510d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, 1.0); 25110af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2512e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2513c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity); 25140af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2515d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2516d201456903f3ecae1f7794edfab0d5678e64226shiqian 2517d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are commutative. 2518d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Commutative) { 2519c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one). 2520c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0); 2521d201456903f3ecae1f7794edfab0d5678e64226shiqian 2522c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one). 2523c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0), 2524c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "1.0"); 2525d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2526d201456903f3ecae1f7794edfab0d5678e64226shiqian 2527d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2528d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, EXPECT_NEAR) { 2529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0, -1.1, 0.2); 2530d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0, 3.0, 1.0); 2531d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1), // NOLINT 2532d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2533d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2534d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2535d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2536d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2537d201456903f3ecae1f7794edfab0d5678e64226shiqian 2538d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2539d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, ASSERT_NEAR) { 2540d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0, -1.1, 0.2); 2541d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0, 3.0, 1.0); 2542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1), // NOLINT 2543d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2544d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2545d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2546d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2547d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2548d201456903f3ecae1f7794edfab0d5678e64226shiqian 2549d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should succeed. 2550d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLESucceeds) { 25519b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 25529b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 2553d201456903f3ecae1f7794edfab0d5678e64226shiqian 2554d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2555c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0); 2556d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2557d201456903f3ecae1f7794edfab0d5678e64226shiqian 2558d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should fail. 2559d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLEFails) { 2560d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 25619b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 2562d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0) <= (1.0)"); 2563d201456903f3ecae1f7794edfab0d5678e64226shiqian 2564d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2565d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2566c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0); 2567c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0)"); 2568d201456903f3ecae1f7794edfab0d5678e64226shiqian 2569c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2570e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2571c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2572c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2573d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2574c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity); 2575c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2577c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1); 2578c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, " (-values_.infinity) <= (values_.nan1)"); 2579d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2580c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1); 2581c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2582c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2583d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2584d201456903f3ecae1f7794edfab0d5678e64226shiqian 2585d201456903f3ecae1f7794edfab0d5678e64226shiqian 2586d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that a test or test case whose name starts with DISABLED_ is 2587d201456903f3ecae1f7794edfab0d5678e64226shiqian// not run. 2588d201456903f3ecae1f7794edfab0d5678e64226shiqian 2589d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name starts with DISABLED_. 2590d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2591d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, DISABLED_TestShouldNotRun) { 2592d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2593d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2594d201456903f3ecae1f7794edfab0d5678e64226shiqian 2595d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name does not start with DISABLED_. 2596d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should run. 2597d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, NotDISABLED_TestShouldRun) { 2598d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1); 2599d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2600d201456903f3ecae1f7794edfab0d5678e64226shiqian 2601d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case whose name starts with DISABLED_. 2602d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2603d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, TestShouldNotRun) { 2604d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2605d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2606d201456903f3ecae1f7794edfab0d5678e64226shiqian 2607d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case and test whose names start with DISABLED_. 2608d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2609d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 2610d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2611d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2612d201456903f3ecae1f7794edfab0d5678e64226shiqian 2613d201456903f3ecae1f7794edfab0d5678e64226shiqian// Check that when all tests in a test case are disabled, SetupTestCase() and 2614d201456903f3ecae1f7794edfab0d5678e64226shiqian// TearDownTestCase() are not called. 26159b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass DisabledTestsTest : public Test { 2616d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2617d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 2618d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2619d201456903f3ecae1f7794edfab0d5678e64226shiqian "SetupTestCase() should not be called."; 2620d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2621d201456903f3ecae1f7794edfab0d5678e64226shiqian 2622d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 2623d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2624d201456903f3ecae1f7794edfab0d5678e64226shiqian "TearDownTestCase() should not be called."; 2625d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2626d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2627d201456903f3ecae1f7794edfab0d5678e64226shiqian 2628d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 2629d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2630d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2631d201456903f3ecae1f7794edfab0d5678e64226shiqian 2632d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 2633d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2634d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2635d201456903f3ecae1f7794edfab0d5678e64226shiqian 2636a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled typed tests aren't run. 2637a2b1a8556ea64014606d78b09333d9c522430a25shiqian 26380af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST 2639a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2640a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2641a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTest : public Test { 2642a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2643a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2644a2b1a8556ea64014606d78b09333d9c522430a25shiqiantypedef testing::Types<int, double> NumericTypes; 2645a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(TypedTest, NumericTypes); 2646a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2647a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 2648a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2649a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2650a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2651a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2652a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTest : public Test { 2653a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2654a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2655a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 2656a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2657a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 2658a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2659a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2660a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2661a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST 2662a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2663a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled type-parameterized tests aren't run. 2664a2b1a8556ea64014606d78b09333d9c522430a25shiqian 26650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST_P 2666a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2667a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2668a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTestP : public Test { 2669a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2670a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2671a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(TypedTestP); 2672a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2673a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 2674a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2675a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2676a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2677a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2678a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 2679a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2680a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 2681a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2682a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2683a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTestP : public Test { 2684a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2685a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2686a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(DISABLED_TypedTestP); 2687a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2688a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 2689a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2690a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2691a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2692a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2693a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 2694a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2695a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 2696a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2697a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST_P 2698d201456903f3ecae1f7794edfab0d5678e64226shiqian 2699d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion macros evaluate their arguments exactly once. 2700d201456903f3ecae1f7794edfab0d5678e64226shiqian 27019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SingleEvaluationTest : public Test { 27028de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 2703d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_STREQ test 2704c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // below. It's public to work around C++Builder's bug with scoping local 2705c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // classes. 2706d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementCharPtrs() { 2707d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1_++, p2_++); 2708d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2709d201456903f3ecae1f7794edfab0d5678e64226shiqian 2710c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This helper function is needed by the FailedASSERT_NE test below. It's 2711c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // public to work around C++Builder's bug with scoping local classes. 2712d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementInts() { 2713d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(a_++, b_++); 2714d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2715d201456903f3ecae1f7794edfab0d5678e64226shiqian 2716c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan protected: 2717c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan SingleEvaluationTest() { 2718c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p1_ = s1_; 2719c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p2_ = s2_; 2720c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan a_ = 0; 2721c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan b_ = 0; 2722c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 2723c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2724d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s1_; 2725d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s2_; 2726d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p1_; 2727d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p2_; 2728d201456903f3ecae1f7794edfab0d5678e64226shiqian 2729d201456903f3ecae1f7794edfab0d5678e64226shiqian static int a_; 2730d201456903f3ecae1f7794edfab0d5678e64226shiqian static int b_; 2731d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2732d201456903f3ecae1f7794edfab0d5678e64226shiqian 2733d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s1_ = "01234"; 2734d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s2_ = "abcde"; 2735d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p1_; 2736d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p2_; 2737d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::a_; 2738d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::b_; 2739d201456903f3ecae1f7794edfab0d5678e64226shiqian 2740d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_STREQ fails, it evaluates its arguments 2741d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2742d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 2743c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(), 2744d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2_++"); 2745d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 2746d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 2747d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2748d201456903f3ecae1f7794edfab0d5678e64226shiqian 2749d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that string assertion arguments are evaluated exactly once. 2750d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, ASSERT_STR) { 2751d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_STRNE 2752d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(p1_++, p2_++); 2753d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 2754d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 2755d201456903f3ecae1f7794edfab0d5678e64226shiqian 2756d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_STRCASEEQ 2757d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 2758d201456903f3ecae1f7794edfab0d5678e64226shiqian "ignoring case"); 2759d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 2, p1_); 2760d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 2, p2_); 2761d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2762d201456903f3ecae1f7794edfab0d5678e64226shiqian 2763d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 2764d201456903f3ecae1f7794edfab0d5678e64226shiqian// once. 2765d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 2766c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(), 2767c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "(a_++) != (b_++)"); 2768d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 2769d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 2770d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2771d201456903f3ecae1f7794edfab0d5678e64226shiqian 2772d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion arguments are evaluated exactly once. 2773d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, OtherCases) { 2774d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_TRUE 2775d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(0 == a_++); // NOLINT 2776d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 2777d201456903f3ecae1f7794edfab0d5678e64226shiqian 2778d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_TRUE 2779d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 2780d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a_); 2781d201456903f3ecae1f7794edfab0d5678e64226shiqian 2782d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_GT 2783d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(a_++, b_++); 2784d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a_); 2785d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 2786d201456903f3ecae1f7794edfab0d5678e64226shiqian 2787d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_LT 2788d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 2789d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a_); 2790d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, b_); 2791d201456903f3ecae1f7794edfab0d5678e64226shiqian 2792d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_TRUE 2793d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(0 < a_++); // NOLINT 2794d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, a_); 2795d201456903f3ecae1f7794edfab0d5678e64226shiqian 2796d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_GT 2797d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(a_++, b_++); 2798d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(6, a_); 2799d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, b_); 2800d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2801d201456903f3ecae1f7794edfab0d5678e64226shiqian 280236865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 280336865d8d354465e3461eedf2949a4b7799985d5dshiqian 280436865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAnInteger() { 280536865d8d354465e3461eedf2949a4b7799985d5dshiqian throw 1; 280636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 280736865d8d354465e3461eedf2949a4b7799985d5dshiqian 280836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests that assertion arguments are evaluated exactly once. 280936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST_F(SingleEvaluationTest, ExceptionTests) { 281036865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_THROW 281136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW({ // NOLINT 281236865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 281336865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 281436865d8d354465e3461eedf2949a4b7799985d5dshiqian }, int); 281536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(1, a_); 281636865d8d354465e3461eedf2949a4b7799985d5dshiqian 281736865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws different 281836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 281936865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 282036865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 282136865d8d354465e3461eedf2949a4b7799985d5dshiqian }, bool), "throws a different type"); 282236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(2, a_); 282336865d8d354465e3461eedf2949a4b7799985d5dshiqian 282436865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws nothing 282536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 282636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(3, a_); 282736865d8d354465e3461eedf2949a4b7799985d5dshiqian 282836865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_NO_THROW 282936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(a_++); 283036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(4, a_); 283136865d8d354465e3461eedf2949a4b7799985d5dshiqian 283236865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_NO_THROW 283336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 283436865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 283536865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 283636865d8d354465e3461eedf2949a4b7799985d5dshiqian }), "it throws"); 283736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(5, a_); 283836865d8d354465e3461eedf2949a4b7799985d5dshiqian 283936865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_ANY_THROW 284036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW({ // NOLINT 284136865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 284236865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 284336865d8d354465e3461eedf2949a4b7799985d5dshiqian }); 284436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(6, a_); 284536865d8d354465e3461eedf2949a4b7799985d5dshiqian 284636865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_ANY_THROW 284736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 284836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(7, a_); 284936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 285036865d8d354465e3461eedf2949a4b7799985d5dshiqian 285136865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 2852d201456903f3ecae1f7794edfab0d5678e64226shiqian 2853e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE. 2854e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass NoFatalFailureTest : public Test { 2855e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 2856e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Succeeds() {} 2857e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void FailsNonFatal() { 2858e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "some non-fatal failure"; 2859e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2860e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Fails() { 2861e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FAIL() << "some fatal failure"; 2862e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2863e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2864e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoAssertNoFatalFailureOnFails() { 2865e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Fails()); 2866e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "shold not reach here."; 2867e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2868e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2869e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoExpectNoFatalFailureOnFails() { 2870e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Fails()); 2871e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "other failure"; 2872e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2873e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 2874e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2875e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NoFailure) { 2876e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Succeeds()); 2877e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Succeeds()); 2878e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 2879e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2880e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NonFatalIsNoFailure) { 2881e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 2882e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FailsNonFatal()), 2883e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 2884e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 2885e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FailsNonFatal()), 2886e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 2887e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 2888e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2889e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) { 2890e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 2891e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 2892e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 2893e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoAssertNoFatalFailureOnFails(); 2894e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2895e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 2896e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 2897e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 2898e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 2899e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 2900e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 2901e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 2902e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 2903e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 2904e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 2905e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2906e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) { 2907e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 2908e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 2909e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 2910e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoExpectNoFatalFailureOnFails(); 2911e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2912e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(3, gtest_failures.size()); 2913e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_FATAL_FAILURE, 2914e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 2915e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 2916e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 2917e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 2918e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).type()); 2919e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 2920e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 2921e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 2922e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 2923e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure", 2924e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).message()); 2925e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 2926e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2927e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, MessageIsStreamable) { 2928e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 2929e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 2930e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 2931e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message"; 2932e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 2933e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 2934e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 2935e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 2936e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(testing::TPRT_NONFATAL_FAILURE, 2937e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 2938e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo", 2939e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 2940e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message", 2941e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 2942e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 2943e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 2944d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests non-string assertions. 2945d201456903f3ecae1f7794edfab0d5678e64226shiqian 2946d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EqFailure(), used for implementing *EQ* assertions. 2947d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, EqFailure) { 2948d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo_val("5"), bar_val("6"); 2949d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg1( 2950d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", foo_val, bar_val, false) 2951d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2952d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2953d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2954d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2955d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 2956d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 2957d201456903f3ecae1f7794edfab0d5678e64226shiqian msg1.c_str()); 2958d201456903f3ecae1f7794edfab0d5678e64226shiqian 2959d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg2( 2960d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "6", foo_val, bar_val, false) 2961d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2962d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2963d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 2964d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 2965d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 2966d201456903f3ecae1f7794edfab0d5678e64226shiqian msg2.c_str()); 2967d201456903f3ecae1f7794edfab0d5678e64226shiqian 2968d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg3( 2969d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "bar", foo_val, bar_val, false) 2970d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2971d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2972d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2973d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2974d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 2975d201456903f3ecae1f7794edfab0d5678e64226shiqian msg3.c_str()); 2976d201456903f3ecae1f7794edfab0d5678e64226shiqian 2977d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg4( 2978d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 2979d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2980d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 2981d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 2982d201456903f3ecae1f7794edfab0d5678e64226shiqian msg4.c_str()); 2983d201456903f3ecae1f7794edfab0d5678e64226shiqian 2984d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg5( 2985d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", 2986d201456903f3ecae1f7794edfab0d5678e64226shiqian String("\"x\""), String("\"y\""), 2987d201456903f3ecae1f7794edfab0d5678e64226shiqian true).failure_message()); 2988d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2989d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2990d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"y\"\n" 2991d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo (ignoring case)\n" 2992d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"x\"", 2993d201456903f3ecae1f7794edfab0d5678e64226shiqian msg5.c_str()); 2994d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2995d201456903f3ecae1f7794edfab0d5678e64226shiqian 2996d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests AppendUserMessage(), used for implementing the *EQ* macros. 2997d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AppendUserMessage) { 2998d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 2999d201456903f3ecae1f7794edfab0d5678e64226shiqian 30009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3001d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", 3002d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3003d201456903f3ecae1f7794edfab0d5678e64226shiqian 3004d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << "bar"; 3005d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo\nbar", 3006d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3007d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3008d201456903f3ecae1f7794edfab0d5678e64226shiqian 3009c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3010c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3011c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3012c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3013c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3014d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_TRUE. 3015d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_TRUE) { 3016d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(2 > 1); // NOLINT 3017d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 3018d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 1"); 3019d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3020d201456903f3ecae1f7794edfab0d5678e64226shiqian 3021d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_FALSE. 3022d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_FALSE) { 3023d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(2 < 1); // NOLINT 3024d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 3025d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3026d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3027d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3028d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3029d201456903f3ecae1f7794edfab0d5678e64226shiqian 3030c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3031c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3032c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 3033c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3034c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3035d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ASSERT_EQ on double values. The purpose is to make 3036d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3037d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3038d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_Double) { 3039d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3040d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5.6, 5.6); 3041d201456903f3ecae1f7794edfab0d5678e64226shiqian 3042d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3043d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 3044d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3045d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3046d201456903f3ecae1f7794edfab0d5678e64226shiqian 3047d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ. 3048d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ) { 3049d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5, 2 + 3); 3050d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 3051d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3052d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3053d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3054d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3055d201456903f3ecae1f7794edfab0d5678e64226shiqian 3056d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(NULL, pointer). 30570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3058d201456903f3ecae1f7794edfab0d5678e64226shiqian// The NULL-detection template magic fails to compile with 3059d201456903f3ecae1f7794edfab0d5678e64226shiqian// the Nokia compiler and crashes the ARM compiler, hence 3060d201456903f3ecae1f7794edfab0d5678e64226shiqian// not testing on Symbian. 3061d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ_NULL) { 3062d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3063d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3064d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(NULL, p); 3065d201456903f3ecae1f7794edfab0d5678e64226shiqian 3066d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3067d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 3068d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 3069d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3070d201456903f3ecae1f7794edfab0d5678e64226shiqian} 30710af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3072d201456903f3ecae1f7794edfab0d5678e64226shiqian 3073d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 3074d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3075d201456903f3ecae1f7794edfab0d5678e64226shiqian// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 3076d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 3077d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_0) { 3078d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3079d201456903f3ecae1f7794edfab0d5678e64226shiqian 3080d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3081d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0, n); 3082d201456903f3ecae1f7794edfab0d5678e64226shiqian 3083d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3084d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 3085d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3086d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3087d201456903f3ecae1f7794edfab0d5678e64226shiqian 3088d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NE. 3089d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_NE) { 3090d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(6, 7); 3091d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 3092d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3093d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3094d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3095d201456903f3ecae1f7794edfab0d5678e64226shiqian 3096d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LE. 3097d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LE) { 3098d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 3); 3099d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 2); 3100d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 3101d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3102d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3103d201456903f3ecae1f7794edfab0d5678e64226shiqian 3104d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LT. 3105d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LT) { 3106d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(2, 3); 3107d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 3108d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3110d201456903f3ecae1f7794edfab0d5678e64226shiqian 3111d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GE. 3112d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GE) { 3113d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 1); 3114d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 2); 3115d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 3116d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3117d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3118d201456903f3ecae1f7794edfab0d5678e64226shiqian 3119d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GT. 3120d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GT) { 3121d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(2, 1); 3122d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 3123d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3124d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3125d201456903f3ecae1f7794edfab0d5678e64226shiqian 312636865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 312736865d8d354465e3461eedf2949a4b7799985d5dshiqian 3128886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wanvoid ThrowNothing() {} 3129886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan 313036865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_THROW. 313136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_THROW) { 313236865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int); 3133c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x600 || defined(_DEBUG) 3134c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 (Release build). 3135886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3136886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowAnInteger(), bool), 3137886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of type bool.\n" 3138886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws a different type."); 3139c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3140886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3141886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowNothing(), bool), 3142886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3143886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 314436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 314536865d8d354465e3461eedf2949a4b7799985d5dshiqian 314636865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_NO_THROW. 314736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_NO_THROW) { 3148886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()); 314936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 3150886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an exception." 315136865d8d354465e3461eedf2949a4b7799985d5dshiqian "\n Actual: it throws."); 315236865d8d354465e3461eedf2949a4b7799985d5dshiqian} 315336865d8d354465e3461eedf2949a4b7799985d5dshiqian 315436865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_ANY_THROW. 315536865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_ANY_THROW) { 315636865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()); 3157886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3158886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_ANY_THROW(ThrowNothing()), 3159886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3160886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 316136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 316236865d8d354465e3461eedf2949a4b7799985d5dshiqian 316336865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 316436865d8d354465e3461eedf2949a4b7799985d5dshiqian 3165d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure we deal with the precedence of <<. This test should 3166d201456903f3ecae1f7794edfab0d5678e64226shiqian// compile. 3167d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertPrecedence) { 3168d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1 < 2, true); 3169d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(true && false, false); 3170d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3171d201456903f3ecae1f7794edfab0d5678e64226shiqian 3172d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3173d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestEq1(int x) { 3174d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, x); 3175d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3176d201456903f3ecae1f7794edfab0d5678e64226shiqian 3177d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests calling a test subroutine that's not part of a fixture. 3178d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, NonFixtureSubroutine) { 3179d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestEq1(2), 3180d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: x"); 3181d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3182d201456903f3ecae1f7794edfab0d5678e64226shiqian 3183d201456903f3ecae1f7794edfab0d5678e64226shiqian// An uncopyable class. 3184d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Uncopyable { 3185d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3186d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Uncopyable(int value) : value_(value) {} 3187d201456903f3ecae1f7794edfab0d5678e64226shiqian 3188d201456903f3ecae1f7794edfab0d5678e64226shiqian int value() const { return value_; } 3189d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator==(const Uncopyable& rhs) const { 3190d201456903f3ecae1f7794edfab0d5678e64226shiqian return value() == rhs.value(); 3191d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3192d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3193d201456903f3ecae1f7794edfab0d5678e64226shiqian // This constructor deliberately has no implementation, as we don't 3194d201456903f3ecae1f7794edfab0d5678e64226shiqian // want this class to be copyable. 3195d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable(const Uncopyable&); // NOLINT 3196d201456903f3ecae1f7794edfab0d5678e64226shiqian 3197d201456903f3ecae1f7794edfab0d5678e64226shiqian int value_; 3198d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3199d201456903f3ecae1f7794edfab0d5678e64226shiqian 3200d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 3201d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << value.value(); 3202d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3203d201456903f3ecae1f7794edfab0d5678e64226shiqian 3204d201456903f3ecae1f7794edfab0d5678e64226shiqian 3205d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositiveUncopyable(const Uncopyable& x) { 3206d201456903f3ecae1f7794edfab0d5678e64226shiqian return x.value() > 0; 3207d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3208d201456903f3ecae1f7794edfab0d5678e64226shiqian 3209d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3210d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertNonPositive() { 3211d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3212d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, y); 3213d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3214d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3215d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertEqualsUncopyable() { 3216d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3217d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3218d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, y); 3219d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3220d201456903f3ecae1f7794edfab0d5678e64226shiqian 3221d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in assertions. 3222d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertWorksWithUncopyableObject) { 3223d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3224d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, x); 3225d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, x); 3226d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 3227d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3228d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 3229d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3230d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3231d201456903f3ecae1f7794edfab0d5678e64226shiqian 3232d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in expects. 3233d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 3234d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3235d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsPositiveUncopyable, x); 3236d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3237d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 3238d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3239d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(x, x); 3240d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 3241d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3242d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3243d201456903f3ecae1f7794edfab0d5678e64226shiqian 3244d201456903f3ecae1f7794edfab0d5678e64226shiqian 3245d201456903f3ecae1f7794edfab0d5678e64226shiqian// The version of gcc used in XCode 2.2 has a bug and doesn't allow 32466a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// anonymous enums in assertions. Therefore the following test is not 32476a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// done on Mac. 32486a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#if !GTEST_OS_MAC 3249d201456903f3ecae1f7794edfab0d5678e64226shiqian 3250d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using assertions with anonymous enums. 3251d201456903f3ecae1f7794edfab0d5678e64226shiqianenum { 3252d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_A = -1, 32530af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 3254d201456903f3ecae1f7794edfab0d5678e64226shiqian // We want to test the case where the size of the anonymous enum is 3255d201456903f3ecae1f7794edfab0d5678e64226shiqian // larger than sizeof(int), to make sure our implementation of the 3256d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions doesn't truncate the enums. However, MSVC 3257d201456903f3ecae1f7794edfab0d5678e64226shiqian // (incorrectly) doesn't allow an enum value to exceed the range of 3258d201456903f3ecae1f7794edfab0d5678e64226shiqian // an int, so this has to be conditionally compiled. 3259d201456903f3ecae1f7794edfab0d5678e64226shiqian // 3260d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Linux, CASE_B and CASE_A have the same value when truncated to 3261d201456903f3ecae1f7794edfab0d5678e64226shiqian // int size. We want to test whether this will confuse the 3262d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions. 32639b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian CASE_B = testing::internal::kMaxBiggestInt, 3264d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 3265d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_B = INT_MAX, 3266d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 3267d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3268d201456903f3ecae1f7794edfab0d5678e64226shiqian 3269d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AnonymousEnum) { 32700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_LINUX 3271d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B)); 3272d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 3273d201456903f3ecae1f7794edfab0d5678e64226shiqian 3274d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(CASE_A, CASE_A); 3275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(CASE_A, CASE_B); 3276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(CASE_A, CASE_B); 3277d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(CASE_A, CASE_B); 3278d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(CASE_B, CASE_A); 3279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(CASE_A, CASE_A); 3280d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(CASE_A, CASE_B), 3281d201456903f3ecae1f7794edfab0d5678e64226shiqian "(CASE_A) >= (CASE_B)"); 3282d201456903f3ecae1f7794edfab0d5678e64226shiqian 3283d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(CASE_A, CASE_A); 3284d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(CASE_A, CASE_B); 3285d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(CASE_A, CASE_B); 3286d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(CASE_A, CASE_B); 3287d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(CASE_B, CASE_A); 3288d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(CASE_A, CASE_A); 3289d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(CASE_A, CASE_B), 3290d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: CASE_B"); 3291d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3292d201456903f3ecae1f7794edfab0d5678e64226shiqian 32936a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan#endif // !GTEST_OS_MAC 3294d201456903f3ecae1f7794edfab0d5678e64226shiqian 32950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 3296d201456903f3ecae1f7794edfab0d5678e64226shiqian 3297d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT UnexpectedHRESULTFailure() { 3298d201456903f3ecae1f7794edfab0d5678e64226shiqian return E_UNEXPECTED; 3299d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3300d201456903f3ecae1f7794edfab0d5678e64226shiqian 3301d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT OkHRESULTSuccess() { 3302d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_OK; 3303d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3304d201456903f3ecae1f7794edfab0d5678e64226shiqian 3305d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT FalseHRESULTSuccess() { 3306d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_FALSE; 3307d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3308d201456903f3ecae1f7794edfab0d5678e64226shiqian 3309d201456903f3ecae1f7794edfab0d5678e64226shiqian// HRESULT assertion tests test both zero and non-zero 3310d201456903f3ecae1f7794edfab0d5678e64226shiqian// success codes as well as failure message for each. 3311d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3312d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows CE doesn't support message texts. 3313d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 3314d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK); 3315d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_FALSE); 3316d201456903f3ecae1f7794edfab0d5678e64226shiqian 3317d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3318ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3319ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3320d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3321d201456903f3ecae1f7794edfab0d5678e64226shiqian 3322d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 3323d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK); 3324d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_FALSE); 3325d201456903f3ecae1f7794edfab0d5678e64226shiqian 3326d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3327ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3328ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3329d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3330d201456903f3ecae1f7794edfab0d5678e64226shiqian 3331d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 3332d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED); 3333d201456903f3ecae1f7794edfab0d5678e64226shiqian 3334d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 3335ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3336ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3337d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 3338ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3339ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3340d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3341d201456903f3ecae1f7794edfab0d5678e64226shiqian 3342d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 3343d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED); 3344d201456903f3ecae1f7794edfab0d5678e64226shiqian 3345c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3346c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3347d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 3348ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 3349ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 3350c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3351d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 3352ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 3353ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 3354d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3355d201456903f3ecae1f7794edfab0d5678e64226shiqian 3356d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that streaming to the HRESULT macros works. 3357d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, Streaming) { 3358d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3359d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 3360d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3361d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 3362d201456903f3ecae1f7794edfab0d5678e64226shiqian 3363d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3364d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3365d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3366d201456903f3ecae1f7794edfab0d5678e64226shiqian 3367c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifndef __BORLANDC__ 3368c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 3369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3370d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 3371d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3372c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3373d201456903f3ecae1f7794edfab0d5678e64226shiqian 3374d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 3375d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 3376d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3377d201456903f3ecae1f7794edfab0d5678e64226shiqian 3378d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 3379d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 3380d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 3381d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3382d201456903f3ecae1f7794edfab0d5678e64226shiqian 33830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_WINDOWS 3384d201456903f3ecae1f7794edfab0d5678e64226shiqian 3385c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3386c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3387c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 3388c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3389c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3390d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros behave like single statements. 3391e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) { 3392d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3393d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(false) << "This should never be executed; " 3394d201456903f3ecae1f7794edfab0d5678e64226shiqian "It's a compilation test only."; 3395d201456903f3ecae1f7794edfab0d5678e64226shiqian 3396d201456903f3ecae1f7794edfab0d5678e64226shiqian if (true) 3397d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false); 3398d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3399ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3400d201456903f3ecae1f7794edfab0d5678e64226shiqian 3401d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3402d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 3); 3403d201456903f3ecae1f7794edfab0d5678e64226shiqian 3404d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 3405ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3406d201456903f3ecae1f7794edfab0d5678e64226shiqian else 3407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(3, 2) << ""; 3408e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 340936865d8d354465e3461eedf2949a4b7799985d5dshiqian 341036865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 341137504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the compiler will not complain about unreachable code in the 341237504994338c114247519331237831f88a9a7c40zhanyong.wan// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros. 341337504994338c114247519331237831f88a9a7c40zhanyong.wanTEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) { 341437504994338c114247519331237831f88a9a7c40zhanyong.wan int n = 0; 341537504994338c114247519331237831f88a9a7c40zhanyong.wan 341637504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_THROW(throw 1, int); 341737504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), ""); 341837504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), ""); 341937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NO_THROW(n++); 342037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), ""); 342137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_ANY_THROW(throw 1); 342237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), ""); 342337504994338c114247519331237831f88a9a7c40zhanyong.wan} 342437504994338c114247519331237831f88a9a7c40zhanyong.wan 3425e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) { 342636865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 3427886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool); 342836865d8d354465e3461eedf2949a4b7799985d5dshiqian 342936865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 343036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 343136865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3432ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 343336865d8d354465e3461eedf2949a4b7799985d5dshiqian 343436865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 343536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(ThrowAnInteger()); 343636865d8d354465e3461eedf2949a4b7799985d5dshiqian 343736865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 3438886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 343936865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3440ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 344136865d8d354465e3461eedf2949a4b7799985d5dshiqian 344236865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 3443886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()); 344436865d8d354465e3461eedf2949a4b7799985d5dshiqian 344536865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 344636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 344736865d8d354465e3461eedf2949a4b7799985d5dshiqian else 3448ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3449e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 345036865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 3451e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3452e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) { 3453e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3454e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. " 3455e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian << "It's a compilation test only."; 3456e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3457ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3458e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3459e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3460e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FAIL()) << ""; 3461e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3462ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3463e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3464e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (true) 3465e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(SUCCEED()); 3466e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3467ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3468e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3469e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (false) 3470ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 3471e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 3472e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(SUCCEED()); 3473d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3474d201456903f3ecae1f7794edfab0d5678e64226shiqian 3475d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros work well with switch statements. 3476d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, WorksWithSwitch) { 3477d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 3478d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 3479d201456903f3ecae1f7794edfab0d5678e64226shiqian break; 3480d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 3481d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 3482d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3483d201456903f3ecae1f7794edfab0d5678e64226shiqian 3484d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 3485d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 3486d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 3487d201456903f3ecae1f7794edfab0d5678e64226shiqian 3488d201456903f3ecae1f7794edfab0d5678e64226shiqian // Binary assertions are implemented using a different code path 3489d201456903f3ecae1f7794edfab0d5678e64226shiqian // than the Boolean assertions. Hence we test them separately. 3490d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 3491d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 3492d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 3493d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 3494d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3495d201456903f3ecae1f7794edfab0d5678e64226shiqian 3496d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 3497d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 3498d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(1, 2); 3499d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3500d201456903f3ecae1f7794edfab0d5678e64226shiqian 350136865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 350236865d8d354465e3461eedf2949a4b7799985d5dshiqian 350336865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAString() { 350436865d8d354465e3461eedf2949a4b7799985d5dshiqian throw "String"; 350536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 350636865d8d354465e3461eedf2949a4b7799985d5dshiqian 350736865d8d354465e3461eedf2949a4b7799985d5dshiqian// Test that the exception assertion macros compile and work with const 350836865d8d354465e3461eedf2949a4b7799985d5dshiqian// type qualifier. 350936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionSyntaxTest, WorksWithConst) { 351036865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAString(), const char*); 351136865d8d354465e3461eedf2949a4b7799985d5dshiqian 351236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAString(), const char*); 351336865d8d354465e3461eedf2949a4b7799985d5dshiqian} 351436865d8d354465e3461eedf2949a4b7799985d5dshiqian 351536865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 351636865d8d354465e3461eedf2949a4b7799985d5dshiqian 3517d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 3518d201456903f3ecae1f7794edfab0d5678e64226shiqian 3519d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns the number of successful parts in the current test. 3520d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic size_t GetSuccessfulPartCount() { 3521d201456903f3ecae1f7794edfab0d5678e64226shiqian return UnitTest::GetInstance()->impl()->current_test_result()-> 3522d201456903f3ecae1f7794edfab0d5678e64226shiqian successful_part_count(); 3523d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3524d201456903f3ecae1f7794edfab0d5678e64226shiqian 3525d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 3526d201456903f3ecae1f7794edfab0d5678e64226shiqian 3527d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test tracks SUCCEED*. 3528d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, SUCCEED) { 3529d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 3530d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "OK"; 3531d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2u, GetSuccessfulPartCount()); 3532d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3533d201456903f3ecae1f7794edfab0d5678e64226shiqian 3534d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_*. 3535d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT) { 3536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true); 3537d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 3538d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3539d201456903f3ecae1f7794edfab0d5678e64226shiqian 3540d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_STR*. 3541d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT_STR) { 3542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", ""); 3543d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 3544d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3545d201456903f3ecae1f7794edfab0d5678e64226shiqian 3546d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_*. 3547d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT) { 3548d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 3549d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 3550d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3551d201456903f3ecae1f7794edfab0d5678e64226shiqian 3552d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_STR*. 3553d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT_STR) { 3554d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("", ""); 3555d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 3556d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3557d201456903f3ecae1f7794edfab0d5678e64226shiqian 3558d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 3559d201456903f3ecae1f7794edfab0d5678e64226shiqian 3560d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 3561d201456903f3ecae1f7794edfab0d5678e64226shiqian 3562d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_TRUE. 3563d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_TRUE) { 3564d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(2 > 1); // NOLINT 3565d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 3566d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 < 1\n" 3567d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: false\n" 3568d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: true"); 3569d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 3570d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 > 3"); 3571d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3572d201456903f3ecae1f7794edfab0d5678e64226shiqian 3573d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_FALSE. 3574d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_FALSE) { 3575d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(2 < 1); // NOLINT 3576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 3577d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3578d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3579d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3580d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 3581d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 3"); 3582d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3583d201456903f3ecae1f7794edfab0d5678e64226shiqian 3584c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3585c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3586c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 3587c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3588c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3589d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ. 3590d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ) { 3591d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, 2 + 3); 3592d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 3593d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3594d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3595d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3596d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 3597d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 - 3"); 3598d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3599d201456903f3ecae1f7794edfab0d5678e64226shiqian 3600d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using EXPECT_EQ on double values. The purpose is to make 3601d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3602d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3603d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_Double) { 3604d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3605d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5.6, 5.6); 3606d201456903f3ecae1f7794edfab0d5678e64226shiqian 3607d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3608d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 3609d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3610d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3611d201456903f3ecae1f7794edfab0d5678e64226shiqian 36120af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3613d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(NULL, pointer). 3614d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_NULL) { 3615d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3616d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3617d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, p); 3618d201456903f3ecae1f7794edfab0d5678e64226shiqian 3619d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3620d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3621d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 3622d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3623d201456903f3ecae1f7794edfab0d5678e64226shiqian} 36240af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3625d201456903f3ecae1f7794edfab0d5678e64226shiqian 3626d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 3627d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3628d201456903f3ecae1f7794edfab0d5678e64226shiqian// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 3629d201456903f3ecae1f7794edfab0d5678e64226shiqian// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 3630d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_0) { 3631d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3632d201456903f3ecae1f7794edfab0d5678e64226shiqian 3633d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3634d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, n); 3635d201456903f3ecae1f7794edfab0d5678e64226shiqian 3636d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3637d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 3638d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3639d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3640d201456903f3ecae1f7794edfab0d5678e64226shiqian 3641d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NE. 3642d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_NE) { 3643d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(6, 7); 3644d201456903f3ecae1f7794edfab0d5678e64226shiqian 3645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 3646d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3647d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3648d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 3649d201456903f3ecae1f7794edfab0d5678e64226shiqian "2"); 3650d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 3651d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 3652d201456903f3ecae1f7794edfab0d5678e64226shiqian "p0"); 3653d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 3654d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 3655d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 3656d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 3657d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 3658d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 3659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 3660d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 3661d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3662d201456903f3ecae1f7794edfab0d5678e64226shiqian 3663d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LE. 3664d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LE) { 3665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 3); 3666d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 2); 3667d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 3668d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 3670d201456903f3ecae1f7794edfab0d5678e64226shiqian "(1.1) <= (0.9)"); 3671d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3672d201456903f3ecae1f7794edfab0d5678e64226shiqian 3673d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LT. 3674d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LT) { 3675d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(2, 3); 3676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 3677d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3678d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 3679d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) < (1)"); 3680d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3681d201456903f3ecae1f7794edfab0d5678e64226shiqian 3682d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GE. 3683d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GE) { 3684d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 1); 3685d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 2); 3686d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 3687d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3688d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 3689d201456903f3ecae1f7794edfab0d5678e64226shiqian "(0.9) >= (1.1)"); 3690d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3691d201456903f3ecae1f7794edfab0d5678e64226shiqian 3692d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GT. 3693d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GT) { 3694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(2, 1); 3695d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 3696d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3697d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 3698d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) > (3)"); 3699d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3700d201456903f3ecae1f7794edfab0d5678e64226shiqian 370136865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 370236865d8d354465e3461eedf2949a4b7799985d5dshiqian 370336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_THROW. 370436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_THROW) { 370536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 370636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 3707886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of " 370836865d8d354465e3461eedf2949a4b7799985d5dshiqian "type bool.\n Actual: it throws a different type."); 3709886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 3710886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool), 3711886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3712886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 371336865d8d354465e3461eedf2949a4b7799985d5dshiqian} 371436865d8d354465e3461eedf2949a4b7799985d5dshiqian 371536865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_NO_THROW. 371636865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_NO_THROW) { 3717886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 371836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 3719886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an " 372036865d8d354465e3461eedf2949a4b7799985d5dshiqian "exception.\n Actual: it throws."); 372136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 372236865d8d354465e3461eedf2949a4b7799985d5dshiqian 372336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_ANY_THROW. 372436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_ANY_THROW) { 372536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 3726886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 3727886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()), 3728886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3729886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 373036865d8d354465e3461eedf2949a4b7799985d5dshiqian} 373136865d8d354465e3461eedf2949a4b7799985d5dshiqian 373236865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 373336865d8d354465e3461eedf2949a4b7799985d5dshiqian 3734d201456903f3ecae1f7794edfab0d5678e64226shiqian// Make sure we deal with the precedence of <<. 3735d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ExpectPrecedence) { 3736d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1 < 2, true); 3737d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 3738d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true && false"); 3739d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3740d201456903f3ecae1f7794edfab0d5678e64226shiqian 3741d201456903f3ecae1f7794edfab0d5678e64226shiqian 3742d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the StreamableToString() function. 3743d201456903f3ecae1f7794edfab0d5678e64226shiqian 3744d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a scalar. 3745d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Scalar) { 3746d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("5", StreamableToString(5).c_str()); 3747d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3748d201456903f3ecae1f7794edfab0d5678e64226shiqian 3749d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a non-char pointer. 3750d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Pointer) { 3751d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3752d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = &n; 3753d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 3754d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3755d201456903f3ecae1f7794edfab0d5678e64226shiqian 3756d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL non-char pointer. 3757d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullPointer) { 3758d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = NULL; 3759d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 3760d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3761d201456903f3ecae1f7794edfab0d5678e64226shiqian 3762d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a C string. 3763d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, CString) { 3764d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 3765d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3766d201456903f3ecae1f7794edfab0d5678e64226shiqian 3767d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL C string. 3768d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullCString) { 3769d201456903f3ecae1f7794edfab0d5678e64226shiqian char* p = NULL; 3770d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 3771d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3772d201456903f3ecae1f7794edfab0d5678e64226shiqian 3773d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using streamable values as assertion messages. 3774d201456903f3ecae1f7794edfab0d5678e64226shiqian 3775d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 3776d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using std::string as an assertion message. 3777d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, string) { 3778d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string str( 3779d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure message is a std::string, and is expected."); 3780d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << str, 3781d201456903f3ecae1f7794edfab0d5678e64226shiqian str.c_str()); 3782d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3783d201456903f3ecae1f7794edfab0d5678e64226shiqian 3784d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output strings containing embedded NULs. 3785d201456903f3ecae1f7794edfab0d5678e64226shiqian// Limited to Linux because we can only do this with std::string's. 3786d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, stringWithEmbeddedNUL) { 3787d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char char_array_with_nul[] = 3788d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\0 and some more string"; 3789d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string string_with_nul(char_array_with_nul, 3790d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(char_array_with_nul) 3791d201456903f3ecae1f7794edfab0d5678e64226shiqian - 1); // drops the trailing NUL 3792d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 3793d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\\0 and some more string"); 3794d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3795d201456903f3ecae1f7794edfab0d5678e64226shiqian 3796d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 3797d201456903f3ecae1f7794edfab0d5678e64226shiqian 3798d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output a NUL char. 3799d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NULChar) { 3800d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3801d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "A NUL" << '\0' << " and some more string"; 3802d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "A NUL\\0 and some more string"); 3803d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3804d201456903f3ecae1f7794edfab0d5678e64226shiqian 3805d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int as an assertion message. 3806d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, int) { 3807d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << 900913, 3808d201456903f3ecae1f7794edfab0d5678e64226shiqian "900913"); 3809d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3810d201456903f3ecae1f7794edfab0d5678e64226shiqian 3811d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using NULL char pointer as an assertion message. 3812d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3813d201456903f3ecae1f7794edfab0d5678e64226shiqian// In MSVC, streaming a NULL char * causes access violation. Google Test 3814d201456903f3ecae1f7794edfab0d5678e64226shiqian// implemented a workaround (substituting "(null)" for NULL). This 3815d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests whether the workaround works. 3816d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NullCharPtr) { 3817d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 3818d201456903f3ecae1f7794edfab0d5678e64226shiqian "(null)"); 3819d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3820d201456903f3ecae1f7794edfab0d5678e64226shiqian 3821d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that basic IO manipulators (endl, ends, and flush) can be 3822d201456903f3ecae1f7794edfab0d5678e64226shiqian// streamed to testing::Message. 3823d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, BasicIoManip) { 3824d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3825d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Line 1." << std::endl 3826d201456903f3ecae1f7794edfab0d5678e64226shiqian << "A NUL char " << std::ends << std::flush << " in line 2."; 3827d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Line 1.\nA NUL char \\0 in line 2."); 3828d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3829d201456903f3ecae1f7794edfab0d5678e64226shiqian 3830d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the macros that haven't been covered so far. 3831d201456903f3ecae1f7794edfab0d5678e64226shiqian 3832d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AddFailureHelper(bool* aborted) { 3833d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 3834d201456903f3ecae1f7794edfab0d5678e64226shiqian ADD_FAILURE() << "Failure"; 3835d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 3836d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3837d201456903f3ecae1f7794edfab0d5678e64226shiqian 3838d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ADD_FAILURE. 3839d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, ADD_FAILURE) { 3840d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 3841d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 3842d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failure"); 3843d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 3844d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3845d201456903f3ecae1f7794edfab0d5678e64226shiqian 3846d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests FAIL. 3847d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, FAIL) { 3848d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL(), 3849d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failed"); 3850d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 3851d201456903f3ecae1f7794edfab0d5678e64226shiqian "Intentional failure."); 3852d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3853d201456903f3ecae1f7794edfab0d5678e64226shiqian 3854d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests SUCCEED 3855d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, SUCCEED) { 3856d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 3857d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "Explicit success."; 3858d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3859d201456903f3ecae1f7794edfab0d5678e64226shiqian 3860d201456903f3ecae1f7794edfab0d5678e64226shiqian 3861d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for EXPECT_EQ() and ASSERT_EQ(). 3862d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3863d201456903f3ecae1f7794edfab0d5678e64226shiqian// These tests fail *intentionally*, s.t. the failure messages can be 3864d201456903f3ecae1f7794edfab0d5678e64226shiqian// generated and tested. 3865d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3866d201456903f3ecae1f7794edfab0d5678e64226shiqian// We have different tests for different argument types. 3867d201456903f3ecae1f7794edfab0d5678e64226shiqian 3868d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using bool values in {EXPECT|ASSERT}_EQ. 3869d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Bool) { 3870d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(true, true); 3871d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(false, true), 3872d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true"); 3873d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3874d201456903f3ecae1f7794edfab0d5678e64226shiqian 3875d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int values in {EXPECT|ASSERT}_EQ. 3876d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Int) { 3877d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(32, 32); 3878d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 3879d201456903f3ecae1f7794edfab0d5678e64226shiqian "33"); 3880d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3881d201456903f3ecae1f7794edfab0d5678e64226shiqian 3882d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using time_t values in {EXPECT|ASSERT}_EQ. 3883d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Time_T) { 3884d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<time_t>(0), 3885d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(0)); 3886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 3887d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(1234)), 3888d201456903f3ecae1f7794edfab0d5678e64226shiqian "1234"); 3889d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3890d201456903f3ecae1f7794edfab0d5678e64226shiqian 3891d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char values in {EXPECT|ASSERT}_EQ. 3892d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Char) { 3893d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ('z', 'z'); 3894d201456903f3ecae1f7794edfab0d5678e64226shiqian const char ch = 'b'; 3895d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 3896d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 3897d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 3898d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 3899d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3900d201456903f3ecae1f7794edfab0d5678e64226shiqian 3901d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 3902d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideChar) { 3903d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L'b', L'b'); 3904d201456903f3ecae1f7794edfab0d5678e64226shiqian 3905d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 3906d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: L'x'\n" 3907d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L'x' (120, 0x78)\n" 3908d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: L'\0'\n" 3909d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L'\0' (0, 0x0)"); 3910d201456903f3ecae1f7794edfab0d5678e64226shiqian 3911d201456903f3ecae1f7794edfab0d5678e64226shiqian static wchar_t wchar; 3912d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'b'; 3913d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 3914d201456903f3ecae1f7794edfab0d5678e64226shiqian "wchar"); 3915d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'\x8119'; 3916d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(L'\x8120', wchar), 3917d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: wchar"); 3918d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3919d201456903f3ecae1f7794edfab0d5678e64226shiqian 3920d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 3921d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 3922d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdString) { 3923d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has identical 3924d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3925d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ("Test", ::std::string("Test")); 3926d201456903f3ecae1f7794edfab0d5678e64226shiqian 3927d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::strings. 3928d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str1("A * in the middle"); 3929d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str2(str1); 3930d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(str1, str2); 3931d201456903f3ecae1f7794edfab0d5678e64226shiqian 3932d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has different 3933d201456903f3ecae1f7794edfab0d5678e64226shiqian // content 3934d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 3935d201456903f3ecae1f7794edfab0d5678e64226shiqian "::std::string(\"test\")"); 3936d201456903f3ecae1f7794edfab0d5678e64226shiqian 3937d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::string to a char* that has different content. 3938d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = const_cast<char*>("foo"); 3939d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 3940d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 3941d201456903f3ecae1f7794edfab0d5678e64226shiqian 3942d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::strings that have different contents, one of 3943d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. This should fail. 3944d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::std::string str3(str1); 3945d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 3946d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 3947d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: str3\n" 3948d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"A \\0 in the middle\""); 3949d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3950d201456903f3ecae1f7794edfab0d5678e64226shiqian 3951d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 3952d201456903f3ecae1f7794edfab0d5678e64226shiqian 3953d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 3954d201456903f3ecae1f7794edfab0d5678e64226shiqian 3955d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 3956d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdWideString) { 3957d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has identical 3958d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3959d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8119"); 3960d201456903f3ecae1f7794edfab0d5678e64226shiqian 3961d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::wstrings. 3962d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr1(L"A * in the middle"); 3963d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr2(wstr1); 3964d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(wstr1, wstr2); 3965d201456903f3ecae1f7794edfab0d5678e64226shiqian 3966d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has different 3967d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3968d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3969d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8120"); 3970d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "L\"Test\\x8120\""); 3971d201456903f3ecae1f7794edfab0d5678e64226shiqian 3972d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::wstrings that have different contents, one of 3973d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. 3974d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring wstr3(wstr1); 3975d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 3976d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 3977d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 3978d201456903f3ecae1f7794edfab0d5678e64226shiqian 3979d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to an std::wstring that has different 3980d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3981d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3982d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 3983d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 3984d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3985d201456903f3ecae1f7794edfab0d5678e64226shiqian 3986d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 3987d201456903f3ecae1f7794edfab0d5678e64226shiqian 3988d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 3989d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::string values in {EXPECT|ASSERT}_EQ. 3990d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalString) { 3991d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to a ::string that has identical content. 3992d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ("Test", ::string("Test")); 3993d201456903f3ecae1f7794edfab0d5678e64226shiqian 3994d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::strings. 3995d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str1("A * in the middle"); 3996d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str2(str1); 3997d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(str1, str2); 3998d201456903f3ecae1f7794edfab0d5678e64226shiqian 3999d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a const char* that has different content. 4000d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 4001d201456903f3ecae1f7794edfab0d5678e64226shiqian "test"); 4002d201456903f3ecae1f7794edfab0d5678e64226shiqian 4003d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::strings that have different contents, one of which 4004d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4005d201456903f3ecae1f7794edfab0d5678e64226shiqian ::string str3(str1); 4006d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4007d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 4008d201456903f3ecae1f7794edfab0d5678e64226shiqian "str3"); 4009d201456903f3ecae1f7794edfab0d5678e64226shiqian 4010d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a char* that has different content. 4011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4012d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 4013d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4014d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4015d201456903f3ecae1f7794edfab0d5678e64226shiqian 4016d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 4017d201456903f3ecae1f7794edfab0d5678e64226shiqian 4018d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_WSTRING 4019d201456903f3ecae1f7794edfab0d5678e64226shiqian 4020d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 4021d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalWideString) { 4022d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has identical content. 4023d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(L"Test\x8119", ::wstring(L"Test\x8119")); 4024d201456903f3ecae1f7794edfab0d5678e64226shiqian 4025d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::wstrings. 4026d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr1(L"A * in the middle"); 4027d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr2(wstr1); 4028d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(wstr1, wstr2); 4029d201456903f3ecae1f7794edfab0d5678e64226shiqian 4030d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has different 4031d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4032d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4033d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L"Test\x8120", ::wstring(L"Test\x8119")); 4034d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Test\\x8119"); 4035d201456903f3ecae1f7794edfab0d5678e64226shiqian 4036d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to a ::wstring that has different content. 4037d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 4038d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 4039d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar"); 4040d201456903f3ecae1f7794edfab0d5678e64226shiqian 4041d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::wstrings that have different contents, one of which 4042d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4043d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::wstring wstr3; 4044d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3 = wstr1; 4045d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 4047d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4048d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4049d201456903f3ecae1f7794edfab0d5678e64226shiqian 4050d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 4051d201456903f3ecae1f7794edfab0d5678e64226shiqian 4052d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char pointers in {EXPECT|ASSERT}_EQ. 4053d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, CharPointer) { 4054d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4055d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4056d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4057d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4058d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4059d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4060d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4061d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4062d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p2 = reinterpret_cast<char*>(pv2); 4063d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(p1, p1); 4064d201456903f3ecae1f7794edfab0d5678e64226shiqian 4065d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4066d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4067d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4068d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4069d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 4070d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<char*>(0xABC0)), 4071d201456903f3ecae1f7794edfab0d5678e64226shiqian "ABC0"); 4072d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4073d201456903f3ecae1f7794edfab0d5678e64226shiqian 4074d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 4075d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideCharPointer) { 4076d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p0 = NULL; 4077d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4078d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4079d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4080d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4081d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4082d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4083d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 4084d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 4085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(p0, p0); 4086d201456903f3ecae1f7794edfab0d5678e64226shiqian 4087d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4088d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4089d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4090d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4091d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv3 = (void*)0x1234; // NOLINT 4092d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv4 = (void*)0xABC0; // NOLINT 4093d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 4094d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 4095d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 4096d201456903f3ecae1f7794edfab0d5678e64226shiqian "p4"); 4097d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4098d201456903f3ecae1f7794edfab0d5678e64226shiqian 4099d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 4100d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, OtherPointer) { 4101d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(static_cast<const int*>(NULL), 4102d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<const int*>(NULL)); 4103d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 4104d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<const int*>(0x1234)), 4105d201456903f3ecae1f7794edfab0d5678e64226shiqian "0x1234"); 4106d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4107d201456903f3ecae1f7794edfab0d5678e64226shiqian 4108d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the FRIEND_TEST macro. 4109d201456903f3ecae1f7794edfab0d5678e64226shiqian 4110d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class has a private member we want to test. We will test it 4111d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a TEST and in a TEST_F. 4112d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Foo { 4113d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4114d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo() {} 4115d201456903f3ecae1f7794edfab0d5678e64226shiqian 4116d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4117d201456903f3ecae1f7794edfab0d5678e64226shiqian int Bar() const { return 1; } 4118d201456903f3ecae1f7794edfab0d5678e64226shiqian 4119d201456903f3ecae1f7794edfab0d5678e64226shiqian // Declares the friend tests that can access the private member 4120d201456903f3ecae1f7794edfab0d5678e64226shiqian // Bar(). 4121d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test, TEST); 4122d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 4123d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4124d201456903f3ecae1f7794edfab0d5678e64226shiqian 4125d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST to access a 4126d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4127d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(FRIEND_TEST_Test, TEST) { 4128d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, Foo().Bar()); 4129d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4130d201456903f3ecae1f7794edfab0d5678e64226shiqian 4131d201456903f3ecae1f7794edfab0d5678e64226shiqian// The fixture needed to test using FRIEND_TEST with TEST_F. 41329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FRIEND_TEST_Test2 : public Test { 4133d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4134d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo foo; 4135d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4136d201456903f3ecae1f7794edfab0d5678e64226shiqian 4137d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 4138d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 4139d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FRIEND_TEST_Test2, TEST_F) { 4140d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, foo.Bar()); 4141d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4142d201456903f3ecae1f7794edfab0d5678e64226shiqian 4143d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of Test objects. 4144d201456903f3ecae1f7794edfab0d5678e64226shiqian 4145d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing the life cycle of Test objects. 4146d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4147d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class counts the number of live test objects that uses this 4148d201456903f3ecae1f7794edfab0d5678e64226shiqian// fixture. 41499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestLifeCycleTest : public Test { 4150d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4151d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructor. Increments the number of test objects that uses 4152d201456903f3ecae1f7794edfab0d5678e64226shiqian // this fixture. 4153d201456903f3ecae1f7794edfab0d5678e64226shiqian TestLifeCycleTest() { count_++; } 4154d201456903f3ecae1f7794edfab0d5678e64226shiqian 4155d201456903f3ecae1f7794edfab0d5678e64226shiqian // Destructor. Decrements the number of test objects that uses this 4156d201456903f3ecae1f7794edfab0d5678e64226shiqian // fixture. 4157d201456903f3ecae1f7794edfab0d5678e64226shiqian ~TestLifeCycleTest() { count_--; } 4158d201456903f3ecae1f7794edfab0d5678e64226shiqian 4159d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the number of live test objects that uses this fixture. 4160d201456903f3ecae1f7794edfab0d5678e64226shiqian int count() const { return count_; } 4161d201456903f3ecae1f7794edfab0d5678e64226shiqian 4162d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4163d201456903f3ecae1f7794edfab0d5678e64226shiqian static int count_; 4164d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4165d201456903f3ecae1f7794edfab0d5678e64226shiqian 4166d201456903f3ecae1f7794edfab0d5678e64226shiqianint TestLifeCycleTest::count_ = 0; 4167d201456903f3ecae1f7794edfab0d5678e64226shiqian 4168d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4169d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test1) { 4170d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be only one test object in this test case that's 4171d201456903f3ecae1f7794edfab0d5678e64226shiqian // currently alive. 4172d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4173d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4174d201456903f3ecae1f7794edfab0d5678e64226shiqian 4175d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 4176d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test2) { 4177d201456903f3ecae1f7794edfab0d5678e64226shiqian // After Test1 is done and Test2 is started, there should still be 4178d201456903f3ecae1f7794edfab0d5678e64226shiqian // only one live test object, as the object for Test1 should've been 4179d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 4180d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 4181d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4182d201456903f3ecae1f7794edfab0d5678e64226shiqian 4183d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4184d201456903f3ecae1f7794edfab0d5678e64226shiqian 4185d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator << are 4186d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in the global namespace. 4187d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Base { 4188d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4189d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Base(int x) : x_(x) {} 4190d201456903f3ecae1f7794edfab0d5678e64226shiqian int x() const { return x_; } 4191d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4192d201456903f3ecae1f7794edfab0d5678e64226shiqian int x_; 4193d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4194d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4195d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base& val) { 4196d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4197d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4198d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4199d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base* pointer) { 4200d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4201d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4202d201456903f3ecae1f7794edfab0d5678e64226shiqian 4203d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 42049b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4205d201456903f3ecae1f7794edfab0d5678e64226shiqian Base a(1); 4206d201456903f3ecae1f7794edfab0d5678e64226shiqian 4207d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 4208d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4209d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4210d201456903f3ecae1f7794edfab0d5678e64226shiqian 4211d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4212d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in an unnamed namespace. 4213d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 4214d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInUnnamedNameSpace : public Base { 4215d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4216d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInUnnamedNameSpace(int x): Base(x) {} 4217d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4218d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4219d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace& val) { 4220d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4221d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4222d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4223d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace* pointer) { 4224d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4225d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4226d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4227d201456903f3ecae1f7794edfab0d5678e64226shiqian 4228d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 42299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4230d201456903f3ecae1f7794edfab0d5678e64226shiqian MyTypeInUnnamedNameSpace a(1); 4231d201456903f3ecae1f7794edfab0d5678e64226shiqian 4232d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses <unnamed_namespace>::operator<<. 4233d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4234d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4235d201456903f3ecae1f7794edfab0d5678e64226shiqian 4236d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 4237d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a user namespace. 4238d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace1 { 4239d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace1 : public Base { 4240d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4241d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace1(int x): Base(x) {} 4242d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4243d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4244d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1& val) { 4245d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4246d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4247d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4248d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1* pointer) { 4249d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4250d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4251d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace1 4252d201456903f3ecae1f7794edfab0d5678e64226shiqian 4253d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 42549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4255d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace1::MyTypeInNameSpace1 a(1); 4256d201456903f3ecae1f7794edfab0d5678e64226shiqian 4257d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses namespace1::operator<<. 4258d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4259d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4260d201456903f3ecae1f7794edfab0d5678e64226shiqian 4261d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition is in a user namespace 4262d201456903f3ecae1f7794edfab0d5678e64226shiqian// but whose operator<< is in the global namespace. 4263d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace2 { 4264d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace2 : public ::Base { 4265d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4266d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace2(int x): Base(x) {} 4267d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4268d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace2 4269d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4270d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2& val) { 4271d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 4272d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4273d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 4274d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2* pointer) { 4275d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 4276d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4277d201456903f3ecae1f7794edfab0d5678e64226shiqian 4278d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 42799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4280d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace2::MyTypeInNameSpace2 a(1); 4281d201456903f3ecae1f7794edfab0d5678e64226shiqian 4282d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 4283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 4284d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4285d201456903f3ecae1f7794edfab0d5678e64226shiqian 4286d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming NULL pointers to testing::Message. 4287d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, NullPointers) { 42889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 4289d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = NULL; 4290d201456903f3ecae1f7794edfab0d5678e64226shiqian unsigned char* const p2 = NULL; 4291d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p3 = NULL; 4292d201456903f3ecae1f7794edfab0d5678e64226shiqian double* p4 = NULL; 4293d201456903f3ecae1f7794edfab0d5678e64226shiqian bool* p5 = NULL; 42949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message* p6 = NULL; 4295d201456903f3ecae1f7794edfab0d5678e64226shiqian 4296d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << p1 << p2 << p3 << p4 << p5 << p6; 4297d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 4298d201456903f3ecae1f7794edfab0d5678e64226shiqian msg.GetString().c_str()); 4299d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4300d201456903f3ecae1f7794edfab0d5678e64226shiqian 4301d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming wide strings to testing::Message. 4302d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, WideStrings) { 4303d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type const wchar_t*. 4304d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* const_wstr = NULL; 4305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 4306d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 4307d201456903f3ecae1f7794edfab0d5678e64226shiqian 4308d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type wchar_t*. 4309d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* wstr = NULL; 4310d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 4311d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 4312d201456903f3ecae1f7794edfab0d5678e64226shiqian 4313d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type const wchar_t*. 4314d201456903f3ecae1f7794edfab0d5678e64226shiqian const_wstr = L"abc\x8119"; 4315d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 4316d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 4317d201456903f3ecae1f7794edfab0d5678e64226shiqian 4318d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type wchar_t*. 4319d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr = const_cast<wchar_t*>(const_wstr); 4320d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 4321d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 4322d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4323d201456903f3ecae1f7794edfab0d5678e64226shiqian 4324d201456903f3ecae1f7794edfab0d5678e64226shiqian 4325d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in the testing namespace. 4326d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 4327d201456903f3ecae1f7794edfab0d5678e64226shiqian 4328d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestInfo class. 4329d201456903f3ecae1f7794edfab0d5678e64226shiqian 43309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestInfoTest : public Test { 4331d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4332d201456903f3ecae1f7794edfab0d5678e64226shiqian static TestInfo * GetTestInfo(const char* test_name) { 4333d201456903f3ecae1f7794edfab0d5678e64226shiqian return UnitTest::GetInstance()->impl()-> 4334a2b1a8556ea64014606d78b09333d9c522430a25shiqian GetTestCase("TestInfoTest", "", NULL, NULL)-> 4335d201456903f3ecae1f7794edfab0d5678e64226shiqian GetTestInfo(test_name); 4336d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4337d201456903f3ecae1f7794edfab0d5678e64226shiqian 4338d201456903f3ecae1f7794edfab0d5678e64226shiqian static const TestResult* GetTestResult( 43399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const TestInfo* test_info) { 4340d201456903f3ecae1f7794edfab0d5678e64226shiqian return test_info->result(); 4341d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4342d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4343d201456903f3ecae1f7794edfab0d5678e64226shiqian 4344d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::test_case_name() and TestInfo::name(). 4345d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, Names) { 4346d201456903f3ecae1f7794edfab0d5678e64226shiqian TestInfo * const test_info = GetTestInfo("Names"); 4347d201456903f3ecae1f7794edfab0d5678e64226shiqian 4348d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 4349d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("Names", test_info->name()); 4350d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4351d201456903f3ecae1f7794edfab0d5678e64226shiqian 4352d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::result(). 4353d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, result) { 4354d201456903f3ecae1f7794edfab0d5678e64226shiqian TestInfo * const test_info = GetTestInfo("result"); 4355d201456903f3ecae1f7794edfab0d5678e64226shiqian 4356d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initially, there is no TestPartResult for this test. 4357d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, GetTestResult(test_info)->total_part_count()); 4358d201456903f3ecae1f7794edfab0d5678e64226shiqian 4359d201456903f3ecae1f7794edfab0d5678e64226shiqian // After the previous assertion, there is still none. 4360d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, GetTestResult(test_info)->total_part_count()); 4361d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4362d201456903f3ecae1f7794edfab0d5678e64226shiqian 4363d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests setting up and tearing down a test case. 4364d201456903f3ecae1f7794edfab0d5678e64226shiqian 43659b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SetUpTestCaseTest : public Test { 4366d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4367d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once before the first test in this test case 4368d201456903f3ecae1f7794edfab0d5678e64226shiqian // is run. 4369d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 4370d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Setting up the test case . . .\n"); 4371d201456903f3ecae1f7794edfab0d5678e64226shiqian 4372d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initializes some shared resource. In this simple example, we 4373d201456903f3ecae1f7794edfab0d5678e64226shiqian // just create a C string. More complex stuff can be done if 4374d201456903f3ecae1f7794edfab0d5678e64226shiqian // desired. 4375d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = "123"; 4376d201456903f3ecae1f7794edfab0d5678e64226shiqian 4377d201456903f3ecae1f7794edfab0d5678e64226shiqian // Increments the number of test cases that have been set up. 4378d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_++; 4379d201456903f3ecae1f7794edfab0d5678e64226shiqian 4380d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once. 4381d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 4382d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4383d201456903f3ecae1f7794edfab0d5678e64226shiqian 4384d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once after the last test in this test case is 4385d201456903f3ecae1f7794edfab0d5678e64226shiqian // run. 4386d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 4387d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Tearing down the test case . . .\n"); 4388d201456903f3ecae1f7794edfab0d5678e64226shiqian 4389d201456903f3ecae1f7794edfab0d5678e64226shiqian // Decrements the number of test cases that have been set up. 4390d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_--; 4391d201456903f3ecae1f7794edfab0d5678e64226shiqian 4392d201456903f3ecae1f7794edfab0d5678e64226shiqian // TearDownTestCase() should be called only once. 4393d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, counter_); 4394d201456903f3ecae1f7794edfab0d5678e64226shiqian 4395d201456903f3ecae1f7794edfab0d5678e64226shiqian // Cleans up the shared resource. 4396d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = NULL; 4397d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4398d201456903f3ecae1f7794edfab0d5678e64226shiqian 4399d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called before each test in this test case. 4400d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 4401d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once, so counter_ should 4402d201456903f3ecae1f7794edfab0d5678e64226shiqian // always be 1. 4403d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 4404d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4405d201456903f3ecae1f7794edfab0d5678e64226shiqian 4406d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of test cases that have been set up. 4407d201456903f3ecae1f7794edfab0d5678e64226shiqian static int counter_; 4408d201456903f3ecae1f7794edfab0d5678e64226shiqian 4409d201456903f3ecae1f7794edfab0d5678e64226shiqian // Some resource to be shared by all tests in this test case. 4410d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* shared_resource_; 4411d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4412d201456903f3ecae1f7794edfab0d5678e64226shiqian 4413d201456903f3ecae1f7794edfab0d5678e64226shiqianint SetUpTestCaseTest::counter_ = 0; 4414d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SetUpTestCaseTest::shared_resource_ = NULL; 4415d201456903f3ecae1f7794edfab0d5678e64226shiqian 4416d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test that uses the shared resource. 4417d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test1) { 4418d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(NULL, shared_resource_); 4419d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4420d201456903f3ecae1f7794edfab0d5678e64226shiqian 4421d201456903f3ecae1f7794edfab0d5678e64226shiqian// Another test that uses the shared resource. 4422d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test2) { 4423d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("123", shared_resource_); 4424d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4425d201456903f3ecae1f7794edfab0d5678e64226shiqian 4426d201456903f3ecae1f7794edfab0d5678e64226shiqian// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 4427d201456903f3ecae1f7794edfab0d5678e64226shiqian 4428d201456903f3ecae1f7794edfab0d5678e64226shiqian// The Flags struct stores a copy of all Google Test flags. 4429d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct Flags { 4430d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs a Flags struct where each flag has its default value. 4431fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags() : also_run_disabled_tests(false), 4432fe186c382905dcf57014985ccea8e067275e9f5fshiqian break_on_failure(false), 4433d201456903f3ecae1f7794edfab0d5678e64226shiqian catch_exceptions(false), 443453e0dc4041f660b6517b15b08b496e164be614f1shiqian death_test_use_fork(false), 4435d201456903f3ecae1f7794edfab0d5678e64226shiqian filter(""), 4436d201456903f3ecae1f7794edfab0d5678e64226shiqian list_tests(false), 4437d201456903f3ecae1f7794edfab0d5678e64226shiqian output(""), 4438f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan print_time(true), 443940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan repeat(1), 444040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan throw_on_failure(false) {} 4441d201456903f3ecae1f7794edfab0d5678e64226shiqian 4442d201456903f3ecae1f7794edfab0d5678e64226shiqian // Factory methods. 4443d201456903f3ecae1f7794edfab0d5678e64226shiqian 4444fe186c382905dcf57014985ccea8e067275e9f5fshiqian // Creates a Flags struct where the gtest_also_run_disabled_tests flag has 4445fe186c382905dcf57014985ccea8e067275e9f5fshiqian // the given value. 4446fe186c382905dcf57014985ccea8e067275e9f5fshiqian static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { 4447fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags flags; 4448fe186c382905dcf57014985ccea8e067275e9f5fshiqian flags.also_run_disabled_tests = also_run_disabled_tests; 4449fe186c382905dcf57014985ccea8e067275e9f5fshiqian return flags; 4450fe186c382905dcf57014985ccea8e067275e9f5fshiqian } 4451fe186c382905dcf57014985ccea8e067275e9f5fshiqian 4452d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_break_on_failure flag has 4453d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 4454d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags BreakOnFailure(bool break_on_failure) { 4455d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4456d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = break_on_failure; 4457d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4458d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4459d201456903f3ecae1f7794edfab0d5678e64226shiqian 4460d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_catch_exceptions flag has 4461d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 4462d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags CatchExceptions(bool catch_exceptions) { 4463d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4464d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.catch_exceptions = catch_exceptions; 4465d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4466d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4467d201456903f3ecae1f7794edfab0d5678e64226shiqian 446853e0dc4041f660b6517b15b08b496e164be614f1shiqian // Creates a Flags struct where the gtest_death_test_use_fork flag has 446953e0dc4041f660b6517b15b08b496e164be614f1shiqian // the given value. 447053e0dc4041f660b6517b15b08b496e164be614f1shiqian static Flags DeathTestUseFork(bool death_test_use_fork) { 447153e0dc4041f660b6517b15b08b496e164be614f1shiqian Flags flags; 447253e0dc4041f660b6517b15b08b496e164be614f1shiqian flags.death_test_use_fork = death_test_use_fork; 447353e0dc4041f660b6517b15b08b496e164be614f1shiqian return flags; 447453e0dc4041f660b6517b15b08b496e164be614f1shiqian } 447553e0dc4041f660b6517b15b08b496e164be614f1shiqian 4476d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_filter flag has the given 4477d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4478d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Filter(const char* filter) { 4479d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4480d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = filter; 4481d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4482d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4483d201456903f3ecae1f7794edfab0d5678e64226shiqian 4484d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_list_tests flag has the 4485d201456903f3ecae1f7794edfab0d5678e64226shiqian // given value. 4486d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags ListTests(bool list_tests) { 4487d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4488d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.list_tests = list_tests; 4489d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4490d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4491d201456903f3ecae1f7794edfab0d5678e64226shiqian 4492d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_output flag has the given 4493d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4494d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Output(const char* output) { 4495d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4496d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.output = output; 4497d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4498d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4499d201456903f3ecae1f7794edfab0d5678e64226shiqian 450015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // Creates a Flags struct where the gtest_print_time flag has the given 450115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // value. 450215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian static Flags PrintTime(bool print_time) { 450315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian Flags flags; 450415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian flags.print_time = print_time; 450515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian return flags; 450615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian } 450715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 4508d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_repeat flag has the given 4509d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 4510d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Repeat(Int32 repeat) { 4511d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4512d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.repeat = repeat; 4513d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 4514d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4515d201456903f3ecae1f7794edfab0d5678e64226shiqian 451640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // Creates a Flags struct where the gtest_throw_on_failure flag has 451740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // the given value. 451840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan static Flags ThrowOnFailure(bool throw_on_failure) { 451940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan Flags flags; 452040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan flags.throw_on_failure = throw_on_failure; 452140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan return flags; 452240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan } 452340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 4524d201456903f3ecae1f7794edfab0d5678e64226shiqian // These fields store the flag values. 4525fe186c382905dcf57014985ccea8e067275e9f5fshiqian bool also_run_disabled_tests; 4526d201456903f3ecae1f7794edfab0d5678e64226shiqian bool break_on_failure; 4527d201456903f3ecae1f7794edfab0d5678e64226shiqian bool catch_exceptions; 452853e0dc4041f660b6517b15b08b496e164be614f1shiqian bool death_test_use_fork; 4529d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* filter; 4530d201456903f3ecae1f7794edfab0d5678e64226shiqian bool list_tests; 4531d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* output; 453215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian bool print_time; 4533d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 repeat; 453440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan bool throw_on_failure; 4535d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4536d201456903f3ecae1f7794edfab0d5678e64226shiqian 4537d201456903f3ecae1f7794edfab0d5678e64226shiqian// Fixture for testing InitGoogleTest(). 45389b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass InitGoogleTestTest : public Test { 4539d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4540d201456903f3ecae1f7794edfab0d5678e64226shiqian // Clears the flags before each test. 4541d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 4542fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 4543d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(break_on_failure) = false; 4544d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(catch_exceptions) = false; 454553e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 4546d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(filter) = ""; 4547d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(list_tests) = false; 4548d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(output) = ""; 4549f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 4550d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(repeat) = 1; 455140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 4552d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4553d201456903f3ecae1f7794edfab0d5678e64226shiqian 4554d201456903f3ecae1f7794edfab0d5678e64226shiqian // Asserts that two narrow or wide string arrays are equal. 4555d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 4556d201456903f3ecae1f7794edfab0d5678e64226shiqian static void AssertStringArrayEq(size_t size1, CharType** array1, 4557d201456903f3ecae1f7794edfab0d5678e64226shiqian size_t size2, CharType** array2) { 4558d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(size1, size2) << " Array sizes different."; 4559d201456903f3ecae1f7794edfab0d5678e64226shiqian 4560d201456903f3ecae1f7794edfab0d5678e64226shiqian for (size_t i = 0; i != size1; i++) { 4561d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 4562d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4563d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4564d201456903f3ecae1f7794edfab0d5678e64226shiqian 4565d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the flag values match the expected values. 4566d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CheckFlags(const Flags& expected) { 4567fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_EQ(expected.also_run_disabled_tests, 4568fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests)); 4569d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 4570d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 457153e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork)); 4572d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 4573d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 4574d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 457515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 4576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 457740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure)); 4578d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4579d201456903f3ecae1f7794edfab0d5678e64226shiqian 4580d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses a command line (specified by argc1 and argv1), then 4581d201456903f3ecae1f7794edfab0d5678e64226shiqian // verifies that the flag values are expected and that the 4582d201456903f3ecae1f7794edfab0d5678e64226shiqian // recognized flags are removed from the command line. 4583d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 4584d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TestParsingFlags(int argc1, const CharType** argv1, 4585d201456903f3ecae1f7794edfab0d5678e64226shiqian int argc2, const CharType** argv2, 4586d201456903f3ecae1f7794edfab0d5678e64226shiqian const Flags& expected) { 4587d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses the command line. 45881998cf5d32a19aaffe8652545802744d9133022dvladlosev internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); 4589d201456903f3ecae1f7794edfab0d5678e64226shiqian 4590d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies the flag values. 4591d201456903f3ecae1f7794edfab0d5678e64226shiqian CheckFlags(expected); 4592d201456903f3ecae1f7794edfab0d5678e64226shiqian 4593d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the recognized flags are removed from the command 4594d201456903f3ecae1f7794edfab0d5678e64226shiqian // line. 4595d201456903f3ecae1f7794edfab0d5678e64226shiqian AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 4596d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4597d201456903f3ecae1f7794edfab0d5678e64226shiqian 4598d201456903f3ecae1f7794edfab0d5678e64226shiqian // This macro wraps TestParsingFlags s.t. the user doesn't need 4599d201456903f3ecae1f7794edfab0d5678e64226shiqian // to specify the array sizes. 46000af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected) \ 4601d201456903f3ecae1f7794edfab0d5678e64226shiqian TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 4602d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected) 4603d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4604d201456903f3ecae1f7794edfab0d5678e64226shiqian 4605d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty command line. 4606d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Empty) { 4607d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4608d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4609d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4610d201456903f3ecae1f7794edfab0d5678e64226shiqian 4611d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4612d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4613d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4614d201456903f3ecae1f7794edfab0d5678e64226shiqian 46150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 4616d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4617d201456903f3ecae1f7794edfab0d5678e64226shiqian 4618d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a command line that has no flag. 4619d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, NoFlag) { 4620d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4621d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4622d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4623d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4624d201456903f3ecae1f7794edfab0d5678e64226shiqian 4625d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4626d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4627d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4628d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4629d201456903f3ecae1f7794edfab0d5678e64226shiqian 46300af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 4631d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4632d201456903f3ecae1f7794edfab0d5678e64226shiqian 4633d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a bad --gtest_filter flag. 4634d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterBad) { 4635d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4636d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4637d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 4638d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4639d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4640d201456903f3ecae1f7794edfab0d5678e64226shiqian 4641d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4642d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4643d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 4644d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4645d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4646d201456903f3ecae1f7794edfab0d5678e64226shiqian 46470af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("")); 4648d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4649d201456903f3ecae1f7794edfab0d5678e64226shiqian 4650d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty --gtest_filter flag. 4651d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterEmpty) { 4652d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4653d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4654d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=", 4655d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4656d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4657d201456903f3ecae1f7794edfab0d5678e64226shiqian 4658d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4659d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4660d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4661d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4662d201456903f3ecae1f7794edfab0d5678e64226shiqian 46630af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("")); 4664d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4665d201456903f3ecae1f7794edfab0d5678e64226shiqian 4666d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a non-empty --gtest_filter flag. 4667d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterNonEmpty) { 4668d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4669d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4670d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=abc", 4671d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4672d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4673d201456903f3ecae1f7794edfab0d5678e64226shiqian 4674d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4675d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4676d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4677d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4678d201456903f3ecae1f7794edfab0d5678e64226shiqian 46790af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc")); 4680d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4681d201456903f3ecae1f7794edfab0d5678e64226shiqian 4682d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure. 4683d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureNoDef) { 4684d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4685d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4686d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 4687d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4688d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4689d201456903f3ecae1f7794edfab0d5678e64226shiqian 4690d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4691d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4692d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4693d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4694d201456903f3ecae1f7794edfab0d5678e64226shiqian 46950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true)); 4696d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4697d201456903f3ecae1f7794edfab0d5678e64226shiqian 4698d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=0. 4699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 4700d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4701d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4702d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=0", 4703d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4704d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4705d201456903f3ecae1f7794edfab0d5678e64226shiqian 4706d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4707d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4708d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4709d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4710d201456903f3ecae1f7794edfab0d5678e64226shiqian 47110af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 4712d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4713d201456903f3ecae1f7794edfab0d5678e64226shiqian 4714d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=f. 4715d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 4716d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4717d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4718d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=f", 4719d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4720d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4721d201456903f3ecae1f7794edfab0d5678e64226shiqian 4722d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4723d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4724d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4725d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4726d201456903f3ecae1f7794edfab0d5678e64226shiqian 47270af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 4728d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4729d201456903f3ecae1f7794edfab0d5678e64226shiqian 4730d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 4731d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 4732d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4733d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4734d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=F", 4735d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4736d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4737d201456903f3ecae1f7794edfab0d5678e64226shiqian 4738d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4739d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4740d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4741d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4742d201456903f3ecae1f7794edfab0d5678e64226shiqian 47430af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false)); 4744d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4745d201456903f3ecae1f7794edfab0d5678e64226shiqian 4746d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a --gtest_break_on_failure flag that has a "true" 4747d201456903f3ecae1f7794edfab0d5678e64226shiqian// definition. 4748d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 4749d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4750d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4751d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=1", 4752d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4753d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4754d201456903f3ecae1f7794edfab0d5678e64226shiqian 4755d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4756d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4757d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4758d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4759d201456903f3ecae1f7794edfab0d5678e64226shiqian 47600af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true)); 4761d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4762d201456903f3ecae1f7794edfab0d5678e64226shiqian 4763d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_catch_exceptions. 4764d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, CatchExceptions) { 4765d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4766d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4767d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_catch_exceptions", 4768d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4769d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4770d201456903f3ecae1f7794edfab0d5678e64226shiqian 4771d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4772d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4773d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4774d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4775d201456903f3ecae1f7794edfab0d5678e64226shiqian 47760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true)); 4777d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4778d201456903f3ecae1f7794edfab0d5678e64226shiqian 477953e0dc4041f660b6517b15b08b496e164be614f1shiqian// Tests parsing --gtest_death_test_use_fork. 478053e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(InitGoogleTestTest, DeathTestUseFork) { 478153e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv[] = { 478253e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 478353e0dc4041f660b6517b15b08b496e164be614f1shiqian "--gtest_death_test_use_fork", 478453e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 478553e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 478653e0dc4041f660b6517b15b08b496e164be614f1shiqian 478753e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv2[] = { 478853e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 478953e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 479053e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 479153e0dc4041f660b6517b15b08b496e164be614f1shiqian 47920af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true)); 479353e0dc4041f660b6517b15b08b496e164be614f1shiqian} 479453e0dc4041f660b6517b15b08b496e164be614f1shiqian 4795d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having the same flag twice with different values. The 4796d201456903f3ecae1f7794edfab0d5678e64226shiqian// expected behavior is that the one coming last takes precedence. 4797d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, DuplicatedFlags) { 4798d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4799d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4800d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=a", 4801d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 4802d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4803d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4804d201456903f3ecae1f7794edfab0d5678e64226shiqian 4805d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4806d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4807d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4808d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4809d201456903f3ecae1f7794edfab0d5678e64226shiqian 48100af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b")); 4811d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4812d201456903f3ecae1f7794edfab0d5678e64226shiqian 4813d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having an unrecognized flag on the command line. 4814d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 4815d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4816d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4817d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 4818d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", // Unrecognized by Google Test. 4819d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 4820d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4821d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4822d201456903f3ecae1f7794edfab0d5678e64226shiqian 4823d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4824d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4825d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", 4826d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4827d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4828d201456903f3ecae1f7794edfab0d5678e64226shiqian 4829d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4830d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = true; 4831d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = "b"; 48320af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags); 4833d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4834d201456903f3ecae1f7794edfab0d5678e64226shiqian 4835d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag 4836d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFlag) { 4837d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4838d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4839d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests", 4840d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4841d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4842d201456903f3ecae1f7794edfab0d5678e64226shiqian 4843d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4844d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4845d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4846d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4847d201456903f3ecae1f7794edfab0d5678e64226shiqian 48480af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true)); 4849d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4850d201456903f3ecae1f7794edfab0d5678e64226shiqian 4851d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "true" value 4852d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsTrue) { 4853d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4854d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4855d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=1", 4856d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4857d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4858d201456903f3ecae1f7794edfab0d5678e64226shiqian 4859d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4860d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4861d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4862d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4863d201456903f3ecae1f7794edfab0d5678e64226shiqian 48640af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true)); 4865d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4866d201456903f3ecae1f7794edfab0d5678e64226shiqian 4867d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "false" value 4868d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse) { 4869d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4870d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4871d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=0", 4872d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4873d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4874d201456903f3ecae1f7794edfab0d5678e64226shiqian 4875d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4876d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4877d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4878d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4879d201456903f3ecae1f7794edfab0d5678e64226shiqian 48800af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 4881d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4882d201456903f3ecae1f7794edfab0d5678e64226shiqian 4883d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_list_tests=f. 4884d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 4885d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4886d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4887d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=f", 4888d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4889d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4890d201456903f3ecae1f7794edfab0d5678e64226shiqian 4891d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4892d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4893d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4894d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4895d201456903f3ecae1f7794edfab0d5678e64226shiqian 48960af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 4897d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4898d201456903f3ecae1f7794edfab0d5678e64226shiqian 4899d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 4900d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 4901d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4902d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4903d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=F", 4904d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4905d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4906d201456903f3ecae1f7794edfab0d5678e64226shiqian 4907d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4908d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4909d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4910d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4911d201456903f3ecae1f7794edfab0d5678e64226shiqian 49120af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false)); 4913d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4914d201456903f3ecae1f7794edfab0d5678e64226shiqian 4915d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output (invalid). 4916d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputEmpty) { 4917d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4918d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4919d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 4920d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4921d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4922d201456903f3ecae1f7794edfab0d5678e64226shiqian 4923d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4924d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4925d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 4926d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4927d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4928d201456903f3ecae1f7794edfab0d5678e64226shiqian 49290af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags()); 4930d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4931d201456903f3ecae1f7794edfab0d5678e64226shiqian 4932d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml 4933d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXml) { 4934d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4935d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4936d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml", 4937d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4938d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4939d201456903f3ecae1f7794edfab0d5678e64226shiqian 4940d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4941d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4942d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4943d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4944d201456903f3ecae1f7794edfab0d5678e64226shiqian 49450af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml")); 4946d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4947d201456903f3ecae1f7794edfab0d5678e64226shiqian 4948d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:file 4949d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlFile) { 4950d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4951d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4952d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:file", 4953d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4954d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4955d201456903f3ecae1f7794edfab0d5678e64226shiqian 4956d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4957d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4958d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4959d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4960d201456903f3ecae1f7794edfab0d5678e64226shiqian 49610af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file")); 4962d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4963d201456903f3ecae1f7794edfab0d5678e64226shiqian 4964d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:directory/path/ 4965d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 4966d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4967d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4968d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:directory/path/", 4969d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4970d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4971d201456903f3ecae1f7794edfab0d5678e64226shiqian 4972d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4973d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4974d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4975d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4976d201456903f3ecae1f7794edfab0d5678e64226shiqian 49770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:directory/path/")); 4978d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4979d201456903f3ecae1f7794edfab0d5678e64226shiqian 498015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag 498115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFlag) { 498215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 498315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 498415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time", 498515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 498615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 498715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 498815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 498915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 499015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 499115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 499215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 49930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true)); 499415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 499515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 499615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "true" value 499715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeTrue) { 499815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 499915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 500015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=1", 500115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 500215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 500315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 500415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 500515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 500615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 500715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 500815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 50090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true)); 501015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 501115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 501215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "false" value 501315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse) { 501415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 501515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 501615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=0", 501715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 501815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 501915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 502015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 502115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 502215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 502315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 502415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 50250af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 502615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 502715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 502815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=f. 502915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 503015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 503115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 503215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=f", 503315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 503415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 503515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 503615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 503715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 503815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 503915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 504015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 50410af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 504215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 504315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 504415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=F. 504515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 504615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 504715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 504815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=F", 504915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 505015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 505115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 505215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 505315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 505415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 505515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 505615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 50570af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false)); 505815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 505915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 5060d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_repeat=number 5061d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Repeat) { 5062d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5063d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5064d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_repeat=1000", 5065d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5066d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5067d201456903f3ecae1f7794edfab0d5678e64226shiqian 5068d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5069d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5070d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5071d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5072d201456903f3ecae1f7794edfab0d5678e64226shiqian 50730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000)); 5074d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5075d201456903f3ecae1f7794edfab0d5678e64226shiqian 5076fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag 5077fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { 5078fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5079fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5080fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests", 5081fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5082fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5083fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5084fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5085fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5086fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5087fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5088fe186c382905dcf57014985ccea8e067275e9f5fshiqian 50890af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true)); 5090fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5091fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5092fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "true" value 5093fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { 5094fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5095fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5096fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=1", 5097fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5098fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5099fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5100fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5101fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5102fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5103fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5104fe186c382905dcf57014985ccea8e067275e9f5fshiqian 51050af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(true)); 5106fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5107fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5108fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "false" value 5109fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { 5110fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 5111fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5112fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=0", 5113fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5114fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5115fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5116fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 5117fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 5118fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 5119fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 5120fe186c382905dcf57014985ccea8e067275e9f5fshiqian 51210af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::AlsoRunDisabledTests(false)); 5122fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 5123fe186c382905dcf57014985ccea8e067275e9f5fshiqian 512440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 512540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure. 512640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureNoDef) { 512740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 512840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 512940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure", 513040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 513140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan}; 513240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 513340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 513440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 513540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 513640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 513740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 513840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true)); 513940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 514040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 514140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure=0. 514240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { 514340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 514440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 514540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=0", 514640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 514740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 514840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 514940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 515040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 515140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 515240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 515340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 515440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false)); 515540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 515640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 515740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing a --gtest_throw_on_failure flag that has a "true" 515840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// definition. 515940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { 516040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 516140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 516240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=1", 516340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 516440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 516540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 516640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 516740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 516840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 516940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 517040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 517140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true)); 517240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 517340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 51740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 5175d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing wide strings. 5176d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, WideStrings) { 5177d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv[] = { 5178d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 5179d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_filter=Foo*", 5180d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_list_tests=1", 5181d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_break_on_failure", 5182d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 5183d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5184d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5185d201456903f3ecae1f7794edfab0d5678e64226shiqian 5186d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv2[] = { 5187d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 5188d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 5189d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5190d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5191d201456903f3ecae1f7794edfab0d5678e64226shiqian 5192d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags expected_flags; 5193d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.break_on_failure = true; 5194d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.filter = "Foo*"; 5195d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.list_tests = true; 5196d201456903f3ecae1f7794edfab0d5678e64226shiqian 51970af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags); 5198d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5199d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 5200d201456903f3ecae1f7794edfab0d5678e64226shiqian 5201d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests current_test_info() in UnitTest. 5202d201456903f3ecae1f7794edfab0d5678e64226shiqianclass CurrentTestInfoTest : public Test { 5203d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5204d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL before the first test in 5205d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case is run. 5206d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 5207d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be no tests running at this point. 5208d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5209d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5210d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, test_info) 5211d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 5212d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5213d201456903f3ecae1f7794edfab0d5678e64226shiqian 5214d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL after the last test in 5215d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case has run. 5216d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 5217d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5218d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5219d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, test_info) 5220d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 5221d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5222d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5223d201456903f3ecae1f7794edfab0d5678e64226shiqian 5224d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 5225d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. 5226d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 5227d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5228d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5229d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 5230d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 5231d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 5232d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 5233d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 5234d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 5235d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5236d201456903f3ecae1f7794edfab0d5678e64226shiqian 5237d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 5238d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. We 5239d201456903f3ecae1f7794edfab0d5678e64226shiqian// use this test to see that the TestInfo object actually changed from 5240d201456903f3ecae1f7794edfab0d5678e64226shiqian// the previous invocation. 5241d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 5242d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 5243d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 5244d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 5245d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 5246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 5247d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 5248d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 5249d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 5250d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5251d201456903f3ecae1f7794edfab0d5678e64226shiqian 5252d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 5253d201456903f3ecae1f7794edfab0d5678e64226shiqian 5254d201456903f3ecae1f7794edfab0d5678e64226shiqian// These two lines test that we can define tests in a namespace that 5255d201456903f3ecae1f7794edfab0d5678e64226shiqian// has the name "testing" and is nested in another namespace. 5256d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace my_namespace { 5257d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 5258d201456903f3ecae1f7794edfab0d5678e64226shiqian 5259d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that TEST knows to use ::testing::Test instead of 5260d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Test. 5261d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Test {}; 5262d201456903f3ecae1f7794edfab0d5678e64226shiqian 5263d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use ::testing::Message instead of 5264d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Message. 5265d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message {}; 5266d201456903f3ecae1f7794edfab0d5678e64226shiqian 5267d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use 5268d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::testing::AssertionResult instead of 5269d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::AssertionResult. 5270d201456903f3ecae1f7794edfab0d5678e64226shiqianclass AssertionResult {}; 5271d201456903f3ecae1f7794edfab0d5678e64226shiqian 5272d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should succeed works as expected. 5273d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Success) { 5274d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "This shouldn't fail."; 5275d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5276d201456903f3ecae1f7794edfab0d5678e64226shiqian 5277d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should fail works as expected. 5278d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Failure) { 5279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 5280d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is expected."); 5281d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5282d201456903f3ecae1f7794edfab0d5678e64226shiqian 5283d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 5284d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace my_namespace 5285d201456903f3ecae1f7794edfab0d5678e64226shiqian 5286d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that one can call superclass SetUp and TearDown methods-- 5287d201456903f3ecae1f7794edfab0d5678e64226shiqian// that is, that they are not private. 5288d201456903f3ecae1f7794edfab0d5678e64226shiqian// No tests are based on this fixture; the test "passes" if it compiles 5289d201456903f3ecae1f7794edfab0d5678e64226shiqian// successfully. 52909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass ProtectedFixtureMethodsTest : public Test { 5291d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5292d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 52939b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::SetUp(); 5294d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5295d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 52969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::TearDown(); 5297d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5298d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5299d201456903f3ecae1f7794edfab0d5678e64226shiqian 5300d201456903f3ecae1f7794edfab0d5678e64226shiqian// StreamingAssertionsTest tests the streaming versions of a representative 5301d201456903f3ecae1f7794edfab0d5678e64226shiqian// sample of assertions. 5302d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Unconditional) { 5303d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "expected success"; 5304d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 5305d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 5307d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5308d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5309d201456903f3ecae1f7794edfab0d5678e64226shiqian 5310c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 5311c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 5312c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option push -w-ccc -w-rch 5313c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 5314c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 5315d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth) { 5316d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true) << "unexpected failure"; 5317d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true) << "unexpected failure"; 5318d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 5319d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5320d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 5321d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5322d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5323d201456903f3ecae1f7794edfab0d5678e64226shiqian 5324d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth2) { 5325d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "unexpected failure"; 5326d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(false) << "unexpected failure"; 5327d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 5328d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5329d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 5330d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5331d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5332d201456903f3ecae1f7794edfab0d5678e64226shiqian 5333c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 5334c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 5335c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#pragma option pop 5336c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 5337c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 5338d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerEquals) { 5339d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "unexpected failure"; 5340d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "unexpected failure"; 5341d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 5342d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5343d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 5344d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5345d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5346d201456903f3ecae1f7794edfab0d5678e64226shiqian 5347d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerLessThan) { 5348d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(1, 2) << "unexpected failure"; 5349d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 2) << "unexpected failure"; 5350d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 5351d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5352d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 5353d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5354d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5355d201456903f3ecae1f7794edfab0d5678e64226shiqian 5356d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqual) { 5357d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", "foo") << "unexpected failure"; 5358d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("foo", "foo") << "unexpected failure"; 5359d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 5360d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5361d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 5362d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5363d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5364d201456903f3ecae1f7794edfab0d5678e64226shiqian 5365d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsNotEqual) { 5366d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("foo", "bar") << "unexpected failure"; 5367d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("foo", "bar") << "unexpected failure"; 5368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 5369d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5370d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 5371d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5372d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5373d201456903f3ecae1f7794edfab0d5678e64226shiqian 5374d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 5375d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 5376d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 5377d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 5378d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5379d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 5380d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5381d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5382d201456903f3ecae1f7794edfab0d5678e64226shiqian 5383d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 5384d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 5385d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 5386d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 5387d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5388d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 5389d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5390d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5391d201456903f3ecae1f7794edfab0d5678e64226shiqian 5392d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, FloatingPointEquals) { 5393d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 5394d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 5395d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 5396d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5397d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 5398d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 5399d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5400d201456903f3ecae1f7794edfab0d5678e64226shiqian 540136865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 540236865d8d354465e3461eedf2949a4b7799985d5dshiqian 540336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, Throw) { 540436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 540536865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 540636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 540736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 540836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 540936865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 541036865d8d354465e3461eedf2949a4b7799985d5dshiqian} 541136865d8d354465e3461eedf2949a4b7799985d5dshiqian 541236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, NoThrow) { 5413886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure"; 5414886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure"; 541536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 541636865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 541736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 541836865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 541936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 542036865d8d354465e3461eedf2949a4b7799985d5dshiqian 542136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, AnyThrow) { 542236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 542336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 5424886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) << 542536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 5426886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << 542736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 542836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 542936865d8d354465e3461eedf2949a4b7799985d5dshiqian 543036865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 543136865d8d354465e3461eedf2949a4b7799985d5dshiqian 5432d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test correctly decides whether to use colors in the output. 5433d201456903f3ecae1f7794edfab0d5678e64226shiqian 5434d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 5435d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "yes"; 5436d201456903f3ecae1f7794edfab0d5678e64226shiqian 5437d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5438d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5439d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5440d201456903f3ecae1f7794edfab0d5678e64226shiqian 5441d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5442d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5443d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5444d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5445d201456903f3ecae1f7794edfab0d5678e64226shiqian 5446d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 5447d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5448d201456903f3ecae1f7794edfab0d5678e64226shiqian 5449d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "True"; 5450d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5451d201456903f3ecae1f7794edfab0d5678e64226shiqian 5452d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "t"; 5453d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5454d201456903f3ecae1f7794edfab0d5678e64226shiqian 5455d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "1"; 5456d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 5457d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5458d201456903f3ecae1f7794edfab0d5678e64226shiqian 5459d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 5460d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "no"; 5461d201456903f3ecae1f7794edfab0d5678e64226shiqian 5462d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5463d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5464d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5465d201456903f3ecae1f7794edfab0d5678e64226shiqian 5466d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5467d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5468d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5469d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5470d201456903f3ecae1f7794edfab0d5678e64226shiqian 5471d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 5472d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5473d201456903f3ecae1f7794edfab0d5678e64226shiqian 5474d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "F"; 5475d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5476d201456903f3ecae1f7794edfab0d5678e64226shiqian 5477d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "0"; 5478d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5479d201456903f3ecae1f7794edfab0d5678e64226shiqian 5480d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "unknown"; 5481d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5482d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5483d201456903f3ecae1f7794edfab0d5678e64226shiqian 5484d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 5485d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 5486d201456903f3ecae1f7794edfab0d5678e64226shiqian 5487d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5488d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 5489d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5490d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5491d201456903f3ecae1f7794edfab0d5678e64226shiqian 5492d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 5493d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 5494d201456903f3ecae1f7794edfab0d5678e64226shiqian 54950af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 5496d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Windows, we ignore the TERM variable as it's usually not set. 5497d201456903f3ecae1f7794edfab0d5678e64226shiqian 5498d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); 5499d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5500d201456903f3ecae1f7794edfab0d5678e64226shiqian 5501d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", ""); 5502d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5503d201456903f3ecae1f7794edfab0d5678e64226shiqian 5504d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); 5505d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5506d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 5507d201456903f3ecae1f7794edfab0d5678e64226shiqian // On non-Windows platforms, we rely on TERM to determine if the 5508d201456903f3ecae1f7794edfab0d5678e64226shiqian // terminal supports colors. 5509d201456903f3ecae1f7794edfab0d5678e64226shiqian 5510d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 5511d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5512d201456903f3ecae1f7794edfab0d5678e64226shiqian 5513d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "emacs"); // TERM doesn't support colors. 5514d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5515d201456903f3ecae1f7794edfab0d5678e64226shiqian 5516d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "vt100"); // TERM doesn't support colors. 5517d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5518d201456903f3ecae1f7794edfab0d5678e64226shiqian 5519d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 5520d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 5521d201456903f3ecae1f7794edfab0d5678e64226shiqian 5522d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 5523d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5524d201456903f3ecae1f7794edfab0d5678e64226shiqian 5525d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-color"); // TERM supports colors. 5526d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 5527d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 5528d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5529d201456903f3ecae1f7794edfab0d5678e64226shiqian 553053e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a namespace scope. 553153e0dc4041f660b6517b15b08b496e164be614f1shiqian 553253e0dc4041f660b6517b15b08b496e164be614f1shiqianstatic bool dummy1 = StaticAssertTypeEq<bool, bool>(); 553353e0dc4041f660b6517b15b08b496e164be614f1shiqianstatic bool dummy2 = StaticAssertTypeEq<const int, const int>(); 553453e0dc4041f660b6517b15b08b496e164be614f1shiqian 553553e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a class. 553653e0dc4041f660b6517b15b08b496e164be614f1shiqian 553753e0dc4041f660b6517b15b08b496e164be614f1shiqiantemplate <typename T> 553853e0dc4041f660b6517b15b08b496e164be614f1shiqianclass StaticAssertTypeEqTestHelper { 553953e0dc4041f660b6517b15b08b496e164be614f1shiqian public: 554053e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); } 554153e0dc4041f660b6517b15b08b496e164be614f1shiqian}; 554253e0dc4041f660b6517b15b08b496e164be614f1shiqian 554353e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, WorksInClass) { 554453e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper<bool>(); 554553e0dc4041f660b6517b15b08b496e164be614f1shiqian} 554653e0dc4041f660b6517b15b08b496e164be614f1shiqian 554753e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works inside a function. 554853e0dc4041f660b6517b15b08b496e164be614f1shiqian 554953e0dc4041f660b6517b15b08b496e164be614f1shiqiantypedef int IntAlias; 555053e0dc4041f660b6517b15b08b496e164be614f1shiqian 555153e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, CompilesForEqualTypes) { 555253e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int, IntAlias>(); 555353e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int*, IntAlias*>(); 555453e0dc4041f660b6517b15b08b496e164be614f1shiqian} 555553e0dc4041f660b6517b15b08b496e164be614f1shiqian 5556e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(ThreadLocalTest, DefaultConstructor) { 5557e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int> t1; 5558e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(0, t1.get()); 5559e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5560e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<void*> t2; 5561e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(t2.get() == NULL); 5562e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 5563e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5564e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(ThreadLocalTest, Init) { 5565e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int> t1(123); 5566e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(123, t1.get()); 5567e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 5568e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian int i = 0; 5569e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ThreadLocal<int*> t2(&i); 5570e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(&i, t2.get()); 5571e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 5572e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 55733d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) { 55743d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev testing::UnitTest* const unit_test = testing::UnitTest::GetInstance(); 55753d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 55763d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // We don't have a stack walker in Google Test yet. 55773d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str()); 55783d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str()); 55793d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 5580c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5581c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) { 5582c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailure()); 5583c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5584c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5585c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic void FailFatally() { FAIL(); } 5586c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5587c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) { 5588c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5589c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5590c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5591c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(has_nonfatal_failure); 5592c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5593c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5594c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 5595c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5596c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5597c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5598c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5599c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5600c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5601c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 5602c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5603c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5604c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 5605c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5606c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5607c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5608c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5609c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasNonfatalFailure outside of a test body. 5610c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasNonfatalFailureHelper() { 5611c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan return testing::Test::HasNonfatalFailure(); 5612c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5613c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5614c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) { 5615c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailureHelper()); 5616c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5617c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5618c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) { 5619c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5620c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailureHelper(); 5621c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5622c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 5623c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5624c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5625c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) { 5626c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailure()); 5627c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5628c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5629c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) { 5630c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5631c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 5632c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5633c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 5634c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5635c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5636c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 5637c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5638c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 5639c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5640c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 5641c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5642c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5643c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 5644c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 5645c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5646c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 5647c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5648c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 5649c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5650c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5651c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasFailure outside of a test body. 5652c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasFailureHelper() { return testing::Test::HasFailure(); } 5653c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5654c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody) { 5655c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailureHelper()); 5656c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5657c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 5658c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody2) { 5659c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 5660c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailureHelper(); 5661c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 5662c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 5663c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 5664