gtest_unittest.cc revision ee39a89debba2b2e00dec3fa2df03e1d3dcb4027
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> 36d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <gtest/gtest-spi.h> 37d201456903f3ecae1f7794edfab0d5678e64226shiqian 38d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 39d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 40d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 41d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 42d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 43d201456903f3ecae1f7794edfab0d5678e64226shiqian#define GTEST_IMPLEMENTATION 44d201456903f3ecae1f7794edfab0d5678e64226shiqian#include "src/gtest-internal-inl.h" 45d201456903f3ecae1f7794edfab0d5678e64226shiqian#undef GTEST_IMPLEMENTATION 46d201456903f3ecae1f7794edfab0d5678e64226shiqian 47d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <stdlib.h> 48d201456903f3ecae1f7794edfab0d5678e64226shiqian 49d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_LINUX 50d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <string.h> 51d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <signal.h> 52d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <sys/stat.h> 53d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <pthread.h> 54d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <unistd.h> 55d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <string> 56d201456903f3ecae1f7794edfab0d5678e64226shiqian#include <vector> 57d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 58d201456903f3ecae1f7794edfab0d5678e64226shiqian 59d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 60d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 61d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ParseInt32Flag(const char* str, const char* flag, Int32* value); 62d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 63d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 64d201456903f3ecae1f7794edfab0d5678e64226shiqian 65d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ParseInt32Flag; 66d201456903f3ecae1f7794edfab0d5678e64226shiqian 67d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 68d201456903f3ecae1f7794edfab0d5678e64226shiqian 69d201456903f3ecae1f7794edfab0d5678e64226shiqianGTEST_DECLARE_string(output); 70d201456903f3ecae1f7794edfab0d5678e64226shiqianGTEST_DECLARE_string(color); 71d201456903f3ecae1f7794edfab0d5678e64226shiqian 72d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 73d201456903f3ecae1f7794edfab0d5678e64226shiqianbool ShouldUseColor(bool stdout_is_tty); 74d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 75d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 76d201456903f3ecae1f7794edfab0d5678e64226shiqian 779b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionFailure; 789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionResult; 799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionSuccess; 809b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::DoubleLE; 819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::FloatLE; 829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(break_on_failure); 839b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(catch_exceptions); 84d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::GTEST_FLAG(color); 859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(filter); 869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(list_tests); 879b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(output); 889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(print_time); 899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(repeat); 909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(show_internal_stack_frames); 919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(stack_trace_depth); 929b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsNotSubstring; 939b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsSubstring; 949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Message; 95d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::ScopedFakeTestPartResultReporter; 969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Test; 97d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResult; 98d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::TestPartResultArray; 999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_FATAL_FAILURE; 1009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_NONFATAL_FAILURE; 1019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::TPRT_SUCCESS; 102d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::UnitTest; 103d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::AppendUserMessage; 1040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::CodePointToUtf8; 105d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::EqFailure; 1069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::FloatingPoint; 1079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::GTestFlagSaver; 108d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::Int32; 109d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::List; 110d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ShouldUseColor; 111d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::StreamableToString; 112d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::String; 113d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestProperty; 114d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::TestResult; 115d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::UnitTestImpl; 1160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::WideStringToUtf8; 117d201456903f3ecae1f7794edfab0d5678e64226shiqian 118d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in an unnamed namespace. 119d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 120d201456903f3ecae1f7794edfab0d5678e64226shiqian 121d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef __SYMBIAN32__ 122d201456903f3ecae1f7794edfab0d5678e64226shiqian// NULL testing does not work with Symbian compilers. 123d201456903f3ecae1f7794edfab0d5678e64226shiqian 124d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTEST_IS_NULL_LITERAL(x) is true when x is a null 125d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 126d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsTrueForNullLiterals) { 127d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(NULL)); 128d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(0)); 129d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(1 - 1)); 130d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(0U)); 131d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(0L)); 132d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(false)); 133d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL(true && false)); 134d201456903f3ecae1f7794edfab0d5678e64226shiqian} 135d201456903f3ecae1f7794edfab0d5678e64226shiqian 136d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTEST_IS_NULL_LITERAL(x) is false when x is not a null 137d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 138d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 139d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL(1)); 140d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL(0.0)); 141d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL('a')); 142d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL(static_cast<void*>(NULL))); 143d201456903f3ecae1f7794edfab0d5678e64226shiqian} 144d201456903f3ecae1f7794edfab0d5678e64226shiqian 145d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32__ 1460c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 1470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests CodePointToUtf8(). 148d201456903f3ecae1f7794edfab0d5678e64226shiqian 149d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the NUL character L'\0' is encoded correctly. 1500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeNul) { 1510c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 1520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", CodePointToUtf8(L'\0', buffer)); 153d201456903f3ecae1f7794edfab0d5678e64226shiqian} 154d201456903f3ecae1f7794edfab0d5678e64226shiqian 155d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASCII characters are encoded correctly. 1560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeAscii) { 1570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 1580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", CodePointToUtf8(L'a', buffer)); 1590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("Z", CodePointToUtf8(L'Z', buffer)); 1600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("&", CodePointToUtf8(L'&', buffer)); 1610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\x7F", CodePointToUtf8(L'\x7F', buffer)); 162d201456903f3ecae1f7794edfab0d5678e64226shiqian} 163d201456903f3ecae1f7794edfab0d5678e64226shiqian 164d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 8 to 11 bits are encoded 165d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 110xxxxx 10xxxxxx. 1660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 1670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 168d201456903f3ecae1f7794edfab0d5678e64226shiqian // 000 1101 0011 => 110-00011 10-010011 1690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", CodePointToUtf8(L'\xD3', buffer)); 170d201456903f3ecae1f7794edfab0d5678e64226shiqian 171d201456903f3ecae1f7794edfab0d5678e64226shiqian // 101 0111 0110 => 110-10101 10-110110 1720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", CodePointToUtf8(L'\x576', buffer)); 173d201456903f3ecae1f7794edfab0d5678e64226shiqian} 174d201456903f3ecae1f7794edfab0d5678e64226shiqian 175d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 12 to 16 bits are encoded 176d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 1110xxxx 10xxxxxx 10xxxxxx. 1770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 1780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 179d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 1800c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", CodePointToUtf8(L'\x8D3', buffer)); 181d201456903f3ecae1f7794edfab0d5678e64226shiqian 182d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 1830c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", CodePointToUtf8(L'\xC74D', buffer)); 184d201456903f3ecae1f7794edfab0d5678e64226shiqian} 185d201456903f3ecae1f7794edfab0d5678e64226shiqian 1860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#ifndef GTEST_WIDE_STRING_USES_UTF16_ 187d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests in this group require a wchar_t to hold > 16 bits, and thus 188e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 1890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 16-bit wide. This code may not compile on those systems. 190d201456903f3ecae1f7794edfab0d5678e64226shiqian 191d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 17 to 21 bits are encoded 192d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 1930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 1940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 195d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 1960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3', buffer)); 1970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 1980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 1990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400', buffer)); 200d201456903f3ecae1f7794edfab0d5678e64226shiqian 2010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 2020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634', buffer)); 203d201456903f3ecae1f7794edfab0d5678e64226shiqian} 204d201456903f3ecae1f7794edfab0d5678e64226shiqian 205d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that encoding an invalid code-point generates the expected result. 2060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 2070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev char buffer[32]; 208d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(Invalid Unicode 0x1234ABCD)", 2090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev CodePointToUtf8(L'\x1234ABCD', buffer)); 2100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#endif // GTEST_WIDE_STRING_USES_UTF16_ 2130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests WideStringToUtf8(). 2150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the NUL character L'\0' is encoded correctly. 2170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeNul) { 2180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 2190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 2200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that ASCII strings are encoded correctly. 2230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeAscii) { 2240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 2250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 2260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 2270c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 2280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2300c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 8 to 11 bits are encoded 2310c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 110xxxxx 10xxxxxx. 2320c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 2330c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 000 1101 0011 => 110-00011 10-010011 2340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 2350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 2360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 101 0111 0110 => 110-10101 10-110110 2380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", 1).c_str()); 2390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(L"\x576", -1).c_str()); 2400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2420c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 12 to 16 bits are encoded 2430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 1110xxxx 10xxxxxx 10xxxxxx. 2440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 2450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 2460c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", 1).c_str()); 2470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(L"\x8D3", -1).c_str()); 2480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 2500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", 1).c_str()); 2510c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(L"\xC74D", -1).c_str()); 252d201456903f3ecae1f7794edfab0d5678e64226shiqian} 253d201456903f3ecae1f7794edfab0d5678e64226shiqian 2540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function encounters \0 character. 2550c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 2560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 2570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function reaches the limit 2600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// specified by the 'length' parameter. 2610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 2620c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 2630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2640c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2650c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#ifndef GTEST_WIDE_STRING_USES_UTF16_ 2670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 17 to 21 bits are encoded 2680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 2690c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// on the systems using UTF-16 encoding. 2700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 2710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 2720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 2730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 2740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 2760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 2770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 2780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2800c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid code-point generates the expected result. 2810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 2820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 2830c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xABCDFF", -1).c_str()); 2840c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 2860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that surrogate pairs are encoded correctly on the systems using 2870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// UTF-16 encoding in the wide strings. 2880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 2890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\x90\x80", 2900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xD801\xDC00", -1).c_str()); 2910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 2920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 2930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid UTF-16 surrogate pair 2940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// generates the expected result. 2950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 2960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is at the end of the string. 2970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(L"\xD800", -1).c_str()); 2980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is not followed by the trailing surrogate. 2990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xA0\x80$", WideStringToUtf8(L"\xD800$", -1).c_str()); 3000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Trailing surrogate appearas without a leading surrogate. 3010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(L"\xDC00PQR", -1).c_str()); 3020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3030c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#endif // GTEST_WIDE_STRING_USES_UTF16_ 3040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 3050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that codepoint concatenation works correctly. 3060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#ifndef GTEST_WIDE_STRING_USES_UTF16_ 3070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 3080c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 3090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4" 3100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" 3110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\n" 3120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xD5\xB6" 3130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xE0\xA3\x93" 3140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4", 3150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\x108634\xC74D\n\x576\x8D3\x108634", -1).c_str()); 3160c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3170c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 3180c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 3190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 3200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 3210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xC74D\n\x576\x8D3", -1).c_str()); 3220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 3230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#endif // GTEST_WIDE_STRING_USES_UTF16_ 324d201456903f3ecae1f7794edfab0d5678e64226shiqian 325d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the List template class. 326d201456903f3ecae1f7794edfab0d5678e64226shiqian 327d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests List::PushFront(). 328d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, PushFront) { 329d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 330d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, a.size()); 331d201456903f3ecae1f7794edfab0d5678e64226shiqian 332d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on an empty list. 333d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(1); 334d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, a.size()); 335d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 336d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(a.Head(), a.Last()); 337d201456903f3ecae1f7794edfab0d5678e64226shiqian 338d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on a singleton list. 339d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 340d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 341d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->element()); 342d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 343d201456903f3ecae1f7794edfab0d5678e64226shiqian 344d201456903f3ecae1f7794edfab0d5678e64226shiqian // Calls PushFront() on a list with more than one elements. 345d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 346d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 347d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Head()->element()); 348d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 349d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 350d201456903f3ecae1f7794edfab0d5678e64226shiqian} 351d201456903f3ecae1f7794edfab0d5678e64226shiqian 352d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests List::PopFront(). 353d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, PopFront) { 354d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 355d201456903f3ecae1f7794edfab0d5678e64226shiqian 356d201456903f3ecae1f7794edfab0d5678e64226shiqian // Popping on an empty list should fail. 357d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(NULL)); 358d201456903f3ecae1f7794edfab0d5678e64226shiqian 359d201456903f3ecae1f7794edfab0d5678e64226shiqian // Popping again on an empty list should fail, and the result element 360d201456903f3ecae1f7794edfab0d5678e64226shiqian // shouldn't be overwritten. 361d201456903f3ecae1f7794edfab0d5678e64226shiqian int element = 1; 362d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(a.PopFront(&element)); 363d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, element); 364d201456903f3ecae1f7794edfab0d5678e64226shiqian 365d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(2); 366d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushFront(3); 367d201456903f3ecae1f7794edfab0d5678e64226shiqian 368d201456903f3ecae1f7794edfab0d5678e64226shiqian // PopFront() should pop the element in the front of the list. 369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(&element)); 370d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, element); 371d201456903f3ecae1f7794edfab0d5678e64226shiqian 372d201456903f3ecae1f7794edfab0d5678e64226shiqian // After popping the last element, the list should be empty. 373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(a.PopFront(NULL)); 374d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, a.size()); 375d201456903f3ecae1f7794edfab0d5678e64226shiqian} 376d201456903f3ecae1f7794edfab0d5678e64226shiqian 377d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests inserting at the beginning using List::InsertAfter(). 378d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, InsertAfterAtBeginning) { 379d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 380d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, a.size()); 381d201456903f3ecae1f7794edfab0d5678e64226shiqian 382d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts into an empty list. 383d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 1); 384d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, a.size()); 385d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 386d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(a.Head(), a.Last()); 387d201456903f3ecae1f7794edfab0d5678e64226shiqian 388d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the beginning of a singleton list. 389d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 2); 390d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 391d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->element()); 392d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 393d201456903f3ecae1f7794edfab0d5678e64226shiqian 394d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the beginning of a list with more than one elements. 395d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(NULL, 3); 396d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 397d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Head()->element()); 398d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 399d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Last()->element()); 400d201456903f3ecae1f7794edfab0d5678e64226shiqian} 401d201456903f3ecae1f7794edfab0d5678e64226shiqian 402d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests inserting at a location other than the beginning using 403d201456903f3ecae1f7794edfab0d5678e64226shiqian// List::InsertAfter(). 404d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ListTest, InsertAfterNotAtBeginning) { 405d201456903f3ecae1f7794edfab0d5678e64226shiqian // Prepares a singleton list. 406d201456903f3ecae1f7794edfab0d5678e64226shiqian List<int> a; 407d201456903f3ecae1f7794edfab0d5678e64226shiqian a.PushBack(1); 408d201456903f3ecae1f7794edfab0d5678e64226shiqian 409d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the end of a singleton list. 410d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Last(), 2); 411d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, a.size()); 412d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 413d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Last()->element()); 414d201456903f3ecae1f7794edfab0d5678e64226shiqian 415d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts at the end of a list with more than one elements. 416d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Last(), 3); 417d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(3u, a.size()); 418d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 419d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->element()); 420d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Last()->element()); 421d201456903f3ecae1f7794edfab0d5678e64226shiqian 422d201456903f3ecae1f7794edfab0d5678e64226shiqian // Inserts in the middle of a list. 423d201456903f3ecae1f7794edfab0d5678e64226shiqian a.InsertAfter(a.Head(), 4); 424d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(4u, a.size()); 425d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a.Head()->element()); 426d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a.Head()->next()->element()); 427d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a.Head()->next()->next()->element()); 428d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a.Last()->element()); 429d201456903f3ecae1f7794edfab0d5678e64226shiqian} 430d201456903f3ecae1f7794edfab0d5678e64226shiqian 431d201456903f3ecae1f7794edfab0d5678e64226shiqian 432d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the String class. 433d201456903f3ecae1f7794edfab0d5678e64226shiqian 434d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String's constructors. 435d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Constructors) { 436d201456903f3ecae1f7794edfab0d5678e64226shiqian // Default ctor. 437d201456903f3ecae1f7794edfab0d5678e64226shiqian String s1; 438bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // We aren't using EXPECT_EQ(NULL, s1.c_str()) because comparing 439bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian // pointers with NULL isn't supported on all platforms. 440bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(NULL == s1.c_str()); 441d201456903f3ecae1f7794edfab0d5678e64226shiqian 442d201456903f3ecae1f7794edfab0d5678e64226shiqian // Implicitly constructs from a C-string. 443d201456903f3ecae1f7794edfab0d5678e64226shiqian String s2 = "Hi"; 444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Hi", s2.c_str()); 445d201456903f3ecae1f7794edfab0d5678e64226shiqian 446d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs from a C-string and a length. 447d201456903f3ecae1f7794edfab0d5678e64226shiqian String s3("hello", 3); 448d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s3.c_str()); 449d201456903f3ecae1f7794edfab0d5678e64226shiqian 450d201456903f3ecae1f7794edfab0d5678e64226shiqian // Copy ctor. 451d201456903f3ecae1f7794edfab0d5678e64226shiqian String s4 = s3; 452d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hel", s4.c_str()); 453d201456903f3ecae1f7794edfab0d5678e64226shiqian} 454d201456903f3ecae1f7794edfab0d5678e64226shiqian 455d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCString(). 456d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCString) { 457d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", String::ShowCString(NULL)); 458d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowCString("")); 459d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowCString("foo")); 460d201456903f3ecae1f7794edfab0d5678e64226shiqian} 461d201456903f3ecae1f7794edfab0d5678e64226shiqian 462d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowCStringQuoted(). 463d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowCStringQuoted) { 464d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 465d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted(NULL).c_str()); 466d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"\"", 467d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("").c_str()); 468d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("\"foo\"", 469d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowCStringQuoted("foo").c_str()); 470d201456903f3ecae1f7794edfab0d5678e64226shiqian} 471d201456903f3ecae1f7794edfab0d5678e64226shiqian 472d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator==(). 473d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, Equals) { 474d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 475d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null == NULL); // NOLINT 476d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == ""); // NOLINT 477d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null == "bar"); // NOLINT 478d201456903f3ecae1f7794edfab0d5678e64226shiqian 479d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 480d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == NULL); // NOLINT 481d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty == ""); // NOLINT 482d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty == "bar"); // NOLINT 483d201456903f3ecae1f7794edfab0d5678e64226shiqian 484d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 485d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == NULL); // NOLINT 486d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == ""); // NOLINT 487d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo == "bar"); // NOLINT 488d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo == "foo"); // NOLINT 489d201456903f3ecae1f7794edfab0d5678e64226shiqian} 490d201456903f3ecae1f7794edfab0d5678e64226shiqian 491d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::operator!=(). 492d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, NotEquals) { 493d201456903f3ecae1f7794edfab0d5678e64226shiqian const String null(NULL); 494d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(null != NULL); // NOLINT 495d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != ""); // NOLINT 496d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(null != "bar"); // NOLINT 497d201456903f3ecae1f7794edfab0d5678e64226shiqian 498d201456903f3ecae1f7794edfab0d5678e64226shiqian const String empty(""); 499d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != NULL); // NOLINT 500d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(empty != ""); // NOLINT 501d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(empty != "bar"); // NOLINT 502d201456903f3ecae1f7794edfab0d5678e64226shiqian 503d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 504d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != NULL); // NOLINT 505d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != ""); // NOLINT 506d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(foo != "bar"); // NOLINT 507d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(foo != "foo"); // NOLINT 508d201456903f3ecae1f7794edfab0d5678e64226shiqian} 509d201456903f3ecae1f7794edfab0d5678e64226shiqian 510d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWith(). 511d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWith) { 512d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("bar")); 513d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWith("")); 514d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWith("")); 515d201456903f3ecae1f7794edfab0d5678e64226shiqian 516d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWith("foo")); 517d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWith("foo")); 518d201456903f3ecae1f7794edfab0d5678e64226shiqian} 519d201456903f3ecae1f7794edfab0d5678e64226shiqian 520d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWithCaseInsensitive(). 521d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWithCaseInsensitive) { 522d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("BAR")); 523d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobaR").EndsWithCaseInsensitive("bar")); 524d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("foobar").EndsWithCaseInsensitive("")); 525d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(String("").EndsWithCaseInsensitive("")); 526d201456903f3ecae1f7794edfab0d5678e64226shiqian 527d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("Foobar").EndsWithCaseInsensitive("foo")); 528d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("foobar").EndsWithCaseInsensitive("Foo")); 529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(String("").EndsWithCaseInsensitive("foo")); 530d201456903f3ecae1f7794edfab0d5678e64226shiqian} 531d201456903f3ecae1f7794edfab0d5678e64226shiqian 532a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests String::CaseInsensitiveWideCStringEquals 533a2b1a8556ea64014606d78b09333d9c522430a25shiqianTEST(StringTest, CaseInsensitiveWideCStringEquals) { 534a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 535a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(NULL, L"")); 536a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", NULL)); 537a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(NULL, L"foobar")); 538a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", NULL)); 539a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 540a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 541a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 542a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 543a2b1a8556ea64014606d78b09333d9c522430a25shiqian 544d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that NULL can be assigned to a String. 545d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNULL) { 546d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(NULL); 547d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 548d201456903f3ecae1f7794edfab0d5678e64226shiqian 549d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 550d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(NULL, dest.c_str()); 551d201456903f3ecae1f7794edfab0d5678e64226shiqian} 552d201456903f3ecae1f7794edfab0d5678e64226shiqian 553d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the empty string "" can be assigned to a String. 554d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedEmpty) { 555d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src(""); 556d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 557d201456903f3ecae1f7794edfab0d5678e64226shiqian 558d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 559d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", dest.c_str()); 560d201456903f3ecae1f7794edfab0d5678e64226shiqian} 561d201456903f3ecae1f7794edfab0d5678e64226shiqian 562d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a non-empty string can be assigned to a String. 563d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedNonEmpty) { 564d201456903f3ecae1f7794edfab0d5678e64226shiqian const String src("hello"); 565d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest; 566d201456903f3ecae1f7794edfab0d5678e64226shiqian 567d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = src; 568d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 569d201456903f3ecae1f7794edfab0d5678e64226shiqian} 570d201456903f3ecae1f7794edfab0d5678e64226shiqian 571d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that a String can be assigned to itself. 572d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, CanBeAssignedSelf) { 573d201456903f3ecae1f7794edfab0d5678e64226shiqian String dest("hello"); 574d201456903f3ecae1f7794edfab0d5678e64226shiqian 575d201456903f3ecae1f7794edfab0d5678e64226shiqian dest = dest; 576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("hello", dest.c_str()); 577d201456903f3ecae1f7794edfab0d5678e64226shiqian} 578d201456903f3ecae1f7794edfab0d5678e64226shiqian 579d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS 580d201456903f3ecae1f7794edfab0d5678e64226shiqian 581d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCString(). 582d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCString) { 583d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 584d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCString(NULL).c_str()); 585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 586d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 588d201456903f3ecae1f7794edfab0d5678e64226shiqian 589d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCStringQuoted(). 590d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCStringQuoted) { 591d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 592d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(NULL).c_str()); 593d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"\"", 594d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"").c_str()); 595d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("L\"foo\"", 596d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCStringQuoted(L"foo").c_str()); 597d201456903f3ecae1f7794edfab0d5678e64226shiqian} 598d201456903f3ecae1f7794edfab0d5678e64226shiqian 599bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#ifdef _WIN32_WCE 600bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16Null) { 601bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 602bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 603bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 604bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 605bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertBasic) { 606bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L"str"); 607bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ("str", ansi); 608bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 609bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16("str"); 610bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(wcsncmp(L"str", utf16, 3) == 0); 611bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 612bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 613bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 614bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 615bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 616bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ(".:\\ \"*?", ansi); 617bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 618bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 619bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_TRUE(wcsncmp(L".:\\ \"*?", utf16, 3) == 0); 620bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 621bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 622bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian#endif // _WIN32_WCE 623bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 624d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 625d201456903f3ecae1f7794edfab0d5678e64226shiqian 626d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty construction. 627d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, StringValue) { 628d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 629d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key", property.key()); 630d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 631d201456903f3ecae1f7794edfab0d5678e64226shiqian} 632d201456903f3ecae1f7794edfab0d5678e64226shiqian 633d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty replacing a value. 634d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, ReplaceStringValue) { 635d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 636d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 637d201456903f3ecae1f7794edfab0d5678e64226shiqian property.SetValue("2"); 638d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", property.value()); 639d201456903f3ecae1f7794edfab0d5678e64226shiqian} 640d201456903f3ecae1f7794edfab0d5678e64226shiqian 641d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestPartResult class. 642d201456903f3ecae1f7794edfab0d5678e64226shiqian 643d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestPartResult. 6449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestPartResultTest : public Test { 645d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 646d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultTest() 6479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian : r1_(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"), 6489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian r2_(TPRT_NONFATAL_FAILURE, "foo/bar.cc", -1, "Failure!"), 6499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian r3_(TPRT_FATAL_FAILURE, NULL, -1, "Failure!") {} 650d201456903f3ecae1f7794edfab0d5678e64226shiqian 651d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult r1_, r2_, r3_; 652d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 653d201456903f3ecae1f7794edfab0d5678e64226shiqian 654d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::type() 655d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, type) { 6569b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(TPRT_SUCCESS, r1_.type()); 6579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(TPRT_NONFATAL_FAILURE, r2_.type()); 6589b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(TPRT_FATAL_FAILURE, r3_.type()); 659d201456903f3ecae1f7794edfab0d5678e64226shiqian} 660d201456903f3ecae1f7794edfab0d5678e64226shiqian 661d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::file_name() 662d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, file_name) { 663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo/bar.cc", r1_.file_name()); 664d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(NULL, r3_.file_name()); 665d201456903f3ecae1f7794edfab0d5678e64226shiqian} 666d201456903f3ecae1f7794edfab0d5678e64226shiqian 667d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::line_number() 668d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, line_number) { 669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, r1_.line_number()); 670d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-1, r2_.line_number()); 671d201456903f3ecae1f7794edfab0d5678e64226shiqian} 672d201456903f3ecae1f7794edfab0d5678e64226shiqian 673d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::message() 674d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, message) { 675d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Success!", r1_.message()); 676d201456903f3ecae1f7794edfab0d5678e64226shiqian} 677d201456903f3ecae1f7794edfab0d5678e64226shiqian 678d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::passed() 679d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, Passed) { 680d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(r1_.passed()); 681d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r2_.passed()); 682d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r3_.passed()); 683d201456903f3ecae1f7794edfab0d5678e64226shiqian} 684d201456903f3ecae1f7794edfab0d5678e64226shiqian 685d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::failed() 686d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, Failed) { 687d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r1_.failed()); 688d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(r2_.failed()); 689d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(r3_.failed()); 690d201456903f3ecae1f7794edfab0d5678e64226shiqian} 691d201456903f3ecae1f7794edfab0d5678e64226shiqian 692d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::fatally_failed() 693d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, FatallyFailed) { 694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r1_.fatally_failed()); 695d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r2_.fatally_failed()); 696d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(r3_.fatally_failed()); 697d201456903f3ecae1f7794edfab0d5678e64226shiqian} 698d201456903f3ecae1f7794edfab0d5678e64226shiqian 699d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestPartResult::nonfatally_failed() 700d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultTest, NonfatallyFailed) { 701d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r1_.nonfatally_failed()); 702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(r2_.nonfatally_failed()); 703d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(r3_.nonfatally_failed()); 704d201456903f3ecae1f7794edfab0d5678e64226shiqian} 705d201456903f3ecae1f7794edfab0d5678e64226shiqian 706d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestPartResultArray class. 707d201456903f3ecae1f7794edfab0d5678e64226shiqian 7089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestPartResultArrayTest : public Test { 709d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 710d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultArrayTest() 7119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian : r1_(TPRT_NONFATAL_FAILURE, "foo/bar.cc", -1, "Failure 1"), 7129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian r2_(TPRT_FATAL_FAILURE, "foo/bar.cc", -1, "Failure 2") {} 713d201456903f3ecae1f7794edfab0d5678e64226shiqian 714d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestPartResult r1_, r2_; 715d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 716d201456903f3ecae1f7794edfab0d5678e64226shiqian 717d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that TestPartResultArray initially has size 0. 718d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultArrayTest, InitialSizeIsZero) { 719d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultArray results; 720d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, results.size()); 721d201456903f3ecae1f7794edfab0d5678e64226shiqian} 722d201456903f3ecae1f7794edfab0d5678e64226shiqian 723d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that TestPartResultArray contains the given TestPartResult 724d201456903f3ecae1f7794edfab0d5678e64226shiqian// after one Append() operation. 725d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultArrayTest, ContainsGivenResultAfterAppend) { 726d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultArray results; 727d201456903f3ecae1f7794edfab0d5678e64226shiqian results.Append(r1_); 728d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, results.size()); 729d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message()); 730d201456903f3ecae1f7794edfab0d5678e64226shiqian} 731d201456903f3ecae1f7794edfab0d5678e64226shiqian 732d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that TestPartResultArray contains the given TestPartResults 733d201456903f3ecae1f7794edfab0d5678e64226shiqian// after two Append() operations. 734d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestPartResultArrayTest, ContainsGivenResultsAfterTwoAppends) { 735d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultArray results; 736d201456903f3ecae1f7794edfab0d5678e64226shiqian results.Append(r1_); 737d201456903f3ecae1f7794edfab0d5678e64226shiqian results.Append(r2_); 738d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, results.size()); 739d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Failure 1", results.GetTestPartResult(0).message()); 740d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Failure 2", results.GetTestPartResult(1).message()); 741d201456903f3ecae1f7794edfab0d5678e64226shiqian} 742d201456903f3ecae1f7794edfab0d5678e64226shiqian 743d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ScopedFakeTestPartResultReporterTestHelper() { 744d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Expected fatal failure."; 745d201456903f3ecae1f7794edfab0d5678e64226shiqian} 746d201456903f3ecae1f7794edfab0d5678e64226shiqian 747d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ScopedFakeTestPartResultReporter intercepts test 748d201456903f3ecae1f7794edfab0d5678e64226shiqian// failures. 749d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 750d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResultArray results; 751d201456903f3ecae1f7794edfab0d5678e64226shiqian { 752d201456903f3ecae1f7794edfab0d5678e64226shiqian ScopedFakeTestPartResultReporter reporter(&results); 753d201456903f3ecae1f7794edfab0d5678e64226shiqian ADD_FAILURE() << "Expected non-fatal failure."; 754d201456903f3ecae1f7794edfab0d5678e64226shiqian ScopedFakeTestPartResultReporterTestHelper(); 755d201456903f3ecae1f7794edfab0d5678e64226shiqian } 756d201456903f3ecae1f7794edfab0d5678e64226shiqian 757d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, results.size()); 758d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 759d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 760d201456903f3ecae1f7794edfab0d5678e64226shiqian} 761d201456903f3ecae1f7794edfab0d5678e64226shiqian 762d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestResult class 763d201456903f3ecae1f7794edfab0d5678e64226shiqian 764d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestResult. 7659b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestResultTest : public Test { 766d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 767d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef List<TestPartResult> TPRList; 768d201456903f3ecae1f7794edfab0d5678e64226shiqian 769d201456903f3ecae1f7794edfab0d5678e64226shiqian // We make use of 2 TestPartResult objects, 770d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult * pr1, * pr2; 771d201456903f3ecae1f7794edfab0d5678e64226shiqian 772d201456903f3ecae1f7794edfab0d5678e64226shiqian // ... and 3 TestResult objects. 773d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult * r0, * r1, * r2; 774d201456903f3ecae1f7794edfab0d5678e64226shiqian 775d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 776d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr1 is for success. 7779b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr1 = new TestPartResult(TPRT_SUCCESS, "foo/bar.cc", 10, "Success!"); 778d201456903f3ecae1f7794edfab0d5678e64226shiqian 779d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr2 is for fatal failure. 7809b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian pr2 = new TestPartResult(TPRT_FATAL_FAILURE, "foo/bar.cc", 7819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian -1, // This line number means "unknown" 7829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "Failure!"); 783d201456903f3ecae1f7794edfab0d5678e64226shiqian 784d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates the TestResult objects. 785d201456903f3ecae1f7794edfab0d5678e64226shiqian r0 = new TestResult(); 786d201456903f3ecae1f7794edfab0d5678e64226shiqian r1 = new TestResult(); 787d201456903f3ecae1f7794edfab0d5678e64226shiqian r2 = new TestResult(); 788d201456903f3ecae1f7794edfab0d5678e64226shiqian 789d201456903f3ecae1f7794edfab0d5678e64226shiqian // In order to test TestResult, we need to modify its internal 790d201456903f3ecae1f7794edfab0d5678e64226shiqian // state, in particular the TestPartResult list it holds. 791d201456903f3ecae1f7794edfab0d5678e64226shiqian // test_part_results() returns a const reference to this list. 792d201456903f3ecae1f7794edfab0d5678e64226shiqian // We cast it to a non-const object s.t. it can be modified (yes, 793d201456903f3ecae1f7794edfab0d5678e64226shiqian // this is a hack). 794d201456903f3ecae1f7794edfab0d5678e64226shiqian TPRList * list1, * list2; 795d201456903f3ecae1f7794edfab0d5678e64226shiqian list1 = const_cast<List<TestPartResult> *>( 796d201456903f3ecae1f7794edfab0d5678e64226shiqian & r1->test_part_results()); 797d201456903f3ecae1f7794edfab0d5678e64226shiqian list2 = const_cast<List<TestPartResult> *>( 798d201456903f3ecae1f7794edfab0d5678e64226shiqian & r2->test_part_results()); 799d201456903f3ecae1f7794edfab0d5678e64226shiqian 800d201456903f3ecae1f7794edfab0d5678e64226shiqian // r0 is an empty TestResult. 801d201456903f3ecae1f7794edfab0d5678e64226shiqian 802d201456903f3ecae1f7794edfab0d5678e64226shiqian // r1 contains a single SUCCESS TestPartResult. 803d201456903f3ecae1f7794edfab0d5678e64226shiqian list1->PushBack(*pr1); 804d201456903f3ecae1f7794edfab0d5678e64226shiqian 805d201456903f3ecae1f7794edfab0d5678e64226shiqian // r2 contains a SUCCESS, and a FAILURE. 806d201456903f3ecae1f7794edfab0d5678e64226shiqian list2->PushBack(*pr1); 807d201456903f3ecae1f7794edfab0d5678e64226shiqian list2->PushBack(*pr2); 808d201456903f3ecae1f7794edfab0d5678e64226shiqian } 809d201456903f3ecae1f7794edfab0d5678e64226shiqian 810d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 811d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr1; 812d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr2; 813d201456903f3ecae1f7794edfab0d5678e64226shiqian 814d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r0; 815d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r1; 816d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r2; 817d201456903f3ecae1f7794edfab0d5678e64226shiqian } 818d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 819d201456903f3ecae1f7794edfab0d5678e64226shiqian 820d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_part_results() 821d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, test_part_results) { 822d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->test_part_results().size()); 823d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->test_part_results().size()); 824d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, r2->test_part_results().size()); 825d201456903f3ecae1f7794edfab0d5678e64226shiqian} 826d201456903f3ecae1f7794edfab0d5678e64226shiqian 827d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::successful_part_count() 828d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, successful_part_count) { 829d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->successful_part_count()); 830d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->successful_part_count()); 831d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r2->successful_part_count()); 832d201456903f3ecae1f7794edfab0d5678e64226shiqian} 833d201456903f3ecae1f7794edfab0d5678e64226shiqian 834d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::failed_part_count() 835d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, failed_part_count) { 836d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->failed_part_count()); 837d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r1->failed_part_count()); 838d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r2->failed_part_count()); 839d201456903f3ecae1f7794edfab0d5678e64226shiqian} 840d201456903f3ecae1f7794edfab0d5678e64226shiqian 841d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::total_part_count() 842d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, total_part_count) { 843d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, r0->total_part_count()); 844d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, r1->total_part_count()); 845d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, r2->total_part_count()); 846d201456903f3ecae1f7794edfab0d5678e64226shiqian} 847d201456903f3ecae1f7794edfab0d5678e64226shiqian 848d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::Passed() 849d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Passed) { 850d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r0->Passed()); 851d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r1->Passed()); 852d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r2->Passed()); 853d201456903f3ecae1f7794edfab0d5678e64226shiqian} 854d201456903f3ecae1f7794edfab0d5678e64226shiqian 855d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::Failed() 856d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Failed) { 857d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r0->Failed()); 858d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r1->Failed()); 859d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r2->Failed()); 860d201456903f3ecae1f7794edfab0d5678e64226shiqian} 861d201456903f3ecae1f7794edfab0d5678e64226shiqian 862d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has no properties when none are added. 863d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 864d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 865d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, test_result.test_properties().size()); 866d201456903f3ecae1f7794edfab0d5678e64226shiqian} 867d201456903f3ecae1f7794edfab0d5678e64226shiqian 868d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has the expected property when added. 869d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 870d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 871d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key_1", "1"); 872d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property); 873d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 874d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1u, properties.size()); 875d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property = properties.Head()->element(); 876d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property.key()); 877d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", actual_property.value()); 878d201456903f3ecae1f7794edfab0d5678e64226shiqian} 879d201456903f3ecae1f7794edfab0d5678e64226shiqian 880d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() has multiple properties when added. 881d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 882d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 883d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1("key_1", "1"); 884d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2("key_2", "2"); 885d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1); 886d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2); 887d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 888d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, properties.size()); 889d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_1 = properties.Head()->element(); 890d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property_1.key()); 891d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", actual_property_1.value()); 892d201456903f3ecae1f7794edfab0d5678e64226shiqian 893d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_2 = properties.Last()->element(); 894d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_2", actual_property_2.key()); 895d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", actual_property_2.value()); 896d201456903f3ecae1f7794edfab0d5678e64226shiqian} 897d201456903f3ecae1f7794edfab0d5678e64226shiqian 898d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestResult::test_properties() overrides values for duplicate keys. 899d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 900d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 901d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_1("key_1", "1"); 902d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_1("key_2", "2"); 903d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_2("key_1", "12"); 904d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_2("key_2", "22"); 905d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1_1); 906d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2_1); 907d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_1_2); 908d201456903f3ecae1f7794edfab0d5678e64226shiqian test_result.RecordProperty(property_2_2); 909d201456903f3ecae1f7794edfab0d5678e64226shiqian 910d201456903f3ecae1f7794edfab0d5678e64226shiqian const List<TestProperty>& properties = test_result.test_properties(); 911d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(2u, properties.size()); 912d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_1 = properties.Head()->element(); 913d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_1", actual_property_1.key()); 914d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("12", actual_property_1.value()); 915d201456903f3ecae1f7794edfab0d5678e64226shiqian 916d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty actual_property_2 = properties.Last()->element(); 917d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key_2", actual_property_2.key()); 918d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("22", actual_property_2.value()); 919d201456903f3ecae1f7794edfab0d5678e64226shiqian} 920d201456903f3ecae1f7794edfab0d5678e64226shiqian 921d201456903f3ecae1f7794edfab0d5678e64226shiqian// When a property using a reserved key is supplied to this function, it tests 922d201456903f3ecae1f7794edfab0d5678e64226shiqian// that a non-fatal failure is added, a fatal failure is not added, and that the 923d201456903f3ecae1f7794edfab0d5678e64226shiqian// property is not recorded. 924d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey(const char* key) { 925d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 926d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("name", "1"); 927d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(test_result.RecordProperty(property), "Reserved key"); 928d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(test_result.test_properties().IsEmpty()) << "Not recorded"; 929d201456903f3ecae1f7794edfab0d5678e64226shiqian} 930d201456903f3ecae1f7794edfab0d5678e64226shiqian 931d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "name" 932d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 933d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledName) { 934d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("name"); 935d201456903f3ecae1f7794edfab0d5678e64226shiqian} 936d201456903f3ecae1f7794edfab0d5678e64226shiqian 937d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "status" 938d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 939d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledStatus) { 940d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("status"); 941d201456903f3ecae1f7794edfab0d5678e64226shiqian} 942d201456903f3ecae1f7794edfab0d5678e64226shiqian 943d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "time" 944d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 945d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledTime) { 946d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("time"); 947d201456903f3ecae1f7794edfab0d5678e64226shiqian} 948d201456903f3ecae1f7794edfab0d5678e64226shiqian 949d201456903f3ecae1f7794edfab0d5678e64226shiqian// Attempting to recording a property with the Reserved literal "classname" 950d201456903f3ecae1f7794edfab0d5678e64226shiqian// should add a non-fatal failure and the property should not be recorded. 951d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, AddFailureWhenUsingReservedKeyCalledClassname) { 952d201456903f3ecae1f7794edfab0d5678e64226shiqian ExpectNonFatalFailureRecordingPropertyWithReservedKey("classname"); 953d201456903f3ecae1f7794edfab0d5678e64226shiqian} 954d201456903f3ecae1f7794edfab0d5678e64226shiqian 955d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTestFlagSaver works on Windows and Mac. 956d201456903f3ecae1f7794edfab0d5678e64226shiqian 9579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass GTestFlagSaverTest : public Test { 958d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 959d201456903f3ecae1f7794edfab0d5678e64226shiqian // Saves the Google Test flags such that we can restore them later, and 960d201456903f3ecae1f7794edfab0d5678e64226shiqian // then sets them to their default values. This will be called 961d201456903f3ecae1f7794edfab0d5678e64226shiqian // before the first test in this test case is run. 962d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 9639b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian saver_ = new GTestFlagSaver; 9649b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 9659b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = false; 9669b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = false; 9679b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "auto"; 9689b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = ""; 9699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = false; 9709b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = ""; 9719b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(print_time) = false; 9729b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 1; 973d201456903f3ecae1f7794edfab0d5678e64226shiqian } 974d201456903f3ecae1f7794edfab0d5678e64226shiqian 975d201456903f3ecae1f7794edfab0d5678e64226shiqian // Restores the Google Test flags that the tests have modified. This will 976d201456903f3ecae1f7794edfab0d5678e64226shiqian // be called after the last test in this test case is run. 977d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 978d201456903f3ecae1f7794edfab0d5678e64226shiqian delete saver_; 979d201456903f3ecae1f7794edfab0d5678e64226shiqian saver_ = NULL; 980d201456903f3ecae1f7794edfab0d5678e64226shiqian } 981d201456903f3ecae1f7794edfab0d5678e64226shiqian 982d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the Google Test flags have their default values, and then 983d201456903f3ecae1f7794edfab0d5678e64226shiqian // modifies each of them. 984d201456903f3ecae1f7794edfab0d5678e64226shiqian void VerifyAndModifyFlags() { 9859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 9869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 9879b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 9889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 9899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(list_tests)); 9909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 9919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(print_time)); 9929b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(1, GTEST_FLAG(repeat)); 9939b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 9949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = true; 9959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = true; 9969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "no"; 9979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = "abc"; 9989b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = true; 9999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = "xml:foo.xml"; 10009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(print_time) = true; 10019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 100; 1002d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1003d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1004d201456903f3ecae1f7794edfab0d5678e64226shiqian // For saving Google Test flags during this test case. 10059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian static GTestFlagSaver* saver_; 1006d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1007d201456903f3ecae1f7794edfab0d5678e64226shiqian 10089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 1009d201456903f3ecae1f7794edfab0d5678e64226shiqian 1010d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test doesn't guarantee the order of tests. The following two 1011d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests are designed to work regardless of their order. 1012d201456903f3ecae1f7794edfab0d5678e64226shiqian 1013d201456903f3ecae1f7794edfab0d5678e64226shiqian// Modifies the Google Test flags in the test body. 1014d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 1015d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1016d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1017d201456903f3ecae1f7794edfab0d5678e64226shiqian 1018d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that the Google Test flags in the body of the previous test were 1019d201456903f3ecae1f7794edfab0d5678e64226shiqian// restored to their original values. 1020d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 1021d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1022d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1023d201456903f3ecae1f7794edfab0d5678e64226shiqian 1024d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets an environment variable with the given name to the given 1025d201456903f3ecae1f7794edfab0d5678e64226shiqian// value. If the value argument is "", unsets the environment 1026d201456903f3ecae1f7794edfab0d5678e64226shiqian// variable. The caller must ensure that both arguments are not NULL. 1027d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic void SetEnv(const char* name, const char* value) { 1028d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef _WIN32_WCE 1029d201456903f3ecae1f7794edfab0d5678e64226shiqian // Environment variables are not supported on Windows CE. 1030d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1031d201456903f3ecae1f7794edfab0d5678e64226shiqian#elif defined(GTEST_OS_WINDOWS) // If we are on Windows proper. 10329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian _putenv((Message() << name << "=" << value).GetString().c_str()); 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1034d201456903f3ecae1f7794edfab0d5678e64226shiqian if (*value == '\0') { 1035d201456903f3ecae1f7794edfab0d5678e64226shiqian unsetenv(name); 1036d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1037d201456903f3ecae1f7794edfab0d5678e64226shiqian setenv(name, value, 1); 1038d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1039d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif 1040d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1041d201456903f3ecae1f7794edfab0d5678e64226shiqian 1042d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef _WIN32_WCE 1043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variables are not supported on Windows CE. 1044d201456903f3ecae1f7794edfab0d5678e64226shiqian 10459b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::Int32FromGTestEnv; 1046d201456903f3ecae1f7794edfab0d5678e64226shiqian 1047d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests Int32FromGTestEnv(). 1048d201456903f3ecae1f7794edfab0d5678e64226shiqian 1049d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1050d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable is not set. 1051d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 1052d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", ""); 1053d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 1054d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1055d201456903f3ecae1f7794edfab0d5678e64226shiqian 1056d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1057d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable overflows as an Int32. 1058d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 1059d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1060d201456903f3ecae1f7794edfab0d5678e64226shiqian 1061d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "12345678987654321"); 1062d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 1063d201456903f3ecae1f7794edfab0d5678e64226shiqian 1064d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "-12345678987654321"); 1065d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 1066d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1067d201456903f3ecae1f7794edfab0d5678e64226shiqian 1068d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1069d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable does not represent a valid decimal integer. 1070d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1072d201456903f3ecae1f7794edfab0d5678e64226shiqian 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "A1"); 1074d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian 1076d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "12X"); 1077d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 1078d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian 1080d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() parses and returns the value of the 1081d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable when it represents a valid decimal integer in 1082d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1083d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 1084d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "123"); 1085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 1086d201456903f3ecae1f7794edfab0d5678e64226shiqian 1087d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv(GTEST_FLAG_PREFIX_UPPER "TEMP", "-321"); 1088d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 1089d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1090d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // !defined(_WIN32_WCE) 1091d201456903f3ecae1f7794edfab0d5678e64226shiqian 1092d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ParseInt32Flag(). 1093d201456903f3ecae1f7794edfab0d5678e64226shiqian 1094d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1095d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag has wrong format 1096d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 1097d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1098d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 1099d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1100d201456903f3ecae1f7794edfab0d5678e64226shiqian 1101d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 1102d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1103d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1104d201456903f3ecae1f7794edfab0d5678e64226shiqian 1105d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1106d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag overflows as an Int32. 1107d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 1108d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1109d201456903f3ecae1f7794edfab0d5678e64226shiqian 1110d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1111d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 1112d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1113d201456903f3ecae1f7794edfab0d5678e64226shiqian 1114d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 1115d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1116d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1117d201456903f3ecae1f7794edfab0d5678e64226shiqian 1118d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1119d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag does not represent a valid decimal 1120d201456903f3ecae1f7794edfab0d5678e64226shiqian// integer. 1121d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 1122d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1123d201456903f3ecae1f7794edfab0d5678e64226shiqian 1124d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1125d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 1126d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1127d201456903f3ecae1f7794edfab0d5678e64226shiqian 1128d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 1129d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1130d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1131d201456903f3ecae1f7794edfab0d5678e64226shiqian 1132d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() parses the value of the flag and 1133d201456903f3ecae1f7794edfab0d5678e64226shiqian// returns true when the flag represents a valid decimal integer in 1134d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1135d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 1136d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1137d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX "abc=456", "abc", &value)); 1138d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(456, value); 1139d201456903f3ecae1f7794edfab0d5678e64226shiqian 1140d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX "abc=-789", "abc", &value)); 1141d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-789, value); 1142d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1143d201456903f3ecae1f7794edfab0d5678e64226shiqian 1144d201456903f3ecae1f7794edfab0d5678e64226shiqian// For the same reason we are not explicitly testing everything in the 1145019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Test class, there are no separate tests for the following classes 1146019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// (except for some trivial cases): 1147d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1148d201456903f3ecae1f7794edfab0d5678e64226shiqian// TestCase, UnitTest, UnitTestResultPrinter. 1149d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1150d201456903f3ecae1f7794edfab0d5678e64226shiqian// Similarly, there are no separate tests for the following macros: 1151d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1152d201456903f3ecae1f7794edfab0d5678e64226shiqian// TEST, TEST_F, RUN_ALL_TESTS 1153d201456903f3ecae1f7794edfab0d5678e64226shiqian 1154019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST(UnitTestTest, CanGetOriginalWorkingDir) { 1155019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 1156019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 1157019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 1158019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 1159d201456903f3ecae1f7794edfab0d5678e64226shiqian// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 1160d201456903f3ecae1f7794edfab0d5678e64226shiqian// of various arities. They do not attempt to be exhaustive. Rather, 1161d201456903f3ecae1f7794edfab0d5678e64226shiqian// view them as smoke tests that can be easily reviewed and verified. 1162d201456903f3ecae1f7794edfab0d5678e64226shiqian// A more complete set of tests for predicate assertions can be found 1163d201456903f3ecae1f7794edfab0d5678e64226shiqian// in gtest_pred_impl_unittest.cc. 1164d201456903f3ecae1f7794edfab0d5678e64226shiqian 1165d201456903f3ecae1f7794edfab0d5678e64226shiqian// First, some predicates and predicate-formatters needed by the tests. 1166d201456903f3ecae1f7794edfab0d5678e64226shiqian 1167d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the argument is an even number. 1168d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsEven(int n) { 1169d201456903f3ecae1f7794edfab0d5678e64226shiqian return (n % 2) == 0; 1170d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1171d201456903f3ecae1f7794edfab0d5678e64226shiqian 1172d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the argument is an even number. 1173d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct IsEvenFunctor { 1174d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n) { return IsEven(n); } 1175d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1176d201456903f3ecae1f7794edfab0d5678e64226shiqian 1177d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the argument is an even 1178d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 11799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertIsEven(const char* expr, int n) { 1180d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(n)) { 11819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1182d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1183d201456903f3ecae1f7794edfab0d5678e64226shiqian 11849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1185d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << expr << " evaluates to " << n << ", which is not even."; 11869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1187d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1188d201456903f3ecae1f7794edfab0d5678e64226shiqian 1189d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the argument is an even 1190d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1191d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertIsEvenFunctor { 11929b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()(const char* expr, int n) { 1193d201456903f3ecae1f7794edfab0d5678e64226shiqian return AssertIsEven(expr, n); 1194d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1195d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1196d201456903f3ecae1f7794edfab0d5678e64226shiqian 1197d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the sum of the arguments is an even number. 1198d201456903f3ecae1f7794edfab0d5678e64226shiqianbool SumIsEven2(int n1, int n2) { 1199d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2); 1200d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1201d201456903f3ecae1f7794edfab0d5678e64226shiqian 1202d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the sum of the arguments is an even 1203d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 1204d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct SumIsEven3Functor { 1205d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n1, int n2, int n3) { 1206d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2 + n3); 1207d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1208d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1209d201456903f3ecae1f7794edfab0d5678e64226shiqian 1210d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the sum of the 1211d201456903f3ecae1f7794edfab0d5678e64226shiqian// arguments is an even number. 12129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertSumIsEven4( 12139b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 12149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian int n1, int n2, int n3, int n4) { 1215d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4; 1216d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 12179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1218d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1219d201456903f3ecae1f7794edfab0d5678e64226shiqian 12209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1221d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 1222d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 1223d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 12249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1225d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1226d201456903f3ecae1f7794edfab0d5678e64226shiqian 1227d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the sum of the arguments 1228d201456903f3ecae1f7794edfab0d5678e64226shiqian// is an even number. 1229d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertSumIsEven5Functor { 12309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()( 12319b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 12329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e5, int n1, int n2, int n3, int n4, int n5) { 1233d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4 + n5; 1234d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 12359b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 1236d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1237d201456903f3ecae1f7794edfab0d5678e64226shiqian 12389b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 1239d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 1240d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" 1241d201456903f3ecae1f7794edfab0d5678e64226shiqian << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 1242d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 12439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 1244d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1245d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1246d201456903f3ecae1f7794edfab0d5678e64226shiqian 1247d201456903f3ecae1f7794edfab0d5678e64226shiqian 1248d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions. 1249d201456903f3ecae1f7794edfab0d5678e64226shiqian 1250d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that don't use a custom formatter. 1251d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithoutFormat) { 1252d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1253d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 1254d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsEven, 4); 1255d201456903f3ecae1f7794edfab0d5678e64226shiqian 1256d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1258d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 1259d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1260d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 1261d201456903f3ecae1f7794edfab0d5678e64226shiqian "evaluates to false"); 1262d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1263d201456903f3ecae1f7794edfab0d5678e64226shiqian 1264d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that use a custom formatter. 1265d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithFormat) { 1266d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1267d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(AssertIsEven, 2); 1268d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 1269d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 1270d201456903f3ecae1f7794edfab0d5678e64226shiqian 1271d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1272d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n = 5; 1273d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 1274d201456903f3ecae1f7794edfab0d5678e64226shiqian "n evaluates to 5, which is not even."); 1275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1276d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 1277d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1278d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1279d201456903f3ecae1f7794edfab0d5678e64226shiqian 1280d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that unary predicate assertions evaluates their arguments 1281d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 1282d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, SingleEvaluationOnFailure) { 1283d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 1284d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 1285d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, n++); 1286d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 1287d201456903f3ecae1f7794edfab0d5678e64226shiqian 1288d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 1289d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1290d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 1291d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1292d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 1294d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1295d201456903f3ecae1f7794edfab0d5678e64226shiqian 1296d201456903f3ecae1f7794edfab0d5678e64226shiqian 1297d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions whose arity is >= 2. 1298d201456903f3ecae1f7794edfab0d5678e64226shiqian 1299d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that don't use a custom formatter. 1300d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithoutFormat) { 1301d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1302d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 1303d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 1304d201456903f3ecae1f7794edfab0d5678e64226shiqian 1305d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1306d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 1307d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 1308d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1309d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 1310d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1311d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1312d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 1313d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to false"); 1314d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1315d201456903f3ecae1f7794edfab0d5678e64226shiqian 1316d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that use a custom formatter. 1317d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithFormat) { 1318d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 1319d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 1320d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is UNEXPECTED!"; 1321d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 1322d201456903f3ecae1f7794edfab0d5678e64226shiqian 1323d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 1324d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 1325d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 1326d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n3 = 4; 1327d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n4 = 6; 1328d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1329d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 1330d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 13, which is not even."); 1331d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1332d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 1333d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1334d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1335d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1336d201456903f3ecae1f7794edfab0d5678e64226shiqian 1337d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that predicate assertions evaluates their arguments 1338d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 1339d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, SingleEvaluationOnFailure) { 1340d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 1341d201456903f3ecae1f7794edfab0d5678e64226shiqian int n1 = 0; 1342d201456903f3ecae1f7794edfab0d5678e64226shiqian int n2 = 0; 1343d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1++, n2++); 1344d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1345d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1346d201456903f3ecae1f7794edfab0d5678e64226shiqian 1347d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another success case. 1348d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = 0; 1349d201456903f3ecae1f7794edfab0d5678e64226shiqian int n3 = 0; 1350d201456903f3ecae1f7794edfab0d5678e64226shiqian int n4 = 0; 1351d201456903f3ecae1f7794edfab0d5678e64226shiqian int n5 = 0; 1352d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1353d201456903f3ecae1f7794edfab0d5678e64226shiqian n1++, n2++, n3++, n4++, n5++) 1354d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 1355d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1356d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1357d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1358d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 1359d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 1360d201456903f3ecae1f7794edfab0d5678e64226shiqian 1361d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 1362d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = 0; 1363d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1364d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 1365d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 1366d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 1367d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1368d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1369d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1370d201456903f3ecae1f7794edfab0d5678e64226shiqian 1371d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another failure case. 1372d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = n4 = 0; 1373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1374d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 1375d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 1, which is not even."); 1376d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 1377d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 1378d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 1379d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 1380d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1381d201456903f3ecae1f7794edfab0d5678e64226shiqian 1382d201456903f3ecae1f7794edfab0d5678e64226shiqian 1383d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 1384d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PREDn and EXPECT_PREDn. 1385d201456903f3ecae1f7794edfab0d5678e64226shiqian 1386d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(int n) { 1387d201456903f3ecae1f7794edfab0d5678e64226shiqian return n > 0; 1388d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1389d201456903f3ecae1f7794edfab0d5678e64226shiqian 1390d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(double x) { 1391d201456903f3ecae1f7794edfab0d5678e64226shiqian return x > 0; 1392d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1393d201456903f3ecae1f7794edfab0d5678e64226shiqian 1394d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 1395d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsNegative(T x) { 1396d201456903f3ecae1f7794edfab0d5678e64226shiqian return x < 0; 1397d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1398d201456903f3ecae1f7794edfab0d5678e64226shiqian 1399d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 1400d201456903f3ecae1f7794edfab0d5678e64226shiqianbool GreaterThan(T1 x1, T2 x2) { 1401d201456903f3ecae1f7794edfab0d5678e64226shiqian return x1 > x2; 1402d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1403d201456903f3ecae1f7794edfab0d5678e64226shiqian 1404d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED* as long as 1405d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 1406d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 1407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(static_cast<bool (*)(int)>(IsPositive), 5); // NOLINT 1408d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(static_cast<bool (*)(double)>(IsPositive), 6.0); // NOLINT 1409d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1410d201456903f3ecae1f7794edfab0d5678e64226shiqian 1411d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED* as long as 1412d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 1413d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 1414d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsNegative<int>, -5); 1415d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes sure that we can handle templates with more than one 1416d201456903f3ecae1f7794edfab0d5678e64226shiqian // parameter. 1417d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 1418d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1419d201456903f3ecae1f7794edfab0d5678e64226shiqian 1420d201456903f3ecae1f7794edfab0d5678e64226shiqian 1421d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 1422d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 1423d201456903f3ecae1f7794edfab0d5678e64226shiqian 14249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult IsPositiveFormat(const char* expr, int n) { 14259b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return n > 0 ? AssertionSuccess() : 14269b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1427d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1428d201456903f3ecae1f7794edfab0d5678e64226shiqian 14299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult IsPositiveFormat(const char* expr, double x) { 14309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x > 0 ? AssertionSuccess() : 14319b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1432d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1433d201456903f3ecae1f7794edfab0d5678e64226shiqian 1434d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 14359b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult IsNegativeFormat(const char* expr, T x) { 14369b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x < 0 ? AssertionSuccess() : 14379b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1438d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1439d201456903f3ecae1f7794edfab0d5678e64226shiqian 1440d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 14419b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult EqualsFormat(const char* expr1, const char* expr2, 14429b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const T1& x1, const T2& x2) { 14439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x1 == x2 ? AssertionSuccess() : 14449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 1445d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1446d201456903f3ecae1f7794edfab0d5678e64226shiqian 1447d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED_FORMAT* 1448d201456903f3ecae1f7794edfab0d5678e64226shiqian// without explictly specifying their types. 1449d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 1450d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 1451d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 1452d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1453d201456903f3ecae1f7794edfab0d5678e64226shiqian 1454d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED_FORMAT* without 1455d201456903f3ecae1f7794edfab0d5678e64226shiqian// explicitly specifying their types. 1456d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 1457d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 1458d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 1459d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1460d201456903f3ecae1f7794edfab0d5678e64226shiqian 1461d201456903f3ecae1f7794edfab0d5678e64226shiqian 1462d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests string assertions. 1463d201456903f3ecae1f7794edfab0d5678e64226shiqian 1464d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with non-NULL arguments. 1465d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ) { 1466d201456903f3ecae1f7794edfab0d5678e64226shiqian const char * const p1 = "good"; 1467d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p1); 1468d201456903f3ecae1f7794edfab0d5678e64226shiqian 1469d201456903f3ecae1f7794edfab0d5678e64226shiqian // Let p2 have the same content as p1, but be at a different address. 1470d201456903f3ecae1f7794edfab0d5678e64226shiqian const char p2[] = "good"; 1471d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p2); 1472d201456903f3ecae1f7794edfab0d5678e64226shiqian 1473d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 1474d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: \"bad\""); 1475d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1476d201456903f3ecae1f7794edfab0d5678e64226shiqian 1477d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 1478d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null) { 1479d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 1480d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 1481d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 1482d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1483d201456903f3ecae1f7794edfab0d5678e64226shiqian 1484d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 1485d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 1486d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 1487d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 1488d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1489d201456903f3ecae1f7794edfab0d5678e64226shiqian 1490d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRNE. 1491d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRNE) { 1492d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("hi", "Hi"); 1493d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", NULL); 1494d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, "Hi"); 1495d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", NULL); 1496d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, ""); 1497d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", "Hi"); 1498d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", ""); 1499d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 1500d201456903f3ecae1f7794edfab0d5678e64226shiqian "\"Hi\" vs \"Hi\""); 1501d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1502d201456903f3ecae1f7794edfab0d5678e64226shiqian 1503d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASEEQ. 1504d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 1505d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("hi", "Hi"); 1506d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 1507d201456903f3ecae1f7794edfab0d5678e64226shiqian 1508d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("", ""); 1509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 1510d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 1511d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1512d201456903f3ecae1f7794edfab0d5678e64226shiqian 1513d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASENE. 1514d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASENE) { 1515d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("hi1", "Hi2"); 1516d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", NULL); 1517d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, "Hi"); 1518d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", NULL); 1519d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, ""); 1520d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", "Hi"); 1521d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", ""); 1522d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 1523d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 1524d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1525d201456903f3ecae1f7794edfab0d5678e64226shiqian 1526d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STREQ on wide strings. 1527d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STREQ_Wide) { 1528d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 1529d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 1530d201456903f3ecae1f7794edfab0d5678e64226shiqian 1531d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 1532d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(L"", L""); 1533d201456903f3ecae1f7794edfab0d5678e64226shiqian 1534d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 1535d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 1536d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 1537d201456903f3ecae1f7794edfab0d5678e64226shiqian 1538d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 1539d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(L"Hi", L"Hi"); 1540d201456903f3ecae1f7794edfab0d5678e64226shiqian 1541d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 1542d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 1543d201456903f3ecae1f7794edfab0d5678e64226shiqian "Abc"); 1544d201456903f3ecae1f7794edfab0d5678e64226shiqian 1545d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 1546d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 1547d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 1548d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1549d201456903f3ecae1f7794edfab0d5678e64226shiqian 1550d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STRNE on wide strings. 1551d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STRNE_Wide) { 1552d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 1553d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 1554d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 1555d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 1556d201456903f3ecae1f7794edfab0d5678e64226shiqian 1557d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 1558d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 1559d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"\""); 1560d201456903f3ecae1f7794edfab0d5678e64226shiqian 1561d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 1562d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(L"non-null", NULL); 1563d201456903f3ecae1f7794edfab0d5678e64226shiqian 1564d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 1565d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 1566d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"Hi\""); 1567d201456903f3ecae1f7794edfab0d5678e64226shiqian 1568d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 1569d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(L"abc", L"Abc"); 1570d201456903f3ecae1f7794edfab0d5678e64226shiqian 1571d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 1572d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 1573d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 1574d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1575d201456903f3ecae1f7794edfab0d5678e64226shiqian 1576d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsSubstring(). 1577d201456903f3ecae1f7794edfab0d5678e64226shiqian 1578d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 1579d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 1580d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 1581d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 1582d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 1583d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 1584d201456903f3ecae1f7794edfab0d5678e64226shiqian 1585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 1586d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 1587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1588d201456903f3ecae1f7794edfab0d5678e64226shiqian 1589d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 1590d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 1591d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 1592d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, L"a")); 1593d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"b", NULL)); 1594d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 1595d201456903f3ecae1f7794edfab0d5678e64226shiqian 1596d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 1597d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 1598d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1599d201456903f3ecae1f7794edfab0d5678e64226shiqian 1600d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 1601d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 1602d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 1603d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 1604d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 1605d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 1606d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"haystack\"", 16079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring("needle_expr", "haystack_expr", 16089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "needle", "haystack").failure_message()); 1609d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1610d201456903f3ecae1f7794edfab0d5678e64226shiqian 1611d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 1612d201456903f3ecae1f7794edfab0d5678e64226shiqian 1613d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 1614d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 1615d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 16169b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 16179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 1618d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1619d201456903f3ecae1f7794edfab0d5678e64226shiqian 1620d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 1621d201456903f3ecae1f7794edfab0d5678e64226shiqian 1622d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 1623d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 1624d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 1625d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 1626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 1627d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 1628d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1629d201456903f3ecae1f7794edfab0d5678e64226shiqian 1630d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 1631d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 1632d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 1633d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 1634d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 1635d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 1636d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"haystack\"", 16379b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring( 1638d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 1639d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring(L"needle"), L"haystack").failure_message()); 1640d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1641d201456903f3ecae1f7794edfab0d5678e64226shiqian 1642d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 1643d201456903f3ecae1f7794edfab0d5678e64226shiqian 1644d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsNotSubstring(). 1645d201456903f3ecae1f7794edfab0d5678e64226shiqian 1646d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 1647d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 1648d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 1649d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 1650d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 1651d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1652d201456903f3ecae1f7794edfab0d5678e64226shiqian 1653d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 1654d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 1655d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 1656d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 1657d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 1658d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1659d201456903f3ecae1f7794edfab0d5678e64226shiqian 1660d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 1661d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 1662d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 1663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 1664d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 1665d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 1666d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"two needles\"", 16679b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 1668d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 1669d201456903f3ecae1f7794edfab0d5678e64226shiqian L"needle", L"two needles").failure_message()); 1670d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1671d201456903f3ecae1f7794edfab0d5678e64226shiqian 1672d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 1673d201456903f3ecae1f7794edfab0d5678e64226shiqian 1674d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 1675d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 1676d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 1677d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 1678d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 1679d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1680d201456903f3ecae1f7794edfab0d5678e64226shiqian 1681d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 1682d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 1683d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 1684d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 1685d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 1686d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 1687d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"two needles\"", 16889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 1689d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 1690d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::string("needle"), "two needles").failure_message()); 1691d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1692d201456903f3ecae1f7794edfab0d5678e64226shiqian 1693d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 1694d201456903f3ecae1f7794edfab0d5678e64226shiqian 1695d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 1696d201456903f3ecae1f7794edfab0d5678e64226shiqian 1697d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 1698d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 1699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 1700d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE( 1701d201456903f3ecae1f7794edfab0d5678e64226shiqian IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 1702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 1703d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1704d201456903f3ecae1f7794edfab0d5678e64226shiqian 1705d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 1706d201456903f3ecae1f7794edfab0d5678e64226shiqian 1707d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests floating-point assertions. 1708d201456903f3ecae1f7794edfab0d5678e64226shiqian 1709d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 17109b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FloatingPointTest : public Test { 1711d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1712d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename testing::internal::FloatingPoint<RawType> Floating; 1713d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename Floating::Bits Bits; 1714d201456903f3ecae1f7794edfab0d5678e64226shiqian 1715d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 1716d201456903f3ecae1f7794edfab0d5678e64226shiqian const size_t max_ulps = Floating::kMaxUlps; 1717d201456903f3ecae1f7794edfab0d5678e64226shiqian 1718d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 0.0. 1719d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits zero_bits = Floating(0).bits(); 1720d201456903f3ecae1f7794edfab0d5678e64226shiqian 1721d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 0.0. 1722d201456903f3ecae1f7794edfab0d5678e64226shiqian close_to_positive_zero_ = Floating::ReinterpretBits(zero_bits + max_ulps/2); 1723d201456903f3ecae1f7794edfab0d5678e64226shiqian close_to_negative_zero_ = -Floating::ReinterpretBits( 1724d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps - max_ulps/2); 1725d201456903f3ecae1f7794edfab0d5678e64226shiqian further_from_negative_zero_ = -Floating::ReinterpretBits( 1726d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps + 1 - max_ulps/2); 1727d201456903f3ecae1f7794edfab0d5678e64226shiqian 1728d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 1.0. 1729d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits one_bits = Floating(1).bits(); 1730d201456903f3ecae1f7794edfab0d5678e64226shiqian 1731d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 1.0. 1732d201456903f3ecae1f7794edfab0d5678e64226shiqian close_to_one_ = Floating::ReinterpretBits(one_bits + max_ulps); 1733d201456903f3ecae1f7794edfab0d5678e64226shiqian further_from_one_ = Floating::ReinterpretBits(one_bits + max_ulps + 1); 1734d201456903f3ecae1f7794edfab0d5678e64226shiqian 1735d201456903f3ecae1f7794edfab0d5678e64226shiqian // +infinity. 1736d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_ = Floating::Infinity(); 1737d201456903f3ecae1f7794edfab0d5678e64226shiqian 1738d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent +infinity. 1739d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits infinity_bits = Floating(infinity_).bits(); 1740d201456903f3ecae1f7794edfab0d5678e64226shiqian 1741d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to infinity. 1742d201456903f3ecae1f7794edfab0d5678e64226shiqian close_to_infinity_ = Floating::ReinterpretBits(infinity_bits - max_ulps); 1743d201456903f3ecae1f7794edfab0d5678e64226shiqian further_from_infinity_ = Floating::ReinterpretBits( 1744d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_bits - max_ulps - 1); 1745d201456903f3ecae1f7794edfab0d5678e64226shiqian 1746d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some NAN's. 1747d201456903f3ecae1f7794edfab0d5678e64226shiqian nan1_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 1); 1748d201456903f3ecae1f7794edfab0d5678e64226shiqian nan2_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 200); 1749d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1750d201456903f3ecae1f7794edfab0d5678e64226shiqian 1751d201456903f3ecae1f7794edfab0d5678e64226shiqian void TestSize() { 1752d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 1753d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1754d201456903f3ecae1f7794edfab0d5678e64226shiqian 1755d201456903f3ecae1f7794edfab0d5678e64226shiqian // Pre-calculated numbers to be used by the tests. 1756d201456903f3ecae1f7794edfab0d5678e64226shiqian 1757d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType close_to_positive_zero_; 1758d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType close_to_negative_zero_; 1759d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType further_from_negative_zero_; 1760d201456903f3ecae1f7794edfab0d5678e64226shiqian 1761d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType close_to_one_; 1762d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType further_from_one_; 1763d201456903f3ecae1f7794edfab0d5678e64226shiqian 1764d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType infinity_; 1765d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType close_to_infinity_; 1766d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType further_from_infinity_; 1767d201456903f3ecae1f7794edfab0d5678e64226shiqian 1768d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType nan1_; 1769d201456903f3ecae1f7794edfab0d5678e64226shiqian static RawType nan2_; 1770d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1771d201456903f3ecae1f7794edfab0d5678e64226shiqian 1772d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1773d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::close_to_positive_zero_; 1774d201456903f3ecae1f7794edfab0d5678e64226shiqian 1775d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1776d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::close_to_negative_zero_; 1777d201456903f3ecae1f7794edfab0d5678e64226shiqian 1778d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1779d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::further_from_negative_zero_; 1780d201456903f3ecae1f7794edfab0d5678e64226shiqian 1781d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1782d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::close_to_one_; 1783d201456903f3ecae1f7794edfab0d5678e64226shiqian 1784d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1785d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::further_from_one_; 1786d201456903f3ecae1f7794edfab0d5678e64226shiqian 1787d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1788d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::infinity_; 1789d201456903f3ecae1f7794edfab0d5678e64226shiqian 1790d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1791d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::close_to_infinity_; 1792d201456903f3ecae1f7794edfab0d5678e64226shiqian 1793d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1794d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::further_from_infinity_; 1795d201456903f3ecae1f7794edfab0d5678e64226shiqian 1796d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1797d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::nan1_; 1798d201456903f3ecae1f7794edfab0d5678e64226shiqian 1799d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 1800d201456903f3ecae1f7794edfab0d5678e64226shiqianRawType FloatingPointTest<RawType>::nan2_; 1801d201456903f3ecae1f7794edfab0d5678e64226shiqian 1802d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 1803d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<float> FloatTest; 1804d201456903f3ecae1f7794edfab0d5678e64226shiqian 1805d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Float::Bits matches the size of float. 1806d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Size) { 1807d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 1808d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1809d201456903f3ecae1f7794edfab0d5678e64226shiqian 1810d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 1811d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Zeros) { 1812d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, -0.0); 1813d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 1814d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 1815d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 1816d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.5"); 1817d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1818d201456903f3ecae1f7794edfab0d5678e64226shiqian 1819d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 1820d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1821d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_FLOAT_EQ handles the sign correctly and no 1822d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 1823d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 1824d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, AlmostZeros) { 1825d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, close_to_positive_zero_); 1826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(-0.0, close_to_negative_zero_); 1827d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(close_to_positive_zero_, close_to_negative_zero_); 1828d201456903f3ecae1f7794edfab0d5678e64226shiqian 1829d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1830d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(close_to_positive_zero_, further_from_negative_zero_); 1831d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "further_from_negative_zero_"); 1832d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1833d201456903f3ecae1f7794edfab0d5678e64226shiqian 1834d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 1835d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, SmallDiff) { 1836d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, close_to_one_); 1837d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, further_from_one_), 1838d201456903f3ecae1f7794edfab0d5678e64226shiqian "further_from_one_"); 1839d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1840d201456903f3ecae1f7794edfab0d5678e64226shiqian 1841d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 1842d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, LargeDiff) { 1843d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 1844d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 1845d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1846d201456903f3ecae1f7794edfab0d5678e64226shiqian 1847d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 1848d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1849d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 1850d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 1851d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Infinity) { 1852d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(infinity_, close_to_infinity_); 1853d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(-infinity_, -close_to_infinity_); 1854d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(infinity_, -infinity_), 1855d201456903f3ecae1f7794edfab0d5678e64226shiqian "-infinity_"); 1856d201456903f3ecae1f7794edfab0d5678e64226shiqian 1857d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 1858d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 1859d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(infinity_, nan1_), 1860d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan1_"); 1861d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1862d201456903f3ecae1f7794edfab0d5678e64226shiqian 1863d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 1864d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, NaN) { 1865d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(nan1_, nan1_), 1866d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan1_"); 1867d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(nan1_, nan2_), 1868d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan2_"); 1869d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, nan1_), 1870d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan1_"); 1871d201456903f3ecae1f7794edfab0d5678e64226shiqian 1872d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(nan1_, infinity_), 1873d201456903f3ecae1f7794edfab0d5678e64226shiqian "infinity_"); 1874d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1875d201456903f3ecae1f7794edfab0d5678e64226shiqian 1876d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are reflexive. 1877d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Reflexive) { 1878d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, 0.0); 1879d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0); 1880d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(infinity_, infinity_); 1881d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1882d201456903f3ecae1f7794edfab0d5678e64226shiqian 1883d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are commutative. 1884d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Commutative) { 1885d201456903f3ecae1f7794edfab0d5678e64226shiqian // We already tested EXPECT_FLOAT_EQ(1.0, close_to_one_). 1886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(close_to_one_, 1.0); 1887d201456903f3ecae1f7794edfab0d5678e64226shiqian 1888d201456903f3ecae1f7794edfab0d5678e64226shiqian // We already tested EXPECT_FLOAT_EQ(1.0, further_from_one_). 1889d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(further_from_one_, 1.0), 1890d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 1891d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1892d201456903f3ecae1f7794edfab0d5678e64226shiqian 1893d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 1894d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, EXPECT_NEAR) { 1895d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 1896d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0f, 3.0f, 1.0f); 1897d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 1898d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 1899d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 1900d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 1901d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 1902d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1903d201456903f3ecae1f7794edfab0d5678e64226shiqian 1904d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 1905d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, ASSERT_NEAR) { 1906d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 1907d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0f, 3.0f, 1.0f); 1908d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.2f, 0.1f), // NOLINT 1909d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0f and 1.2f is 0.2, " 1910d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1f"); 1911d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 1912d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 1913d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1914d201456903f3ecae1f7794edfab0d5678e64226shiqian 1915d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should succeed. 1916d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLESucceeds) { 19179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 19189b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 1919d201456903f3ecae1f7794edfab0d5678e64226shiqian 1920d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 19219b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, close_to_positive_zero_, 0.0f); 1922d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1923d201456903f3ecae1f7794edfab0d5678e64226shiqian 1924d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should fail. 1925d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLEFails) { 1926d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 19279b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 1928d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0f) <= (1.0f)"); 1929d201456903f3ecae1f7794edfab0d5678e64226shiqian 1930d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 1931d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 19329b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, further_from_one_, 1.0f); 1933d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(further_from_one_) <= (1.0f)"); 1934d201456903f3ecae1f7794edfab0d5678e64226shiqian 1935d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when either val1 or val2 is NaN. 1936d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 19379b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, nan1_, infinity_); 1938d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(nan1_) <= (infinity_)"); 1939d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 19409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, -infinity_, nan1_); 1941d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(-infinity_) <= (nan1_)"); 1942d201456903f3ecae1f7794edfab0d5678e64226shiqian 1943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 19449b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, nan1_, nan1_); 1945d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(nan1_) <= (nan1_)"); 1946d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1947d201456903f3ecae1f7794edfab0d5678e64226shiqian 1948d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 1949d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<double> DoubleTest; 1950d201456903f3ecae1f7794edfab0d5678e64226shiqian 1951d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Double::Bits matches the size of double. 1952d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Size) { 1953d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 1954d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1955d201456903f3ecae1f7794edfab0d5678e64226shiqian 1956d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 1957d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Zeros) { 1958d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, -0.0); 1959d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 1960d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 1961d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 1962d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 1963d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1964d201456903f3ecae1f7794edfab0d5678e64226shiqian 1965d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 1966d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1967d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_DOUBLE_EQ handles the sign correctly and no 1968d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 1969d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 1970d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, AlmostZeros) { 1971d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, close_to_positive_zero_); 1972d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(-0.0, close_to_negative_zero_); 1973d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(close_to_positive_zero_, close_to_negative_zero_); 1974d201456903f3ecae1f7794edfab0d5678e64226shiqian 1975d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 1976d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DOUBLE_EQ(close_to_positive_zero_, further_from_negative_zero_); 1977d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "further_from_negative_zero_"); 1978d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1979d201456903f3ecae1f7794edfab0d5678e64226shiqian 1980d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 1981d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, SmallDiff) { 1982d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, close_to_one_); 1983d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, further_from_one_), 1984d201456903f3ecae1f7794edfab0d5678e64226shiqian "further_from_one_"); 1985d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1986d201456903f3ecae1f7794edfab0d5678e64226shiqian 1987d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 1988d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, LargeDiff) { 1989d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 1990d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 1991d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1992d201456903f3ecae1f7794edfab0d5678e64226shiqian 1993d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 1994d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1995d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 1996d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 1997d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Infinity) { 1998d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(infinity_, close_to_infinity_); 1999d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(-infinity_, -close_to_infinity_); 2000d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(infinity_, -infinity_), 2001d201456903f3ecae1f7794edfab0d5678e64226shiqian "-infinity_"); 2002d201456903f3ecae1f7794edfab0d5678e64226shiqian 2003d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 2004d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2005d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(infinity_, nan1_), 2006d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan1_"); 2007d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2008d201456903f3ecae1f7794edfab0d5678e64226shiqian 2009d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2010d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, NaN) { 2011d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(nan1_, nan1_), 2012d201456903f3ecae1f7794edfab0d5678e64226shiqian "nan1_"); 2013d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(nan1_, nan2_), "nan2_"); 2014d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, nan1_), "nan1_"); 2015d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(nan1_, infinity_), "infinity_"); 2016d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2017d201456903f3ecae1f7794edfab0d5678e64226shiqian 2018d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are reflexive. 2019d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Reflexive) { 2020d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, 0.0); 2021d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, 1.0); 2022d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_DOUBLE_EQ(infinity_, infinity_); 2023d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2024d201456903f3ecae1f7794edfab0d5678e64226shiqian 2025d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are commutative. 2026d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Commutative) { 2027d201456903f3ecae1f7794edfab0d5678e64226shiqian // We already tested EXPECT_DOUBLE_EQ(1.0, close_to_one_). 2028d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(close_to_one_, 1.0); 2029d201456903f3ecae1f7794edfab0d5678e64226shiqian 2030d201456903f3ecae1f7794edfab0d5678e64226shiqian // We already tested EXPECT_DOUBLE_EQ(1.0, further_from_one_). 2031d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(further_from_one_, 1.0), "1.0"); 2032d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2033d201456903f3ecae1f7794edfab0d5678e64226shiqian 2034d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2035d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, EXPECT_NEAR) { 2036d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0, -1.1, 0.2); 2037d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0, 3.0, 1.0); 2038d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __SYMBIAN32__ 2039d201456903f3ecae1f7794edfab0d5678e64226shiqian // Symbian STLport has currently a buggy floating point output. 2040d201456903f3ecae1f7794edfab0d5678e64226shiqian // TODO(mikie): fix STLport. 2041d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1), // NOLINT 2042d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.19999:, " 2043d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2044d201456903f3ecae1f7794edfab0d5678e64226shiqian#else // !__SYMBIAN32__ 2045d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.2, 0.1), // NOLINT 2046d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2047d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2048d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2049d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2050d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32__ 2051d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2052d201456903f3ecae1f7794edfab0d5678e64226shiqian 2053d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2054d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, ASSERT_NEAR) { 2055d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0, -1.1, 0.2); 2056d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0, 3.0, 1.0); 2057d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef __SYMBIAN32__ 2058d201456903f3ecae1f7794edfab0d5678e64226shiqian // Symbian STLport has currently a buggy floating point output. 2059d201456903f3ecae1f7794edfab0d5678e64226shiqian // TODO(mikie): fix STLport. 2060d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1), // NOLINT 2061d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.19999:, " 2062d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2063d201456903f3ecae1f7794edfab0d5678e64226shiqian#else // ! __SYMBIAN32__ 2064d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.2, 0.1), // NOLINT 2065d201456903f3ecae1f7794edfab0d5678e64226shiqian "The difference between 1.0 and 1.2 is 0.2, " 2066d201456903f3ecae1f7794edfab0d5678e64226shiqian "which exceeds 0.1"); 2067d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2068d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 2069d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32__ 2070d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2071d201456903f3ecae1f7794edfab0d5678e64226shiqian 2072d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should succeed. 2073d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLESucceeds) { 20749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 20759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 2076d201456903f3ecae1f7794edfab0d5678e64226shiqian 2077d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 20789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, close_to_positive_zero_, 0.0); 2079d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2080d201456903f3ecae1f7794edfab0d5678e64226shiqian 2081d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should fail. 2082d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLEFails) { 2083d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 20849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 2085d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0) <= (1.0)"); 2086d201456903f3ecae1f7794edfab0d5678e64226shiqian 2087d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2088d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 20899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, further_from_one_, 1.0); 2090d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(further_from_one_) <= (1.0)"); 2091d201456903f3ecae1f7794edfab0d5678e64226shiqian 2092d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when either val1 or val2 is NaN. 2093d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 20949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, nan1_, infinity_); 2095d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(nan1_) <= (infinity_)"); 2096d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 20979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, -infinity_, nan1_); 2098d201456903f3ecae1f7794edfab0d5678e64226shiqian }, " (-infinity_) <= (nan1_)"); 2099d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 21009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, nan1_, nan1_); 2101d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "(nan1_) <= (nan1_)"); 2102d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2103d201456903f3ecae1f7794edfab0d5678e64226shiqian 2104d201456903f3ecae1f7794edfab0d5678e64226shiqian 2105d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that a test or test case whose name starts with DISABLED_ is 2106d201456903f3ecae1f7794edfab0d5678e64226shiqian// not run. 2107d201456903f3ecae1f7794edfab0d5678e64226shiqian 2108d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name starts with DISABLED_. 2109d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2110d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, DISABLED_TestShouldNotRun) { 2111d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2112d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2113d201456903f3ecae1f7794edfab0d5678e64226shiqian 2114d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name does not start with DISABLED_. 2115d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should run. 2116d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, NotDISABLED_TestShouldRun) { 2117d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1); 2118d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2119d201456903f3ecae1f7794edfab0d5678e64226shiqian 2120d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case whose name starts with DISABLED_. 2121d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2122d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, TestShouldNotRun) { 2123d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2124d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2125d201456903f3ecae1f7794edfab0d5678e64226shiqian 2126d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case and test whose names start with DISABLED_. 2127d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 2128d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 2129d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 2130d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2131d201456903f3ecae1f7794edfab0d5678e64226shiqian 2132d201456903f3ecae1f7794edfab0d5678e64226shiqian// Check that when all tests in a test case are disabled, SetupTestCase() and 2133d201456903f3ecae1f7794edfab0d5678e64226shiqian// TearDownTestCase() are not called. 21349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass DisabledTestsTest : public Test { 2135d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2136d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 2137d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2138d201456903f3ecae1f7794edfab0d5678e64226shiqian "SetupTestCase() should not be called."; 2139d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2140d201456903f3ecae1f7794edfab0d5678e64226shiqian 2141d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 2142d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 2143d201456903f3ecae1f7794edfab0d5678e64226shiqian "TearDownTestCase() should not be called."; 2144d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2145d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2146d201456903f3ecae1f7794edfab0d5678e64226shiqian 2147d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 2148d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2149d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2150d201456903f3ecae1f7794edfab0d5678e64226shiqian 2151d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 2152d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 2153d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2154d201456903f3ecae1f7794edfab0d5678e64226shiqian 2155a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled typed tests aren't run. 2156a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2157a2b1a8556ea64014606d78b09333d9c522430a25shiqian#ifdef GTEST_HAS_TYPED_TEST 2158a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2159a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2160a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTest : public Test { 2161a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2162a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2163a2b1a8556ea64014606d78b09333d9c522430a25shiqiantypedef testing::Types<int, double> NumericTypes; 2164a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(TypedTest, NumericTypes); 2165a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2166a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 2167a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2168a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2169a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2170a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2171a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTest : public Test { 2172a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2173a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2174a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 2175a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2176a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 2177a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 2178a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2179a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2180a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST 2181a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2182a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled type-parameterized tests aren't run. 2183a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2184a2b1a8556ea64014606d78b09333d9c522430a25shiqian#ifdef GTEST_HAS_TYPED_TEST_P 2185a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2186a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2187a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTestP : public Test { 2188a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2189a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2190a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(TypedTestP); 2191a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2192a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 2193a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2194a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2195a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2196a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2197a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 2198a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2199a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 2200a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2201a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 2202a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTestP : public Test { 2203a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 2204a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2205a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(DISABLED_TypedTestP); 2206a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2207a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 2208a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 2209a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 2210a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 2211a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2212a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 2213a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2214a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 2215a2b1a8556ea64014606d78b09333d9c522430a25shiqian 2216a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST_P 2217d201456903f3ecae1f7794edfab0d5678e64226shiqian 2218d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion macros evaluate their arguments exactly once. 2219d201456903f3ecae1f7794edfab0d5678e64226shiqian 22209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SingleEvaluationTest : public Test { 2221d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2222d201456903f3ecae1f7794edfab0d5678e64226shiqian SingleEvaluationTest() { 2223d201456903f3ecae1f7794edfab0d5678e64226shiqian p1_ = s1_; 2224d201456903f3ecae1f7794edfab0d5678e64226shiqian p2_ = s2_; 2225d201456903f3ecae1f7794edfab0d5678e64226shiqian a_ = 0; 2226d201456903f3ecae1f7794edfab0d5678e64226shiqian b_ = 0; 2227d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2228d201456903f3ecae1f7794edfab0d5678e64226shiqian 2229d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_STREQ test 2230d201456903f3ecae1f7794edfab0d5678e64226shiqian // below. 2231d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementCharPtrs() { 2232d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1_++, p2_++); 2233d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2234d201456903f3ecae1f7794edfab0d5678e64226shiqian 2235d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_NE test below. 2236d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementInts() { 2237d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(a_++, b_++); 2238d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2239d201456903f3ecae1f7794edfab0d5678e64226shiqian 2240d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s1_; 2241d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s2_; 2242d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p1_; 2243d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p2_; 2244d201456903f3ecae1f7794edfab0d5678e64226shiqian 2245d201456903f3ecae1f7794edfab0d5678e64226shiqian static int a_; 2246d201456903f3ecae1f7794edfab0d5678e64226shiqian static int b_; 2247d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2248d201456903f3ecae1f7794edfab0d5678e64226shiqian 2249d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s1_ = "01234"; 2250d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s2_ = "abcde"; 2251d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p1_; 2252d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p2_; 2253d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::a_; 2254d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::b_; 2255d201456903f3ecae1f7794edfab0d5678e64226shiqian 2256d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_STREQ fails, it evaluates its arguments 2257d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2258d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 2259d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(CompareAndIncrementCharPtrs(), 2260d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2_++"); 2261d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 2262d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 2263d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2264d201456903f3ecae1f7794edfab0d5678e64226shiqian 2265d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that string assertion arguments are evaluated exactly once. 2266d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, ASSERT_STR) { 2267d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_STRNE 2268d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(p1_++, p2_++); 2269d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 2270d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 2271d201456903f3ecae1f7794edfab0d5678e64226shiqian 2272d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_STRCASEEQ 2273d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 2274d201456903f3ecae1f7794edfab0d5678e64226shiqian "ignoring case"); 2275d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 2, p1_); 2276d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 2, p2_); 2277d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2278d201456903f3ecae1f7794edfab0d5678e64226shiqian 2279d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 2280d201456903f3ecae1f7794edfab0d5678e64226shiqian// once. 2281d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 2282d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(CompareAndIncrementInts(), "(a_++) != (b_++)"); 2283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 2284d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 2285d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2286d201456903f3ecae1f7794edfab0d5678e64226shiqian 2287d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion arguments are evaluated exactly once. 2288d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, OtherCases) { 2289d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_TRUE 2290d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(0 == a_++); // NOLINT 2291d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 2292d201456903f3ecae1f7794edfab0d5678e64226shiqian 2293d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_TRUE 2294d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 2295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a_); 2296d201456903f3ecae1f7794edfab0d5678e64226shiqian 2297d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_GT 2298d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(a_++, b_++); 2299d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a_); 2300d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 2301d201456903f3ecae1f7794edfab0d5678e64226shiqian 2302d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_LT 2303d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 2304d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a_); 2305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, b_); 2306d201456903f3ecae1f7794edfab0d5678e64226shiqian 2307d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_TRUE 2308d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(0 < a_++); // NOLINT 2309d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, a_); 2310d201456903f3ecae1f7794edfab0d5678e64226shiqian 2311d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_GT 2312d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(a_++, b_++); 2313d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(6, a_); 2314d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, b_); 2315d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2316d201456903f3ecae1f7794edfab0d5678e64226shiqian 231736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 231836865d8d354465e3461eedf2949a4b7799985d5dshiqian 231936865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAnInteger() { 232036865d8d354465e3461eedf2949a4b7799985d5dshiqian throw 1; 232136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 232236865d8d354465e3461eedf2949a4b7799985d5dshiqian 232336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests that assertion arguments are evaluated exactly once. 232436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST_F(SingleEvaluationTest, ExceptionTests) { 232536865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_THROW 232636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW({ // NOLINT 232736865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 232836865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 232936865d8d354465e3461eedf2949a4b7799985d5dshiqian }, int); 233036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(1, a_); 233136865d8d354465e3461eedf2949a4b7799985d5dshiqian 233236865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws different 233336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 233436865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 233536865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 233636865d8d354465e3461eedf2949a4b7799985d5dshiqian }, bool), "throws a different type"); 233736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(2, a_); 233836865d8d354465e3461eedf2949a4b7799985d5dshiqian 233936865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws nothing 234036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 234136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(3, a_); 234236865d8d354465e3461eedf2949a4b7799985d5dshiqian 234336865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_NO_THROW 234436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(a_++); 234536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(4, a_); 234636865d8d354465e3461eedf2949a4b7799985d5dshiqian 234736865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_NO_THROW 234836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 234936865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 235036865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 235136865d8d354465e3461eedf2949a4b7799985d5dshiqian }), "it throws"); 235236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(5, a_); 235336865d8d354465e3461eedf2949a4b7799985d5dshiqian 235436865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_ANY_THROW 235536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW({ // NOLINT 235636865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 235736865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 235836865d8d354465e3461eedf2949a4b7799985d5dshiqian }); 235936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(6, a_); 236036865d8d354465e3461eedf2949a4b7799985d5dshiqian 236136865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_ANY_THROW 236236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 236336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(7, a_); 236436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 236536865d8d354465e3461eedf2949a4b7799985d5dshiqian 236636865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 2367d201456903f3ecae1f7794edfab0d5678e64226shiqian 2368d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests non-string assertions. 2369d201456903f3ecae1f7794edfab0d5678e64226shiqian 2370d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EqFailure(), used for implementing *EQ* assertions. 2371d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, EqFailure) { 2372d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo_val("5"), bar_val("6"); 2373d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg1( 2374d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", foo_val, bar_val, false) 2375d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2376d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2377d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2378d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2379d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 2380d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 2381d201456903f3ecae1f7794edfab0d5678e64226shiqian msg1.c_str()); 2382d201456903f3ecae1f7794edfab0d5678e64226shiqian 2383d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg2( 2384d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "6", foo_val, bar_val, false) 2385d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2386d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2387d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 2388d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 2389d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 2390d201456903f3ecae1f7794edfab0d5678e64226shiqian msg2.c_str()); 2391d201456903f3ecae1f7794edfab0d5678e64226shiqian 2392d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg3( 2393d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "bar", foo_val, bar_val, false) 2394d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 2395d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2396d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2397d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2398d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 2399d201456903f3ecae1f7794edfab0d5678e64226shiqian msg3.c_str()); 2400d201456903f3ecae1f7794edfab0d5678e64226shiqian 2401d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg4( 2402d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 2403d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2404d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 2405d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 2406d201456903f3ecae1f7794edfab0d5678e64226shiqian msg4.c_str()); 2407d201456903f3ecae1f7794edfab0d5678e64226shiqian 2408d201456903f3ecae1f7794edfab0d5678e64226shiqian const String msg5( 2409d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", 2410d201456903f3ecae1f7794edfab0d5678e64226shiqian String("\"x\""), String("\"y\""), 2411d201456903f3ecae1f7794edfab0d5678e64226shiqian true).failure_message()); 2412d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 2413d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 2414d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"y\"\n" 2415d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo (ignoring case)\n" 2416d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"x\"", 2417d201456903f3ecae1f7794edfab0d5678e64226shiqian msg5.c_str()); 2418d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2419d201456903f3ecae1f7794edfab0d5678e64226shiqian 2420d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests AppendUserMessage(), used for implementing the *EQ* macros. 2421d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AppendUserMessage) { 2422d201456903f3ecae1f7794edfab0d5678e64226shiqian const String foo("foo"); 2423d201456903f3ecae1f7794edfab0d5678e64226shiqian 24249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2425d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", 2426d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 2427d201456903f3ecae1f7794edfab0d5678e64226shiqian 2428d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << "bar"; 2429d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo\nbar", 2430d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 2431d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2432d201456903f3ecae1f7794edfab0d5678e64226shiqian 2433d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_TRUE. 2434d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_TRUE) { 2435d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(2 > 1); // NOLINT 2436d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 2437d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 1"); 2438d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2439d201456903f3ecae1f7794edfab0d5678e64226shiqian 2440d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_FALSE. 2441d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_FALSE) { 2442d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(2 < 1); // NOLINT 2443d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 2444d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 2445d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 2446d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 2447d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2448d201456903f3ecae1f7794edfab0d5678e64226shiqian 2449d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ASSERT_EQ on double values. The purpose is to make 2450d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 2451d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 2452d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_Double) { 2453d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2454d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5.6, 5.6); 2455d201456903f3ecae1f7794edfab0d5678e64226shiqian 2456d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2457d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 2458d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 2459d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2460d201456903f3ecae1f7794edfab0d5678e64226shiqian 2461d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ. 2462d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ) { 2463d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5, 2 + 3); 2464d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 2465d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 2466d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2467d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 2468d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2469d201456903f3ecae1f7794edfab0d5678e64226shiqian 2470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(NULL, pointer). 2471d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef __SYMBIAN32__ 2472d201456903f3ecae1f7794edfab0d5678e64226shiqian// The NULL-detection template magic fails to compile with 2473d201456903f3ecae1f7794edfab0d5678e64226shiqian// the Nokia compiler and crashes the ARM compiler, hence 2474d201456903f3ecae1f7794edfab0d5678e64226shiqian// not testing on Symbian. 2475d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ_NULL) { 2476d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2477d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 2478d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(NULL, p); 2479d201456903f3ecae1f7794edfab0d5678e64226shiqian 2480d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2481d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 2482d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 2483d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 2484d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2485d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32__ 2486d201456903f3ecae1f7794edfab0d5678e64226shiqian 2487d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 2488d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 2489d201456903f3ecae1f7794edfab0d5678e64226shiqian// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 2490d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 2491d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_0) { 2492d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 2493d201456903f3ecae1f7794edfab0d5678e64226shiqian 2494d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2495d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0, n); 2496d201456903f3ecae1f7794edfab0d5678e64226shiqian 2497d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2498d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 2499d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 2500d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2501d201456903f3ecae1f7794edfab0d5678e64226shiqian 2502d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NE. 2503d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_NE) { 2504d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(6, 7); 2505d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 2506d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 2507d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 2508d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2509d201456903f3ecae1f7794edfab0d5678e64226shiqian 2510d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LE. 2511d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LE) { 2512d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 3); 2513d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 2); 2514d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 2515d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 2516d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2517d201456903f3ecae1f7794edfab0d5678e64226shiqian 2518d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LT. 2519d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LT) { 2520d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(2, 3); 2521d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 2522d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 2523d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2524d201456903f3ecae1f7794edfab0d5678e64226shiqian 2525d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GE. 2526d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GE) { 2527d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 1); 2528d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 2); 2529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 2530d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 2531d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2532d201456903f3ecae1f7794edfab0d5678e64226shiqian 2533d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GT. 2534d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GT) { 2535d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(2, 1); 2536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 2537d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 2538d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2539d201456903f3ecae1f7794edfab0d5678e64226shiqian 254036865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 254136865d8d354465e3461eedf2949a4b7799985d5dshiqian 254236865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_THROW. 254336865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_THROW) { 254436865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int); 254536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool), 254636865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: ThrowAnInteger() throws an exception of type"\ 254736865d8d354465e3461eedf2949a4b7799985d5dshiqian " bool.\n Actual: it throws a different type."); 254836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(1, bool), 254936865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: 1 throws an exception of type bool.\n"\ 255036865d8d354465e3461eedf2949a4b7799985d5dshiqian " Actual: it throws nothing."); 255136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 255236865d8d354465e3461eedf2949a4b7799985d5dshiqian 255336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_NO_THROW. 255436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_NO_THROW) { 255536865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_NO_THROW(1); 255636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 255736865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: ThrowAnInteger() doesn't throw an exception."\ 255836865d8d354465e3461eedf2949a4b7799985d5dshiqian "\n Actual: it throws."); 255936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 256036865d8d354465e3461eedf2949a4b7799985d5dshiqian 256136865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_ANY_THROW. 256236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_ANY_THROW) { 256336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()); 256436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(1), 256536865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: 1 throws an exception.\n Actual: it "\ 256636865d8d354465e3461eedf2949a4b7799985d5dshiqian "doesn't."); 256736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 256836865d8d354465e3461eedf2949a4b7799985d5dshiqian 256936865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 257036865d8d354465e3461eedf2949a4b7799985d5dshiqian 2571d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure we deal with the precedence of <<. This test should 2572d201456903f3ecae1f7794edfab0d5678e64226shiqian// compile. 2573d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertPrecedence) { 2574d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1 < 2, true); 2575d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(true && false, false); 2576d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2577d201456903f3ecae1f7794edfab0d5678e64226shiqian 2578d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 2579d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestEq1(int x) { 2580d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, x); 2581d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2582d201456903f3ecae1f7794edfab0d5678e64226shiqian 2583d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests calling a test subroutine that's not part of a fixture. 2584d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, NonFixtureSubroutine) { 2585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestEq1(2), 2586d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: x"); 2587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2588d201456903f3ecae1f7794edfab0d5678e64226shiqian 2589d201456903f3ecae1f7794edfab0d5678e64226shiqian// An uncopyable class. 2590d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Uncopyable { 2591d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 2592d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Uncopyable(int value) : value_(value) {} 2593d201456903f3ecae1f7794edfab0d5678e64226shiqian 2594d201456903f3ecae1f7794edfab0d5678e64226shiqian int value() const { return value_; } 2595d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator==(const Uncopyable& rhs) const { 2596d201456903f3ecae1f7794edfab0d5678e64226shiqian return value() == rhs.value(); 2597d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2598d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 2599d201456903f3ecae1f7794edfab0d5678e64226shiqian // This constructor deliberately has no implementation, as we don't 2600d201456903f3ecae1f7794edfab0d5678e64226shiqian // want this class to be copyable. 2601d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable(const Uncopyable&); // NOLINT 2602d201456903f3ecae1f7794edfab0d5678e64226shiqian 2603d201456903f3ecae1f7794edfab0d5678e64226shiqian int value_; 2604d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2605d201456903f3ecae1f7794edfab0d5678e64226shiqian 2606d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 2607d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << value.value(); 2608d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2609d201456903f3ecae1f7794edfab0d5678e64226shiqian 2610d201456903f3ecae1f7794edfab0d5678e64226shiqian 2611d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositiveUncopyable(const Uncopyable& x) { 2612d201456903f3ecae1f7794edfab0d5678e64226shiqian return x.value() > 0; 2613d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2614d201456903f3ecae1f7794edfab0d5678e64226shiqian 2615d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 2616d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertNonPositive() { 2617d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 2618d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, y); 2619d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2620d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 2621d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertEqualsUncopyable() { 2622d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 2623d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 2624d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, y); 2625d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2626d201456903f3ecae1f7794edfab0d5678e64226shiqian 2627d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in assertions. 2628d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertWorksWithUncopyableObject) { 2629d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 2630d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, x); 2631d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, x); 2632d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 2633d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 2634d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 2635d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 2636d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2637d201456903f3ecae1f7794edfab0d5678e64226shiqian 2638d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in expects. 2639d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 2640d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 2641d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsPositiveUncopyable, x); 2642d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 2643d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 2644d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 2645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(x, x); 2646d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 2647d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 2648d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2649d201456903f3ecae1f7794edfab0d5678e64226shiqian 2650d201456903f3ecae1f7794edfab0d5678e64226shiqian 2651d201456903f3ecae1f7794edfab0d5678e64226shiqian// The version of gcc used in XCode 2.2 has a bug and doesn't allow 2652d201456903f3ecae1f7794edfab0d5678e64226shiqian// anonymous enums in assertions. Therefore the following test is 2653d201456903f3ecae1f7794edfab0d5678e64226shiqian// done only on Linux and Windows. 2654d201456903f3ecae1f7794edfab0d5678e64226shiqian#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_WINDOWS) 2655d201456903f3ecae1f7794edfab0d5678e64226shiqian 2656d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using assertions with anonymous enums. 2657d201456903f3ecae1f7794edfab0d5678e64226shiqianenum { 2658d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_A = -1, 2659d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_LINUX 2660d201456903f3ecae1f7794edfab0d5678e64226shiqian // We want to test the case where the size of the anonymous enum is 2661d201456903f3ecae1f7794edfab0d5678e64226shiqian // larger than sizeof(int), to make sure our implementation of the 2662d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions doesn't truncate the enums. However, MSVC 2663d201456903f3ecae1f7794edfab0d5678e64226shiqian // (incorrectly) doesn't allow an enum value to exceed the range of 2664d201456903f3ecae1f7794edfab0d5678e64226shiqian // an int, so this has to be conditionally compiled. 2665d201456903f3ecae1f7794edfab0d5678e64226shiqian // 2666d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Linux, CASE_B and CASE_A have the same value when truncated to 2667d201456903f3ecae1f7794edfab0d5678e64226shiqian // int size. We want to test whether this will confuse the 2668d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions. 26699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian CASE_B = testing::internal::kMaxBiggestInt, 2670d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 2671d201456903f3ecae1f7794edfab0d5678e64226shiqian CASE_B = INT_MAX, 2672d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 2673d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2674d201456903f3ecae1f7794edfab0d5678e64226shiqian 2675d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AnonymousEnum) { 2676d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_LINUX 2677d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<int>(CASE_A), static_cast<int>(CASE_B)); 2678d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_LINUX 2679d201456903f3ecae1f7794edfab0d5678e64226shiqian 2680d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(CASE_A, CASE_A); 2681d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(CASE_A, CASE_B); 2682d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(CASE_A, CASE_B); 2683d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(CASE_A, CASE_B); 2684d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(CASE_B, CASE_A); 2685d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(CASE_A, CASE_A); 2686d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(CASE_A, CASE_B), 2687d201456903f3ecae1f7794edfab0d5678e64226shiqian "(CASE_A) >= (CASE_B)"); 2688d201456903f3ecae1f7794edfab0d5678e64226shiqian 2689d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(CASE_A, CASE_A); 2690d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(CASE_A, CASE_B); 2691d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(CASE_A, CASE_B); 2692d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(CASE_A, CASE_B); 2693d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(CASE_B, CASE_A); 2694d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(CASE_A, CASE_A); 2695d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(CASE_A, CASE_B), 2696d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: CASE_B"); 2697d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2698d201456903f3ecae1f7794edfab0d5678e64226shiqian 2699d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // defined(GTEST_OS_LINUX) || defined(GTEST_OS_WINDOWS) 2700d201456903f3ecae1f7794edfab0d5678e64226shiqian 2701d201456903f3ecae1f7794edfab0d5678e64226shiqian#if defined(GTEST_OS_WINDOWS) 2702d201456903f3ecae1f7794edfab0d5678e64226shiqian 2703d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT UnexpectedHRESULTFailure() { 2704d201456903f3ecae1f7794edfab0d5678e64226shiqian return E_UNEXPECTED; 2705d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2706d201456903f3ecae1f7794edfab0d5678e64226shiqian 2707d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT OkHRESULTSuccess() { 2708d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_OK; 2709d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2710d201456903f3ecae1f7794edfab0d5678e64226shiqian 2711d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT FalseHRESULTSuccess() { 2712d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_FALSE; 2713d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2714d201456903f3ecae1f7794edfab0d5678e64226shiqian 2715d201456903f3ecae1f7794edfab0d5678e64226shiqian// HRESULT assertion tests test both zero and non-zero 2716d201456903f3ecae1f7794edfab0d5678e64226shiqian// success codes as well as failure message for each. 2717d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2718d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows CE doesn't support message texts. 2719d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 2720d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK); 2721d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_FALSE); 2722d201456903f3ecae1f7794edfab0d5678e64226shiqian 2723d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 2724ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 2725ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 2726d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2727d201456903f3ecae1f7794edfab0d5678e64226shiqian 2728d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 2729d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK); 2730d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_FALSE); 2731d201456903f3ecae1f7794edfab0d5678e64226shiqian 2732d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 2733ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 2734ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 2735d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2736d201456903f3ecae1f7794edfab0d5678e64226shiqian 2737d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 2738d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED); 2739d201456903f3ecae1f7794edfab0d5678e64226shiqian 2740d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 2741ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 2742ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 2743d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 2744ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 2745ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 2746d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2747d201456903f3ecae1f7794edfab0d5678e64226shiqian 2748d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 2749d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED); 2750d201456903f3ecae1f7794edfab0d5678e64226shiqian 2751d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 2752ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 2753ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000000"); 2754d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 2755ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 2756ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x00000001"); 2757d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2758d201456903f3ecae1f7794edfab0d5678e64226shiqian 2759d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that streaming to the HRESULT macros works. 2760d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, Streaming) { 2761d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 2762d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 2763d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 2764d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 2765d201456903f3ecae1f7794edfab0d5678e64226shiqian 2766d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 2767d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 2768d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 2769d201456903f3ecae1f7794edfab0d5678e64226shiqian 2770d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 2771d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 2772d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 2773d201456903f3ecae1f7794edfab0d5678e64226shiqian 2774d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 2775d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 2776d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 2777d201456903f3ecae1f7794edfab0d5678e64226shiqian 2778d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 2779d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 2780d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 2781d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2782d201456903f3ecae1f7794edfab0d5678e64226shiqian 2783d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // defined(GTEST_OS_WINDOWS) 2784d201456903f3ecae1f7794edfab0d5678e64226shiqian 2785d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros behave like single statements. 2786d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, BehavesLikeSingleStatement) { 2787d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 2788d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(false) << "This should never be executed; " 2789d201456903f3ecae1f7794edfab0d5678e64226shiqian "It's a compilation test only."; 2790d201456903f3ecae1f7794edfab0d5678e64226shiqian 2791d201456903f3ecae1f7794edfab0d5678e64226shiqian if (true) 2792d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false); 2793d201456903f3ecae1f7794edfab0d5678e64226shiqian else 2794d201456903f3ecae1f7794edfab0d5678e64226shiqian ; 2795d201456903f3ecae1f7794edfab0d5678e64226shiqian 2796d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 2797d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 3); 2798d201456903f3ecae1f7794edfab0d5678e64226shiqian 2799d201456903f3ecae1f7794edfab0d5678e64226shiqian if (false) 2800d201456903f3ecae1f7794edfab0d5678e64226shiqian ; 2801d201456903f3ecae1f7794edfab0d5678e64226shiqian else 2802d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(3, 2) << ""; 280336865d8d354465e3461eedf2949a4b7799985d5dshiqian 280436865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 280536865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 280636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(1, bool); 280736865d8d354465e3461eedf2949a4b7799985d5dshiqian 280836865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 280936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 281036865d8d354465e3461eedf2949a4b7799985d5dshiqian else 281136865d8d354465e3461eedf2949a4b7799985d5dshiqian ; 281236865d8d354465e3461eedf2949a4b7799985d5dshiqian 281336865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 281436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(ThrowAnInteger()); 281536865d8d354465e3461eedf2949a4b7799985d5dshiqian 281636865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 281736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(1); 281836865d8d354465e3461eedf2949a4b7799985d5dshiqian else 281936865d8d354465e3461eedf2949a4b7799985d5dshiqian ; 282036865d8d354465e3461eedf2949a4b7799985d5dshiqian 282136865d8d354465e3461eedf2949a4b7799985d5dshiqian if (false) 282236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(1); 282336865d8d354465e3461eedf2949a4b7799985d5dshiqian 282436865d8d354465e3461eedf2949a4b7799985d5dshiqian if (true) 282536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 282636865d8d354465e3461eedf2949a4b7799985d5dshiqian else 282736865d8d354465e3461eedf2949a4b7799985d5dshiqian ; 282836865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 2829d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2830d201456903f3ecae1f7794edfab0d5678e64226shiqian 2831d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros work well with switch statements. 2832d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, WorksWithSwitch) { 2833d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 2834d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 2835d201456903f3ecae1f7794edfab0d5678e64226shiqian break; 2836d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 2837d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 2838d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2839d201456903f3ecae1f7794edfab0d5678e64226shiqian 2840d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 2841d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 2842d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 2843d201456903f3ecae1f7794edfab0d5678e64226shiqian 2844d201456903f3ecae1f7794edfab0d5678e64226shiqian // Binary assertions are implemented using a different code path 2845d201456903f3ecae1f7794edfab0d5678e64226shiqian // than the Boolean assertions. Hence we test them separately. 2846d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 2847d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 2848d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 2849d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 2850d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2851d201456903f3ecae1f7794edfab0d5678e64226shiqian 2852d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 2853d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 2854d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(1, 2); 2855d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2856d201456903f3ecae1f7794edfab0d5678e64226shiqian 285736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 285836865d8d354465e3461eedf2949a4b7799985d5dshiqian 285936865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAString() { 286036865d8d354465e3461eedf2949a4b7799985d5dshiqian throw "String"; 286136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 286236865d8d354465e3461eedf2949a4b7799985d5dshiqian 286336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Test that the exception assertion macros compile and work with const 286436865d8d354465e3461eedf2949a4b7799985d5dshiqian// type qualifier. 286536865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionSyntaxTest, WorksWithConst) { 286636865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAString(), const char*); 286736865d8d354465e3461eedf2949a4b7799985d5dshiqian 286836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAString(), const char*); 286936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 287036865d8d354465e3461eedf2949a4b7799985d5dshiqian 287136865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 287236865d8d354465e3461eedf2949a4b7799985d5dshiqian 2873d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 2874d201456903f3ecae1f7794edfab0d5678e64226shiqian 2875d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns the number of successful parts in the current test. 2876d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic size_t GetSuccessfulPartCount() { 2877d201456903f3ecae1f7794edfab0d5678e64226shiqian return UnitTest::GetInstance()->impl()->current_test_result()-> 2878d201456903f3ecae1f7794edfab0d5678e64226shiqian successful_part_count(); 2879d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2880d201456903f3ecae1f7794edfab0d5678e64226shiqian 2881d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 2882d201456903f3ecae1f7794edfab0d5678e64226shiqian 2883d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test tracks SUCCEED*. 2884d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, SUCCEED) { 2885d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 2886d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "OK"; 2887d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2u, GetSuccessfulPartCount()); 2888d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2889d201456903f3ecae1f7794edfab0d5678e64226shiqian 2890d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_*. 2891d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT) { 2892d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true); 2893d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 2894d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2895d201456903f3ecae1f7794edfab0d5678e64226shiqian 2896d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_STR*. 2897d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT_STR) { 2898d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", ""); 2899d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 2900d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2901d201456903f3ecae1f7794edfab0d5678e64226shiqian 2902d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_*. 2903d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT) { 2904d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 2905d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 2906d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2907d201456903f3ecae1f7794edfab0d5678e64226shiqian 2908d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_STR*. 2909d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT_STR) { 2910d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("", ""); 2911d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0u, GetSuccessfulPartCount()); 2912d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2913d201456903f3ecae1f7794edfab0d5678e64226shiqian 2914d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 2915d201456903f3ecae1f7794edfab0d5678e64226shiqian 2916d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 2917d201456903f3ecae1f7794edfab0d5678e64226shiqian 2918d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_TRUE. 2919d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_TRUE) { 2920d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(2 > 1); // NOLINT 2921d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 2922d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 < 1\n" 2923d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: false\n" 2924d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: true"); 2925d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 2926d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 > 3"); 2927d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2928d201456903f3ecae1f7794edfab0d5678e64226shiqian 2929d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_FALSE. 2930d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_FALSE) { 2931d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(2 < 1); // NOLINT 2932d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 2933d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 2934d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 2935d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 2936d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 2937d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 3"); 2938d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2939d201456903f3ecae1f7794edfab0d5678e64226shiqian 2940d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ. 2941d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ) { 2942d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, 2 + 3); 2943d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 2944d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 2945d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 2946d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 2947d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 2948d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 - 3"); 2949d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2950d201456903f3ecae1f7794edfab0d5678e64226shiqian 2951d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using EXPECT_EQ on double values. The purpose is to make 2952d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 2953d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 2954d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_Double) { 2955d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2956d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5.6, 5.6); 2957d201456903f3ecae1f7794edfab0d5678e64226shiqian 2958d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2959d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 2960d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 2961d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2962d201456903f3ecae1f7794edfab0d5678e64226shiqian 2963d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef __SYMBIAN32__ 2964d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(NULL, pointer). 2965d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_NULL) { 2966d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2967d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 2968d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, p); 2969d201456903f3ecae1f7794edfab0d5678e64226shiqian 2970d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2971d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 2972d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 2973d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 2974d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2975d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32__ 2976d201456903f3ecae1f7794edfab0d5678e64226shiqian 2977d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 2978d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 2979d201456903f3ecae1f7794edfab0d5678e64226shiqian// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 2980d201456903f3ecae1f7794edfab0d5678e64226shiqian// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 2981d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_0) { 2982d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 2983d201456903f3ecae1f7794edfab0d5678e64226shiqian 2984d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 2985d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, n); 2986d201456903f3ecae1f7794edfab0d5678e64226shiqian 2987d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 2988d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 2989d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 2990d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2991d201456903f3ecae1f7794edfab0d5678e64226shiqian 2992d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NE. 2993d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_NE) { 2994d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(6, 7); 2995d201456903f3ecae1f7794edfab0d5678e64226shiqian 2996d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 2997d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 2998d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 2999d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 3000d201456903f3ecae1f7794edfab0d5678e64226shiqian "2"); 3001d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 3002d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 3003d201456903f3ecae1f7794edfab0d5678e64226shiqian "p0"); 3004d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 3005d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 3006d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 3007d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 3008d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 3009d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 3010d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 3011d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 3012d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3013d201456903f3ecae1f7794edfab0d5678e64226shiqian 3014d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LE. 3015d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LE) { 3016d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 3); 3017d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 2); 3018d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 3019d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3020d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 3021d201456903f3ecae1f7794edfab0d5678e64226shiqian "(1.1) <= (0.9)"); 3022d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3023d201456903f3ecae1f7794edfab0d5678e64226shiqian 3024d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LT. 3025d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LT) { 3026d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(2, 3); 3027d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 3028d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3029d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 3030d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) < (1)"); 3031d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3032d201456903f3ecae1f7794edfab0d5678e64226shiqian 3033d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GE. 3034d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GE) { 3035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 1); 3036d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 2); 3037d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 3038d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3039d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 3040d201456903f3ecae1f7794edfab0d5678e64226shiqian "(0.9) >= (1.1)"); 3041d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3042d201456903f3ecae1f7794edfab0d5678e64226shiqian 3043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GT. 3044d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GT) { 3045d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(2, 1); 3046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 3047d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3048d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 3049d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) > (3)"); 3050d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3051d201456903f3ecae1f7794edfab0d5678e64226shiqian 305236865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 305336865d8d354465e3461eedf2949a4b7799985d5dshiqian 305436865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_THROW. 305536865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_THROW) { 305636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 305736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 305836865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: ThrowAnInteger() throws an exception of "\ 305936865d8d354465e3461eedf2949a4b7799985d5dshiqian "type bool.\n Actual: it throws a different type."); 306036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(1, bool), 306136865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: 1 throws an exception of type bool.\n"\ 306236865d8d354465e3461eedf2949a4b7799985d5dshiqian " Actual: it throws nothing."); 306336865d8d354465e3461eedf2949a4b7799985d5dshiqian} 306436865d8d354465e3461eedf2949a4b7799985d5dshiqian 306536865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_NO_THROW. 306636865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_NO_THROW) { 306736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(1); 306836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 306936865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: ThrowAnInteger() doesn't throw an "\ 307036865d8d354465e3461eedf2949a4b7799985d5dshiqian "exception.\n Actual: it throws."); 307136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 307236865d8d354465e3461eedf2949a4b7799985d5dshiqian 307336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_ANY_THROW. 307436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_ANY_THROW) { 307536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 307636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(1), 307736865d8d354465e3461eedf2949a4b7799985d5dshiqian "Expected: 1 throws an exception.\n Actual: it "\ 307836865d8d354465e3461eedf2949a4b7799985d5dshiqian "doesn't."); 307936865d8d354465e3461eedf2949a4b7799985d5dshiqian} 308036865d8d354465e3461eedf2949a4b7799985d5dshiqian 308136865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 308236865d8d354465e3461eedf2949a4b7799985d5dshiqian 3083d201456903f3ecae1f7794edfab0d5678e64226shiqian// Make sure we deal with the precedence of <<. 3084d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ExpectPrecedence) { 3085d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1 < 2, true); 3086d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 3087d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true && false"); 3088d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3089d201456903f3ecae1f7794edfab0d5678e64226shiqian 3090d201456903f3ecae1f7794edfab0d5678e64226shiqian 3091d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the StreamableToString() function. 3092d201456903f3ecae1f7794edfab0d5678e64226shiqian 3093d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a scalar. 3094d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Scalar) { 3095d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("5", StreamableToString(5).c_str()); 3096d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3097d201456903f3ecae1f7794edfab0d5678e64226shiqian 3098d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a non-char pointer. 3099d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Pointer) { 3100d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3101d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = &n; 3102d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 3103d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3104d201456903f3ecae1f7794edfab0d5678e64226shiqian 3105d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL non-char pointer. 3106d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullPointer) { 3107d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = NULL; 3108d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 3109d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3110d201456903f3ecae1f7794edfab0d5678e64226shiqian 3111d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a C string. 3112d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, CString) { 3113d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 3114d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3115d201456903f3ecae1f7794edfab0d5678e64226shiqian 3116d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL C string. 3117d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullCString) { 3118d201456903f3ecae1f7794edfab0d5678e64226shiqian char* p = NULL; 3119d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 3120d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3121d201456903f3ecae1f7794edfab0d5678e64226shiqian 3122d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using streamable values as assertion messages. 3123d201456903f3ecae1f7794edfab0d5678e64226shiqian 3124d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 3125d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using std::string as an assertion message. 3126d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, string) { 3127d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string str( 3128d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure message is a std::string, and is expected."); 3129d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << str, 3130d201456903f3ecae1f7794edfab0d5678e64226shiqian str.c_str()); 3131d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3132d201456903f3ecae1f7794edfab0d5678e64226shiqian 3133d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output strings containing embedded NULs. 3134d201456903f3ecae1f7794edfab0d5678e64226shiqian// Limited to Linux because we can only do this with std::string's. 3135d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, stringWithEmbeddedNUL) { 3136d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char char_array_with_nul[] = 3137d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\0 and some more string"; 3138d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string string_with_nul(char_array_with_nul, 3139d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(char_array_with_nul) 3140d201456903f3ecae1f7794edfab0d5678e64226shiqian - 1); // drops the trailing NUL 3141d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 3142d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\\0 and some more string"); 3143d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3144d201456903f3ecae1f7794edfab0d5678e64226shiqian 3145d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 3146d201456903f3ecae1f7794edfab0d5678e64226shiqian 3147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output a NUL char. 3148d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NULChar) { 3149d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3150d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "A NUL" << '\0' << " and some more string"; 3151d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "A NUL\\0 and some more string"); 3152d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3153d201456903f3ecae1f7794edfab0d5678e64226shiqian 3154d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int as an assertion message. 3155d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, int) { 3156d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << 900913, 3157d201456903f3ecae1f7794edfab0d5678e64226shiqian "900913"); 3158d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3159d201456903f3ecae1f7794edfab0d5678e64226shiqian 3160d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using NULL char pointer as an assertion message. 3161d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3162d201456903f3ecae1f7794edfab0d5678e64226shiqian// In MSVC, streaming a NULL char * causes access violation. Google Test 3163d201456903f3ecae1f7794edfab0d5678e64226shiqian// implemented a workaround (substituting "(null)" for NULL). This 3164d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests whether the workaround works. 3165d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NullCharPtr) { 3166d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 3167d201456903f3ecae1f7794edfab0d5678e64226shiqian "(null)"); 3168d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3169d201456903f3ecae1f7794edfab0d5678e64226shiqian 3170d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that basic IO manipulators (endl, ends, and flush) can be 3171d201456903f3ecae1f7794edfab0d5678e64226shiqian// streamed to testing::Message. 3172d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, BasicIoManip) { 3173d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3174d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Line 1." << std::endl 3175d201456903f3ecae1f7794edfab0d5678e64226shiqian << "A NUL char " << std::ends << std::flush << " in line 2."; 3176d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Line 1.\nA NUL char \\0 in line 2."); 3177d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3178d201456903f3ecae1f7794edfab0d5678e64226shiqian 3179d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the macros that haven't been covered so far. 3180d201456903f3ecae1f7794edfab0d5678e64226shiqian 3181d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AddFailureHelper(bool* aborted) { 3182d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 3183d201456903f3ecae1f7794edfab0d5678e64226shiqian ADD_FAILURE() << "Failure"; 3184d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 3185d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3186d201456903f3ecae1f7794edfab0d5678e64226shiqian 3187d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ADD_FAILURE. 3188d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, ADD_FAILURE) { 3189d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 3190d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 3191d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failure"); 3192d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 3193d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3194d201456903f3ecae1f7794edfab0d5678e64226shiqian 3195d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests FAIL. 3196d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, FAIL) { 3197d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL(), 3198d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failed"); 3199d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 3200d201456903f3ecae1f7794edfab0d5678e64226shiqian "Intentional failure."); 3201d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3202d201456903f3ecae1f7794edfab0d5678e64226shiqian 3203d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests SUCCEED 3204d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, SUCCEED) { 3205d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 3206d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "Explicit success."; 3207d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3208d201456903f3ecae1f7794edfab0d5678e64226shiqian 3209d201456903f3ecae1f7794edfab0d5678e64226shiqian 3210d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for EXPECT_EQ() and ASSERT_EQ(). 3211d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3212d201456903f3ecae1f7794edfab0d5678e64226shiqian// These tests fail *intentionally*, s.t. the failure messages can be 3213d201456903f3ecae1f7794edfab0d5678e64226shiqian// generated and tested. 3214d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3215d201456903f3ecae1f7794edfab0d5678e64226shiqian// We have different tests for different argument types. 3216d201456903f3ecae1f7794edfab0d5678e64226shiqian 3217d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using bool values in {EXPECT|ASSERT}_EQ. 3218d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Bool) { 3219d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(true, true); 3220d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(false, true), 3221d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true"); 3222d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3223d201456903f3ecae1f7794edfab0d5678e64226shiqian 3224d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int values in {EXPECT|ASSERT}_EQ. 3225d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Int) { 3226d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(32, 32); 3227d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 3228d201456903f3ecae1f7794edfab0d5678e64226shiqian "33"); 3229d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3230d201456903f3ecae1f7794edfab0d5678e64226shiqian 3231d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using time_t values in {EXPECT|ASSERT}_EQ. 3232d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Time_T) { 3233d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<time_t>(0), 3234d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(0)); 3235d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 3236d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(1234)), 3237d201456903f3ecae1f7794edfab0d5678e64226shiqian "1234"); 3238d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3239d201456903f3ecae1f7794edfab0d5678e64226shiqian 3240d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char values in {EXPECT|ASSERT}_EQ. 3241d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Char) { 3242d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ('z', 'z'); 3243d201456903f3ecae1f7794edfab0d5678e64226shiqian const char ch = 'b'; 3244d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 3245d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 3246d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 3247d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 3248d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3249d201456903f3ecae1f7794edfab0d5678e64226shiqian 3250d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 3251d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideChar) { 3252d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L'b', L'b'); 3253d201456903f3ecae1f7794edfab0d5678e64226shiqian 3254d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 3255d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: L'x'\n" 3256d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L'x' (120, 0x78)\n" 3257d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: L'\0'\n" 3258d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L'\0' (0, 0x0)"); 3259d201456903f3ecae1f7794edfab0d5678e64226shiqian 3260d201456903f3ecae1f7794edfab0d5678e64226shiqian static wchar_t wchar; 3261d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'b'; 3262d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 3263d201456903f3ecae1f7794edfab0d5678e64226shiqian "wchar"); 3264d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'\x8119'; 3265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(L'\x8120', wchar), 3266d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: wchar"); 3267d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3268d201456903f3ecae1f7794edfab0d5678e64226shiqian 3269d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_STRING 3270d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 3271d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdString) { 3272d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has identical 3273d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3274d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ("Test", ::std::string("Test")); 3275d201456903f3ecae1f7794edfab0d5678e64226shiqian 3276d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::strings. 3277d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str1("A * in the middle"); 3278d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str2(str1); 3279d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(str1, str2); 3280d201456903f3ecae1f7794edfab0d5678e64226shiqian 3281d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has different 3282d201456903f3ecae1f7794edfab0d5678e64226shiqian // content 3283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 3284d201456903f3ecae1f7794edfab0d5678e64226shiqian "::std::string(\"test\")"); 3285d201456903f3ecae1f7794edfab0d5678e64226shiqian 3286d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::string to a char* that has different content. 3287d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = const_cast<char*>("foo"); 3288d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 3289d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 3290d201456903f3ecae1f7794edfab0d5678e64226shiqian 3291d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::strings that have different contents, one of 3292d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. This should fail. 3293d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::std::string str3(str1); 3294d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 3295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 3296d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: str3\n" 3297d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"A \\0 in the middle\""); 3298d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3299d201456903f3ecae1f7794edfab0d5678e64226shiqian 3300d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_STRING 3301d201456903f3ecae1f7794edfab0d5678e64226shiqian 3302d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 3303d201456903f3ecae1f7794edfab0d5678e64226shiqian 3304d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 3305d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdWideString) { 3306d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has identical 3307d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3308d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8119"); 3309d201456903f3ecae1f7794edfab0d5678e64226shiqian 3310d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::wstrings. 3311d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr1(L"A * in the middle"); 3312d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr2(wstr1); 3313d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(wstr1, wstr2); 3314d201456903f3ecae1f7794edfab0d5678e64226shiqian 3315d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has different 3316d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3317d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3318d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(::std::wstring(L"Test\x8119"), L"Test\x8120"); 3319d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "L\"Test\\x8120\""); 3320d201456903f3ecae1f7794edfab0d5678e64226shiqian 3321d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::wstrings that have different contents, one of 3322d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. 3323d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring wstr3(wstr1); 3324d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 3325d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 3326d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 3327d201456903f3ecae1f7794edfab0d5678e64226shiqian 3328d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to an std::wstring that has different 3329d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3330d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3331d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 3332d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 3333d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3334d201456903f3ecae1f7794edfab0d5678e64226shiqian 3335d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 3336d201456903f3ecae1f7794edfab0d5678e64226shiqian 3337d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 3338d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::string values in {EXPECT|ASSERT}_EQ. 3339d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalString) { 3340d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to a ::string that has identical content. 3341d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ("Test", ::string("Test")); 3342d201456903f3ecae1f7794edfab0d5678e64226shiqian 3343d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::strings. 3344d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str1("A * in the middle"); 3345d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str2(str1); 3346d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(str1, str2); 3347d201456903f3ecae1f7794edfab0d5678e64226shiqian 3348d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a const char* that has different content. 3349d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 3350d201456903f3ecae1f7794edfab0d5678e64226shiqian "test"); 3351d201456903f3ecae1f7794edfab0d5678e64226shiqian 3352d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::strings that have different contents, one of which 3353d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 3354d201456903f3ecae1f7794edfab0d5678e64226shiqian ::string str3(str1); 3355d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 3356d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 3357d201456903f3ecae1f7794edfab0d5678e64226shiqian "str3"); 3358d201456903f3ecae1f7794edfab0d5678e64226shiqian 3359d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a char* that has different content. 3360d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3361d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 3362d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 3363d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3364d201456903f3ecae1f7794edfab0d5678e64226shiqian 3365d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 3366d201456903f3ecae1f7794edfab0d5678e64226shiqian 3367d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_WSTRING 3368d201456903f3ecae1f7794edfab0d5678e64226shiqian 3369d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 3370d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalWideString) { 3371d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has identical content. 3372d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(L"Test\x8119", ::wstring(L"Test\x8119")); 3373d201456903f3ecae1f7794edfab0d5678e64226shiqian 3374d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::wstrings. 3375d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr1(L"A * in the middle"); 3376d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr2(wstr1); 3377d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(wstr1, wstr2); 3378d201456903f3ecae1f7794edfab0d5678e64226shiqian 3379d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has different 3380d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 3381d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3382d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L"Test\x8120", ::wstring(L"Test\x8119")); 3383d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Test\\x8119"); 3384d201456903f3ecae1f7794edfab0d5678e64226shiqian 3385d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to a ::wstring that has different content. 3386d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 3387d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 3388d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar"); 3389d201456903f3ecae1f7794edfab0d5678e64226shiqian 3390d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::wstrings that have different contents, one of which 3391d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 3392d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::wstring wstr3; 3393d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3 = wstr1; 3394d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 3395d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 3396d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 3397d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3398d201456903f3ecae1f7794edfab0d5678e64226shiqian 3399d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 3400d201456903f3ecae1f7794edfab0d5678e64226shiqian 3401d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char pointers in {EXPECT|ASSERT}_EQ. 3402d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, CharPointer) { 3403d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 3404d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 3405d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 3406d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 3407d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 3408d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 3409d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 3410d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 3411d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p2 = reinterpret_cast<char*>(pv2); 3412d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(p1, p1); 3413d201456903f3ecae1f7794edfab0d5678e64226shiqian 3414d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 3415d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 3416d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 3417d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 3418d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 3419d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<char*>(0xABC0)), 3420d201456903f3ecae1f7794edfab0d5678e64226shiqian "ABC0"); 3421d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3422d201456903f3ecae1f7794edfab0d5678e64226shiqian 3423d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 3424d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideCharPointer) { 3425d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p0 = NULL; 3426d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 3427d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 3428d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 3429d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 3430d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 3431d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 3432d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 3433d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 3434d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(p0, p0); 3435d201456903f3ecae1f7794edfab0d5678e64226shiqian 3436d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 3437d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 3438d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 3439d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 3440d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv3 = (void*)0x1234; // NOLINT 3441d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv4 = (void*)0xABC0; // NOLINT 3442d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 3443d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 3444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 3445d201456903f3ecae1f7794edfab0d5678e64226shiqian "p4"); 3446d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3447d201456903f3ecae1f7794edfab0d5678e64226shiqian 3448d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 3449d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, OtherPointer) { 3450d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(static_cast<const int*>(NULL), 3451d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<const int*>(NULL)); 3452d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 3453d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<const int*>(0x1234)), 3454d201456903f3ecae1f7794edfab0d5678e64226shiqian "0x1234"); 3455d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3456d201456903f3ecae1f7794edfab0d5678e64226shiqian 3457d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the FRIEND_TEST macro. 3458d201456903f3ecae1f7794edfab0d5678e64226shiqian 3459d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class has a private member we want to test. We will test it 3460d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a TEST and in a TEST_F. 3461d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Foo { 3462d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3463d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo() {} 3464d201456903f3ecae1f7794edfab0d5678e64226shiqian 3465d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3466d201456903f3ecae1f7794edfab0d5678e64226shiqian int Bar() const { return 1; } 3467d201456903f3ecae1f7794edfab0d5678e64226shiqian 3468d201456903f3ecae1f7794edfab0d5678e64226shiqian // Declares the friend tests that can access the private member 3469d201456903f3ecae1f7794edfab0d5678e64226shiqian // Bar(). 3470d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test, TEST); 3471d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 3472d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3473d201456903f3ecae1f7794edfab0d5678e64226shiqian 3474d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST to access a 3475d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 3476d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(FRIEND_TEST_Test, TEST) { 3477d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, Foo().Bar()); 3478d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3479d201456903f3ecae1f7794edfab0d5678e64226shiqian 3480d201456903f3ecae1f7794edfab0d5678e64226shiqian// The fixture needed to test using FRIEND_TEST with TEST_F. 34819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FRIEND_TEST_Test2 : public Test { 3482d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3483d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo foo; 3484d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3485d201456903f3ecae1f7794edfab0d5678e64226shiqian 3486d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 3487d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 3488d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FRIEND_TEST_Test2, TEST_F) { 3489d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, foo.Bar()); 3490d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3491d201456903f3ecae1f7794edfab0d5678e64226shiqian 3492d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of Test objects. 3493d201456903f3ecae1f7794edfab0d5678e64226shiqian 3494d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing the life cycle of Test objects. 3495d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3496d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class counts the number of live test objects that uses this 3497d201456903f3ecae1f7794edfab0d5678e64226shiqian// fixture. 34989b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestLifeCycleTest : public Test { 3499d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3500d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructor. Increments the number of test objects that uses 3501d201456903f3ecae1f7794edfab0d5678e64226shiqian // this fixture. 3502d201456903f3ecae1f7794edfab0d5678e64226shiqian TestLifeCycleTest() { count_++; } 3503d201456903f3ecae1f7794edfab0d5678e64226shiqian 3504d201456903f3ecae1f7794edfab0d5678e64226shiqian // Destructor. Decrements the number of test objects that uses this 3505d201456903f3ecae1f7794edfab0d5678e64226shiqian // fixture. 3506d201456903f3ecae1f7794edfab0d5678e64226shiqian ~TestLifeCycleTest() { count_--; } 3507d201456903f3ecae1f7794edfab0d5678e64226shiqian 3508d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the number of live test objects that uses this fixture. 3509d201456903f3ecae1f7794edfab0d5678e64226shiqian int count() const { return count_; } 3510d201456903f3ecae1f7794edfab0d5678e64226shiqian 3511d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3512d201456903f3ecae1f7794edfab0d5678e64226shiqian static int count_; 3513d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3514d201456903f3ecae1f7794edfab0d5678e64226shiqian 3515d201456903f3ecae1f7794edfab0d5678e64226shiqianint TestLifeCycleTest::count_ = 0; 3516d201456903f3ecae1f7794edfab0d5678e64226shiqian 3517d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 3518d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test1) { 3519d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be only one test object in this test case that's 3520d201456903f3ecae1f7794edfab0d5678e64226shiqian // currently alive. 3521d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 3522d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3523d201456903f3ecae1f7794edfab0d5678e64226shiqian 3524d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 3525d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test2) { 3526d201456903f3ecae1f7794edfab0d5678e64226shiqian // After Test1 is done and Test2 is started, there should still be 3527d201456903f3ecae1f7794edfab0d5678e64226shiqian // only one live test object, as the object for Test1 should've been 3528d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 3529d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 3530d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3531d201456903f3ecae1f7794edfab0d5678e64226shiqian 3532d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 3533d201456903f3ecae1f7794edfab0d5678e64226shiqian 3534d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator << are 3535d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in the global namespace. 3536d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Base { 3537d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3538d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit Base(int x) : x_(x) {} 3539d201456903f3ecae1f7794edfab0d5678e64226shiqian int x() const { return x_; } 3540d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3541d201456903f3ecae1f7794edfab0d5678e64226shiqian int x_; 3542d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3543d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3544d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base& val) { 3545d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 3546d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3547d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3548d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base* pointer) { 3549d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 3550d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3551d201456903f3ecae1f7794edfab0d5678e64226shiqian 3552d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 35539b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3554d201456903f3ecae1f7794edfab0d5678e64226shiqian Base a(1); 3555d201456903f3ecae1f7794edfab0d5678e64226shiqian 3556d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 3557d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 3558d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3559d201456903f3ecae1f7794edfab0d5678e64226shiqian 3560d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 3561d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in an unnamed namespace. 3562d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 3563d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInUnnamedNameSpace : public Base { 3564d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3565d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInUnnamedNameSpace(int x): Base(x) {} 3566d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3567d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3568d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace& val) { 3569d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 3570d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3571d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3572d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace* pointer) { 3573d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 3574d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3575d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 3576d201456903f3ecae1f7794edfab0d5678e64226shiqian 3577d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 35789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3579d201456903f3ecae1f7794edfab0d5678e64226shiqian MyTypeInUnnamedNameSpace a(1); 3580d201456903f3ecae1f7794edfab0d5678e64226shiqian 3581d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses <unnamed_namespace>::operator<<. 3582d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 3583d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3584d201456903f3ecae1f7794edfab0d5678e64226shiqian 3585d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 3586d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a user namespace. 3587d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace1 { 3588d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace1 : public Base { 3589d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3590d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace1(int x): Base(x) {} 3591d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3592d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3593d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1& val) { 3594d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 3595d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3596d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3597d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1* pointer) { 3598d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 3599d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3600d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace1 3601d201456903f3ecae1f7794edfab0d5678e64226shiqian 3602d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 36039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3604d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace1::MyTypeInNameSpace1 a(1); 3605d201456903f3ecae1f7794edfab0d5678e64226shiqian 3606d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses namespace1::operator<<. 3607d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 3608d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3609d201456903f3ecae1f7794edfab0d5678e64226shiqian 3610d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition is in a user namespace 3611d201456903f3ecae1f7794edfab0d5678e64226shiqian// but whose operator<< is in the global namespace. 3612d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace2 { 3613d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace2 : public ::Base { 3614d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3615d201456903f3ecae1f7794edfab0d5678e64226shiqian explicit MyTypeInNameSpace2(int x): Base(x) {} 3616d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3617d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace2 3618d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3619d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2& val) { 3620d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 3621d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3622d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 3623d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2* pointer) { 3624d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 3625d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3626d201456903f3ecae1f7794edfab0d5678e64226shiqian 3627d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 36289b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3629d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace2::MyTypeInNameSpace2 a(1); 3630d201456903f3ecae1f7794edfab0d5678e64226shiqian 3631d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 3632d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 3633d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3634d201456903f3ecae1f7794edfab0d5678e64226shiqian 3635d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming NULL pointers to testing::Message. 3636d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, NullPointers) { 36379b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3638d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = NULL; 3639d201456903f3ecae1f7794edfab0d5678e64226shiqian unsigned char* const p2 = NULL; 3640d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p3 = NULL; 3641d201456903f3ecae1f7794edfab0d5678e64226shiqian double* p4 = NULL; 3642d201456903f3ecae1f7794edfab0d5678e64226shiqian bool* p5 = NULL; 36439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message* p6 = NULL; 3644d201456903f3ecae1f7794edfab0d5678e64226shiqian 3645d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << p1 << p2 << p3 << p4 << p5 << p6; 3646d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 3647d201456903f3ecae1f7794edfab0d5678e64226shiqian msg.GetString().c_str()); 3648d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3649d201456903f3ecae1f7794edfab0d5678e64226shiqian 3650d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming wide strings to testing::Message. 3651d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, WideStrings) { 3652d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type const wchar_t*. 3653d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* const_wstr = NULL; 3654d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 3655d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 3656d201456903f3ecae1f7794edfab0d5678e64226shiqian 3657d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type wchar_t*. 3658d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* wstr = NULL; 3659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 3660d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 3661d201456903f3ecae1f7794edfab0d5678e64226shiqian 3662d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type const wchar_t*. 3663d201456903f3ecae1f7794edfab0d5678e64226shiqian const_wstr = L"abc\x8119"; 3664d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 3665d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 3666d201456903f3ecae1f7794edfab0d5678e64226shiqian 3667d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type wchar_t*. 3668d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr = const_cast<wchar_t*>(const_wstr); 3669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 3670d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 3671d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3672d201456903f3ecae1f7794edfab0d5678e64226shiqian 3673d201456903f3ecae1f7794edfab0d5678e64226shiqian 3674d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in the testing namespace. 3675d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 3676d201456903f3ecae1f7794edfab0d5678e64226shiqian 3677d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestInfo class. 3678d201456903f3ecae1f7794edfab0d5678e64226shiqian 36799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestInfoTest : public Test { 3680d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3681d201456903f3ecae1f7794edfab0d5678e64226shiqian static TestInfo * GetTestInfo(const char* test_name) { 3682d201456903f3ecae1f7794edfab0d5678e64226shiqian return UnitTest::GetInstance()->impl()-> 3683a2b1a8556ea64014606d78b09333d9c522430a25shiqian GetTestCase("TestInfoTest", "", NULL, NULL)-> 3684d201456903f3ecae1f7794edfab0d5678e64226shiqian GetTestInfo(test_name); 3685d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3686d201456903f3ecae1f7794edfab0d5678e64226shiqian 3687d201456903f3ecae1f7794edfab0d5678e64226shiqian static const TestResult* GetTestResult( 36889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const TestInfo* test_info) { 3689d201456903f3ecae1f7794edfab0d5678e64226shiqian return test_info->result(); 3690d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3691d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3692d201456903f3ecae1f7794edfab0d5678e64226shiqian 3693d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::test_case_name() and TestInfo::name(). 3694d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, Names) { 3695d201456903f3ecae1f7794edfab0d5678e64226shiqian TestInfo * const test_info = GetTestInfo("Names"); 3696d201456903f3ecae1f7794edfab0d5678e64226shiqian 3697d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 3698d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("Names", test_info->name()); 3699d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3700d201456903f3ecae1f7794edfab0d5678e64226shiqian 3701d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::result(). 3702d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, result) { 3703d201456903f3ecae1f7794edfab0d5678e64226shiqian TestInfo * const test_info = GetTestInfo("result"); 3704d201456903f3ecae1f7794edfab0d5678e64226shiqian 3705d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initially, there is no TestPartResult for this test. 3706d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, GetTestResult(test_info)->total_part_count()); 3707d201456903f3ecae1f7794edfab0d5678e64226shiqian 3708d201456903f3ecae1f7794edfab0d5678e64226shiqian // After the previous assertion, there is still none. 3709d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0u, GetTestResult(test_info)->total_part_count()); 3710d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3711d201456903f3ecae1f7794edfab0d5678e64226shiqian 3712d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests setting up and tearing down a test case. 3713d201456903f3ecae1f7794edfab0d5678e64226shiqian 37149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SetUpTestCaseTest : public Test { 3715d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3716d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once before the first test in this test case 3717d201456903f3ecae1f7794edfab0d5678e64226shiqian // is run. 3718d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 3719d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Setting up the test case . . .\n"); 3720d201456903f3ecae1f7794edfab0d5678e64226shiqian 3721d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initializes some shared resource. In this simple example, we 3722d201456903f3ecae1f7794edfab0d5678e64226shiqian // just create a C string. More complex stuff can be done if 3723d201456903f3ecae1f7794edfab0d5678e64226shiqian // desired. 3724d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = "123"; 3725d201456903f3ecae1f7794edfab0d5678e64226shiqian 3726d201456903f3ecae1f7794edfab0d5678e64226shiqian // Increments the number of test cases that have been set up. 3727d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_++; 3728d201456903f3ecae1f7794edfab0d5678e64226shiqian 3729d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once. 3730d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 3731d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3732d201456903f3ecae1f7794edfab0d5678e64226shiqian 3733d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once after the last test in this test case is 3734d201456903f3ecae1f7794edfab0d5678e64226shiqian // run. 3735d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 3736d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Tearing down the test case . . .\n"); 3737d201456903f3ecae1f7794edfab0d5678e64226shiqian 3738d201456903f3ecae1f7794edfab0d5678e64226shiqian // Decrements the number of test cases that have been set up. 3739d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_--; 3740d201456903f3ecae1f7794edfab0d5678e64226shiqian 3741d201456903f3ecae1f7794edfab0d5678e64226shiqian // TearDownTestCase() should be called only once. 3742d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, counter_); 3743d201456903f3ecae1f7794edfab0d5678e64226shiqian 3744d201456903f3ecae1f7794edfab0d5678e64226shiqian // Cleans up the shared resource. 3745d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = NULL; 3746d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3747d201456903f3ecae1f7794edfab0d5678e64226shiqian 3748d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called before each test in this test case. 3749d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 3750d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once, so counter_ should 3751d201456903f3ecae1f7794edfab0d5678e64226shiqian // always be 1. 3752d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 3753d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3754d201456903f3ecae1f7794edfab0d5678e64226shiqian 3755d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of test cases that have been set up. 3756d201456903f3ecae1f7794edfab0d5678e64226shiqian static int counter_; 3757d201456903f3ecae1f7794edfab0d5678e64226shiqian 3758d201456903f3ecae1f7794edfab0d5678e64226shiqian // Some resource to be shared by all tests in this test case. 3759d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* shared_resource_; 3760d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3761d201456903f3ecae1f7794edfab0d5678e64226shiqian 3762d201456903f3ecae1f7794edfab0d5678e64226shiqianint SetUpTestCaseTest::counter_ = 0; 3763d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SetUpTestCaseTest::shared_resource_ = NULL; 3764d201456903f3ecae1f7794edfab0d5678e64226shiqian 3765d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test that uses the shared resource. 3766d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test1) { 3767d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(NULL, shared_resource_); 3768d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3769d201456903f3ecae1f7794edfab0d5678e64226shiqian 3770d201456903f3ecae1f7794edfab0d5678e64226shiqian// Another test that uses the shared resource. 3771d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test2) { 3772d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("123", shared_resource_); 3773d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3774d201456903f3ecae1f7794edfab0d5678e64226shiqian 3775d201456903f3ecae1f7794edfab0d5678e64226shiqian// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 3776d201456903f3ecae1f7794edfab0d5678e64226shiqian 3777d201456903f3ecae1f7794edfab0d5678e64226shiqian// The Flags struct stores a copy of all Google Test flags. 3778d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct Flags { 3779d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs a Flags struct where each flag has its default value. 3780d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags() : break_on_failure(false), 3781d201456903f3ecae1f7794edfab0d5678e64226shiqian catch_exceptions(false), 3782d201456903f3ecae1f7794edfab0d5678e64226shiqian filter(""), 3783d201456903f3ecae1f7794edfab0d5678e64226shiqian list_tests(false), 3784d201456903f3ecae1f7794edfab0d5678e64226shiqian output(""), 378515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian print_time(false), 3786d201456903f3ecae1f7794edfab0d5678e64226shiqian repeat(1) {} 3787d201456903f3ecae1f7794edfab0d5678e64226shiqian 3788d201456903f3ecae1f7794edfab0d5678e64226shiqian // Factory methods. 3789d201456903f3ecae1f7794edfab0d5678e64226shiqian 3790d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_break_on_failure flag has 3791d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 3792d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags BreakOnFailure(bool break_on_failure) { 3793d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3794d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = break_on_failure; 3795d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3796d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3797d201456903f3ecae1f7794edfab0d5678e64226shiqian 3798d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_catch_exceptions flag has 3799d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 3800d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags CatchExceptions(bool catch_exceptions) { 3801d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3802d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.catch_exceptions = catch_exceptions; 3803d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3804d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3805d201456903f3ecae1f7794edfab0d5678e64226shiqian 3806d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_filter flag has the given 3807d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 3808d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Filter(const char* filter) { 3809d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3810d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = filter; 3811d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3812d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3813d201456903f3ecae1f7794edfab0d5678e64226shiqian 3814d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_list_tests flag has the 3815d201456903f3ecae1f7794edfab0d5678e64226shiqian // given value. 3816d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags ListTests(bool list_tests) { 3817d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3818d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.list_tests = list_tests; 3819d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3820d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3821d201456903f3ecae1f7794edfab0d5678e64226shiqian 3822d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_output flag has the given 3823d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 3824d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Output(const char* output) { 3825d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3826d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.output = output; 3827d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3828d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3829d201456903f3ecae1f7794edfab0d5678e64226shiqian 383015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // Creates a Flags struct where the gtest_print_time flag has the given 383115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // value. 383215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian static Flags PrintTime(bool print_time) { 383315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian Flags flags; 383415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian flags.print_time = print_time; 383515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian return flags; 383615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian } 383715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 3838d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_repeat flag has the given 3839d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 3840d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Repeat(Int32 repeat) { 3841d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 3842d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.repeat = repeat; 3843d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 3844d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3845d201456903f3ecae1f7794edfab0d5678e64226shiqian 3846d201456903f3ecae1f7794edfab0d5678e64226shiqian // These fields store the flag values. 3847d201456903f3ecae1f7794edfab0d5678e64226shiqian bool break_on_failure; 3848d201456903f3ecae1f7794edfab0d5678e64226shiqian bool catch_exceptions; 3849d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* filter; 3850d201456903f3ecae1f7794edfab0d5678e64226shiqian bool list_tests; 3851d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* output; 385215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian bool print_time; 3853d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 repeat; 3854d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3855d201456903f3ecae1f7794edfab0d5678e64226shiqian 3856d201456903f3ecae1f7794edfab0d5678e64226shiqian// Fixture for testing InitGoogleTest(). 38579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass InitGoogleTestTest : public Test { 3858d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3859d201456903f3ecae1f7794edfab0d5678e64226shiqian // Clears the flags before each test. 3860d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 3861d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(break_on_failure) = false; 3862d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(catch_exceptions) = false; 3863d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(filter) = ""; 3864d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(list_tests) = false; 3865d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(output) = ""; 386615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian GTEST_FLAG(print_time) = false; 3867d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(repeat) = 1; 3868d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3869d201456903f3ecae1f7794edfab0d5678e64226shiqian 3870d201456903f3ecae1f7794edfab0d5678e64226shiqian // Asserts that two narrow or wide string arrays are equal. 3871d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 3872d201456903f3ecae1f7794edfab0d5678e64226shiqian static void AssertStringArrayEq(size_t size1, CharType** array1, 3873d201456903f3ecae1f7794edfab0d5678e64226shiqian size_t size2, CharType** array2) { 3874d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(size1, size2) << " Array sizes different."; 3875d201456903f3ecae1f7794edfab0d5678e64226shiqian 3876d201456903f3ecae1f7794edfab0d5678e64226shiqian for (size_t i = 0; i != size1; i++) { 3877d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 3878d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3879d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3880d201456903f3ecae1f7794edfab0d5678e64226shiqian 3881d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the flag values match the expected values. 3882d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CheckFlags(const Flags& expected) { 3883d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 3884d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 3885d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 3886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 3887d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 388815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 3889d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 3890d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3891d201456903f3ecae1f7794edfab0d5678e64226shiqian 3892d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses a command line (specified by argc1 and argv1), then 3893d201456903f3ecae1f7794edfab0d5678e64226shiqian // verifies that the flag values are expected and that the 3894d201456903f3ecae1f7794edfab0d5678e64226shiqian // recognized flags are removed from the command line. 3895d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 3896d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TestParsingFlags(int argc1, const CharType** argv1, 3897d201456903f3ecae1f7794edfab0d5678e64226shiqian int argc2, const CharType** argv2, 3898d201456903f3ecae1f7794edfab0d5678e64226shiqian const Flags& expected) { 3899d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses the command line. 3900d201456903f3ecae1f7794edfab0d5678e64226shiqian InitGoogleTest(&argc1, const_cast<CharType**>(argv1)); 3901d201456903f3ecae1f7794edfab0d5678e64226shiqian 3902d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies the flag values. 3903d201456903f3ecae1f7794edfab0d5678e64226shiqian CheckFlags(expected); 3904d201456903f3ecae1f7794edfab0d5678e64226shiqian 3905d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the recognized flags are removed from the command 3906d201456903f3ecae1f7794edfab0d5678e64226shiqian // line. 3907d201456903f3ecae1f7794edfab0d5678e64226shiqian AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 3908d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3909d201456903f3ecae1f7794edfab0d5678e64226shiqian 3910d201456903f3ecae1f7794edfab0d5678e64226shiqian // This macro wraps TestParsingFlags s.t. the user doesn't need 3911d201456903f3ecae1f7794edfab0d5678e64226shiqian // to specify the array sizes. 3912d201456903f3ecae1f7794edfab0d5678e64226shiqian#define TEST_PARSING_FLAGS(argv1, argv2, expected) \ 3913d201456903f3ecae1f7794edfab0d5678e64226shiqian TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 3914d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(argv2)/sizeof(*argv2) - 1, argv2, expected) 3915d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3916d201456903f3ecae1f7794edfab0d5678e64226shiqian 3917d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty command line. 3918d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Empty) { 3919d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3920d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3921d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3922d201456903f3ecae1f7794edfab0d5678e64226shiqian 3923d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 3924d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3925d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3926d201456903f3ecae1f7794edfab0d5678e64226shiqian 3927d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags()); 3928d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3929d201456903f3ecae1f7794edfab0d5678e64226shiqian 3930d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a command line that has no flag. 3931d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, NoFlag) { 3932d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3933d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3934d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3935d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3936d201456903f3ecae1f7794edfab0d5678e64226shiqian 3937d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 3938d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3939d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3940d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3941d201456903f3ecae1f7794edfab0d5678e64226shiqian 3942d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags()); 3943d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3944d201456903f3ecae1f7794edfab0d5678e64226shiqian 3945d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a bad --gtest_filter flag. 3946d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterBad) { 3947d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3948d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3949d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 3950d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3951d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3952d201456903f3ecae1f7794edfab0d5678e64226shiqian 3953d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 3954d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3955d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 3956d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3957d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3958d201456903f3ecae1f7794edfab0d5678e64226shiqian 3959d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("")); 3960d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3961d201456903f3ecae1f7794edfab0d5678e64226shiqian 3962d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty --gtest_filter flag. 3963d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterEmpty) { 3964d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3965d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3966d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=", 3967d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3968d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3969d201456903f3ecae1f7794edfab0d5678e64226shiqian 3970d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 3971d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3972d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3973d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3974d201456903f3ecae1f7794edfab0d5678e64226shiqian 3975d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("")); 3976d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3977d201456903f3ecae1f7794edfab0d5678e64226shiqian 3978d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a non-empty --gtest_filter flag. 3979d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterNonEmpty) { 3980d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3981d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3982d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=abc", 3983d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3984d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3985d201456903f3ecae1f7794edfab0d5678e64226shiqian 3986d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 3987d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3988d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 3989d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 3990d201456903f3ecae1f7794edfab0d5678e64226shiqian 3991d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("abc")); 3992d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3993d201456903f3ecae1f7794edfab0d5678e64226shiqian 3994d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure. 3995d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureNoDef) { 3996d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 3997d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 3998d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 3999d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4000d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4001d201456903f3ecae1f7794edfab0d5678e64226shiqian 4002d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4003d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4004d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4005d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4006d201456903f3ecae1f7794edfab0d5678e64226shiqian 4007d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(true)); 4008d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4009d201456903f3ecae1f7794edfab0d5678e64226shiqian 4010d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=0. 4011d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 4012d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4013d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4014d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=0", 4015d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4016d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4017d201456903f3ecae1f7794edfab0d5678e64226shiqian 4018d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4019d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4020d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4021d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4022d201456903f3ecae1f7794edfab0d5678e64226shiqian 4023d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false)); 4024d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4025d201456903f3ecae1f7794edfab0d5678e64226shiqian 4026d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=f. 4027d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 4028d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4029d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4030d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=f", 4031d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4032d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4033d201456903f3ecae1f7794edfab0d5678e64226shiqian 4034d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4035d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4036d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4037d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4038d201456903f3ecae1f7794edfab0d5678e64226shiqian 4039d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false)); 4040d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4041d201456903f3ecae1f7794edfab0d5678e64226shiqian 4042d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 4043d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 4044d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4045d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4046d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=F", 4047d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4048d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4049d201456903f3ecae1f7794edfab0d5678e64226shiqian 4050d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4051d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4052d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4053d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4054d201456903f3ecae1f7794edfab0d5678e64226shiqian 4055d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(false)); 4056d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4057d201456903f3ecae1f7794edfab0d5678e64226shiqian 4058d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a --gtest_break_on_failure flag that has a "true" 4059d201456903f3ecae1f7794edfab0d5678e64226shiqian// definition. 4060d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 4061d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4062d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4063d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=1", 4064d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4065d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4066d201456903f3ecae1f7794edfab0d5678e64226shiqian 4067d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4068d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4069d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4070d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4071d201456903f3ecae1f7794edfab0d5678e64226shiqian 4072d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::BreakOnFailure(true)); 4073d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4074d201456903f3ecae1f7794edfab0d5678e64226shiqian 4075d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_catch_exceptions. 4076d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, CatchExceptions) { 4077d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4078d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4079d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_catch_exceptions", 4080d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4081d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4082d201456903f3ecae1f7794edfab0d5678e64226shiqian 4083d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4084d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4085d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4086d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4087d201456903f3ecae1f7794edfab0d5678e64226shiqian 4088d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::CatchExceptions(true)); 4089d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4090d201456903f3ecae1f7794edfab0d5678e64226shiqian 4091d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having the same flag twice with different values. The 4092d201456903f3ecae1f7794edfab0d5678e64226shiqian// expected behavior is that the one coming last takes precedence. 4093d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, DuplicatedFlags) { 4094d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4095d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4096d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=a", 4097d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 4098d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4099d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4100d201456903f3ecae1f7794edfab0d5678e64226shiqian 4101d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4102d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4103d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4104d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4105d201456903f3ecae1f7794edfab0d5678e64226shiqian 4106d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Filter("b")); 4107d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4108d201456903f3ecae1f7794edfab0d5678e64226shiqian 4109d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having an unrecognized flag on the command line. 4110d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 4111d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4112d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4113d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 4114d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", // Unrecognized by Google Test. 4115d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 4116d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4117d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4118d201456903f3ecae1f7794edfab0d5678e64226shiqian 4119d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4120d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4121d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", 4122d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4123d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4124d201456903f3ecae1f7794edfab0d5678e64226shiqian 4125d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 4126d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = true; 4127d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = "b"; 4128d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, flags); 4129d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4130d201456903f3ecae1f7794edfab0d5678e64226shiqian 4131d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag 4132d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFlag) { 4133d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4134d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4135d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests", 4136d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4137d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4138d201456903f3ecae1f7794edfab0d5678e64226shiqian 4139d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4140d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4141d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4142d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4143d201456903f3ecae1f7794edfab0d5678e64226shiqian 4144d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(true)); 4145d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4146d201456903f3ecae1f7794edfab0d5678e64226shiqian 4147d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "true" value 4148d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsTrue) { 4149d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4150d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4151d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=1", 4152d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4153d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4154d201456903f3ecae1f7794edfab0d5678e64226shiqian 4155d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4156d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4157d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4158d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4159d201456903f3ecae1f7794edfab0d5678e64226shiqian 4160d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(true)); 4161d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4162d201456903f3ecae1f7794edfab0d5678e64226shiqian 4163d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "false" value 4164d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse) { 4165d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4166d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4167d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=0", 4168d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4169d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4170d201456903f3ecae1f7794edfab0d5678e64226shiqian 4171d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4172d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4173d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4174d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4175d201456903f3ecae1f7794edfab0d5678e64226shiqian 4176d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false)); 4177d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4178d201456903f3ecae1f7794edfab0d5678e64226shiqian 4179d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_list_tests=f. 4180d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 4181d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4182d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4183d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=f", 4184d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4185d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4186d201456903f3ecae1f7794edfab0d5678e64226shiqian 4187d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4188d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4189d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4190d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4191d201456903f3ecae1f7794edfab0d5678e64226shiqian 4192d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false)); 4193d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4194d201456903f3ecae1f7794edfab0d5678e64226shiqian 4195d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 4196d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 4197d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4198d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4199d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=F", 4200d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4201d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4202d201456903f3ecae1f7794edfab0d5678e64226shiqian 4203d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4204d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4205d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4206d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4207d201456903f3ecae1f7794edfab0d5678e64226shiqian 4208d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::ListTests(false)); 4209d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4210d201456903f3ecae1f7794edfab0d5678e64226shiqian 4211d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output (invalid). 4212d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputEmpty) { 4213d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4214d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4215d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 4216d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4217d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4218d201456903f3ecae1f7794edfab0d5678e64226shiqian 4219d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4220d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4221d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 4222d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4223d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4224d201456903f3ecae1f7794edfab0d5678e64226shiqian 4225d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags()); 4226d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4227d201456903f3ecae1f7794edfab0d5678e64226shiqian 4228d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml 4229d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXml) { 4230d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4231d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4232d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml", 4233d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4234d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4235d201456903f3ecae1f7794edfab0d5678e64226shiqian 4236d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4237d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4238d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4239d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4240d201456903f3ecae1f7794edfab0d5678e64226shiqian 4241d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml")); 4242d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4243d201456903f3ecae1f7794edfab0d5678e64226shiqian 4244d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:file 4245d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlFile) { 4246d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4247d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4248d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:file", 4249d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4250d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4251d201456903f3ecae1f7794edfab0d5678e64226shiqian 4252d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4253d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4254d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4255d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4256d201456903f3ecae1f7794edfab0d5678e64226shiqian 4257d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml:file")); 4258d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4259d201456903f3ecae1f7794edfab0d5678e64226shiqian 4260d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:directory/path/ 4261d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 4262d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4263d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4264d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:directory/path/", 4265d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4266d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4267d201456903f3ecae1f7794edfab0d5678e64226shiqian 4268d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4269d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4270d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4271d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4272d201456903f3ecae1f7794edfab0d5678e64226shiqian 4273d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Output("xml:directory/path/")); 4274d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4275d201456903f3ecae1f7794edfab0d5678e64226shiqian 427615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag 427715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFlag) { 427815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 427915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 428015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time", 428115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 428215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 428315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 428415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 428515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 428615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 428715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 428815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 428915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(true)); 429015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 429115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 429215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "true" value 429315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeTrue) { 429415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 429515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 429615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=1", 429715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 429815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 429915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 430015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 430115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 430215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 430315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 430415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 430515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(true)); 430615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 430715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 430815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "false" value 430915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse) { 431015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 431115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 431215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=0", 431315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 431415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 431515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 431615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 431715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 431815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 431915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 432015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 432115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false)); 432215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 432315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 432415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=f. 432515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 432615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 432715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 432815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=f", 432915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 433015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 433115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 433215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 433315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 433415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 433515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 433615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 433715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false)); 433815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 433915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 434015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=F. 434115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 434215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 434315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 434415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=F", 434515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 434615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 434715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 434815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 434915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 435015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 435115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 435215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 435315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian TEST_PARSING_FLAGS(argv, argv2, Flags::PrintTime(false)); 435415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 435515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 4356d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_repeat=number 4357d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Repeat) { 4358d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 4359d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4360d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_repeat=1000", 4361d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4362d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4363d201456903f3ecae1f7794edfab0d5678e64226shiqian 4364d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 4365d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 4366d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4367d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4368d201456903f3ecae1f7794edfab0d5678e64226shiqian 4369d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, Flags::Repeat(1000)); 4370d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4371d201456903f3ecae1f7794edfab0d5678e64226shiqian 4372d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS 4373d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing wide strings. 4374d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, WideStrings) { 4375d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv[] = { 4376d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 4377d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_filter=Foo*", 4378d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_list_tests=1", 4379d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_break_on_failure", 4380d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 4381d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4382d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4383d201456903f3ecae1f7794edfab0d5678e64226shiqian 4384d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv2[] = { 4385d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 4386d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 4387d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 4388d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 4389d201456903f3ecae1f7794edfab0d5678e64226shiqian 4390d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags expected_flags; 4391d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.break_on_failure = true; 4392d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.filter = "Foo*"; 4393d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.list_tests = true; 4394d201456903f3ecae1f7794edfab0d5678e64226shiqian 4395d201456903f3ecae1f7794edfab0d5678e64226shiqian TEST_PARSING_FLAGS(argv, argv2, expected_flags); 4396d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4397d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 4398d201456903f3ecae1f7794edfab0d5678e64226shiqian 4399d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests current_test_info() in UnitTest. 4400d201456903f3ecae1f7794edfab0d5678e64226shiqianclass CurrentTestInfoTest : public Test { 4401d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4402d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL before the first test in 4403d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case is run. 4404d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 4405d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be no tests running at this point. 4406d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 4407d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 4408d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, test_info) 4409d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 4410d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4411d201456903f3ecae1f7794edfab0d5678e64226shiqian 4412d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL after the last test in 4413d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case has run. 4414d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 4415d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 4416d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 4417d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, test_info) 4418d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 4419d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4420d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4421d201456903f3ecae1f7794edfab0d5678e64226shiqian 4422d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 4423d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. 4424d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 4425d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 4426d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 4427d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 4428d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 4429d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 4430d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 4431d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 4432d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 4433d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4434d201456903f3ecae1f7794edfab0d5678e64226shiqian 4435d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 4436d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. We 4437d201456903f3ecae1f7794edfab0d5678e64226shiqian// use this test to see that the TestInfo object actually changed from 4438d201456903f3ecae1f7794edfab0d5678e64226shiqian// the previous invocation. 4439d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 4440d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 4441d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 4442d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 4443d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 4444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 4445d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 4446d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 4447d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 4448d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4449d201456903f3ecae1f7794edfab0d5678e64226shiqian 4450d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 4451d201456903f3ecae1f7794edfab0d5678e64226shiqian 4452d201456903f3ecae1f7794edfab0d5678e64226shiqian// These two lines test that we can define tests in a namespace that 4453d201456903f3ecae1f7794edfab0d5678e64226shiqian// has the name "testing" and is nested in another namespace. 4454d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace my_namespace { 4455d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 4456d201456903f3ecae1f7794edfab0d5678e64226shiqian 4457d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that TEST knows to use ::testing::Test instead of 4458d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Test. 4459d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Test {}; 4460d201456903f3ecae1f7794edfab0d5678e64226shiqian 4461d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use ::testing::Message instead of 4462d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Message. 4463d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message {}; 4464d201456903f3ecae1f7794edfab0d5678e64226shiqian 4465d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use 4466d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::testing::AssertionResult instead of 4467d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::AssertionResult. 4468d201456903f3ecae1f7794edfab0d5678e64226shiqianclass AssertionResult {}; 4469d201456903f3ecae1f7794edfab0d5678e64226shiqian 4470d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should succeed works as expected. 4471d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Success) { 4472d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "This shouldn't fail."; 4473d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4474d201456903f3ecae1f7794edfab0d5678e64226shiqian 4475d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should fail works as expected. 4476d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Failure) { 4477d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 4478d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is expected."); 4479d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4480d201456903f3ecae1f7794edfab0d5678e64226shiqian 4481d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 4482d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace my_namespace 4483d201456903f3ecae1f7794edfab0d5678e64226shiqian 4484d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that one can call superclass SetUp and TearDown methods-- 4485d201456903f3ecae1f7794edfab0d5678e64226shiqian// that is, that they are not private. 4486d201456903f3ecae1f7794edfab0d5678e64226shiqian// No tests are based on this fixture; the test "passes" if it compiles 4487d201456903f3ecae1f7794edfab0d5678e64226shiqian// successfully. 44889b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass ProtectedFixtureMethodsTest : public Test { 4489d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 4490d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 44919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::SetUp(); 4492d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4493d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 44949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::TearDown(); 4495d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4496d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 4497d201456903f3ecae1f7794edfab0d5678e64226shiqian 4498d201456903f3ecae1f7794edfab0d5678e64226shiqian// StreamingAssertionsTest tests the streaming versions of a representative 4499d201456903f3ecae1f7794edfab0d5678e64226shiqian// sample of assertions. 4500d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Unconditional) { 4501d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "expected success"; 4502d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 4503d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4504d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 4505d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4506d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4507d201456903f3ecae1f7794edfab0d5678e64226shiqian 4508d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth) { 4509d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true) << "unexpected failure"; 4510d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true) << "unexpected failure"; 4511d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 4512d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4513d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 4514d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4515d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4516d201456903f3ecae1f7794edfab0d5678e64226shiqian 4517d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth2) { 4518d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "unexpected failure"; 4519d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(false) << "unexpected failure"; 4520d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 4521d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4522d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 4523d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4524d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4525d201456903f3ecae1f7794edfab0d5678e64226shiqian 4526d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerEquals) { 4527d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "unexpected failure"; 4528d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "unexpected failure"; 4529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 4530d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4531d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 4532d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4533d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4534d201456903f3ecae1f7794edfab0d5678e64226shiqian 4535d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerLessThan) { 4536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(1, 2) << "unexpected failure"; 4537d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 2) << "unexpected failure"; 4538d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 4539d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 4541d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4542d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4543d201456903f3ecae1f7794edfab0d5678e64226shiqian 4544d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqual) { 4545d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", "foo") << "unexpected failure"; 4546d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("foo", "foo") << "unexpected failure"; 4547d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 4548d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4549d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 4550d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4551d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4552d201456903f3ecae1f7794edfab0d5678e64226shiqian 4553d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsNotEqual) { 4554d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("foo", "bar") << "unexpected failure"; 4555d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("foo", "bar") << "unexpected failure"; 4556d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 4557d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4558d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 4559d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4560d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4561d201456903f3ecae1f7794edfab0d5678e64226shiqian 4562d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 4563d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 4564d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 4565d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 4566d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4567d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 4568d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4569d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4570d201456903f3ecae1f7794edfab0d5678e64226shiqian 4571d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 4572d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 4573d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 4574d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 4575d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4576d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 4577d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4578d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4579d201456903f3ecae1f7794edfab0d5678e64226shiqian 4580d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, FloatingPointEquals) { 4581d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 4582d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 4583d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 4584d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 4586d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4588d201456903f3ecae1f7794edfab0d5678e64226shiqian 458936865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 459036865d8d354465e3461eedf2949a4b7799985d5dshiqian 459136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, Throw) { 459236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 459336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 459436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 459536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 459636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 459736865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 459836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 459936865d8d354465e3461eedf2949a4b7799985d5dshiqian 460036865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, NoThrow) { 460136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(1) << "unexpected failure"; 460236865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_NO_THROW(1) << "unexpected failure"; 460336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 460436865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 460536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 460636865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 460736865d8d354465e3461eedf2949a4b7799985d5dshiqian} 460836865d8d354465e3461eedf2949a4b7799985d5dshiqian 460936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, AnyThrow) { 461036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 461136865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 461236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(1) << 461336865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 461436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(1) << 461536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 461636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 461736865d8d354465e3461eedf2949a4b7799985d5dshiqian 461836865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 461936865d8d354465e3461eedf2949a4b7799985d5dshiqian 4620d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test correctly decides whether to use colors in the output. 4621d201456903f3ecae1f7794edfab0d5678e64226shiqian 4622d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 4623d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "yes"; 4624d201456903f3ecae1f7794edfab0d5678e64226shiqian 4625d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 4626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4627d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 4628d201456903f3ecae1f7794edfab0d5678e64226shiqian 4629d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 4630d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4631d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 4632d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4633d201456903f3ecae1f7794edfab0d5678e64226shiqian 4634d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 4635d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 4636d201456903f3ecae1f7794edfab0d5678e64226shiqian 4637d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "True"; 4638d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 4639d201456903f3ecae1f7794edfab0d5678e64226shiqian 4640d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "t"; 4641d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 4642d201456903f3ecae1f7794edfab0d5678e64226shiqian 4643d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "1"; 4644d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 4645d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4646d201456903f3ecae1f7794edfab0d5678e64226shiqian 4647d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 4648d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "no"; 4649d201456903f3ecae1f7794edfab0d5678e64226shiqian 4650d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 4651d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4652d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 4653d201456903f3ecae1f7794edfab0d5678e64226shiqian 4654d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 4655d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4656d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 4657d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4658d201456903f3ecae1f7794edfab0d5678e64226shiqian 4659d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 4660d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 4661d201456903f3ecae1f7794edfab0d5678e64226shiqian 4662d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "F"; 4663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4664d201456903f3ecae1f7794edfab0d5678e64226shiqian 4665d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "0"; 4666d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4667d201456903f3ecae1f7794edfab0d5678e64226shiqian 4668d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "unknown"; 4669d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4670d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4671d201456903f3ecae1f7794edfab0d5678e64226shiqian 4672d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 4673d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 4674d201456903f3ecae1f7794edfab0d5678e64226shiqian 4675d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 4676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 4677d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4678d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4679d201456903f3ecae1f7794edfab0d5678e64226shiqian 4680d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 4681d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 4682d201456903f3ecae1f7794edfab0d5678e64226shiqian 4683d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_OS_WINDOWS 4684d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Windows, we ignore the TERM variable as it's usually not set. 4685d201456903f3ecae1f7794edfab0d5678e64226shiqian 4686d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); 4687d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4688d201456903f3ecae1f7794edfab0d5678e64226shiqian 4689d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", ""); 4690d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4691d201456903f3ecae1f7794edfab0d5678e64226shiqian 4692d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); 4693d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4694d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 4695d201456903f3ecae1f7794edfab0d5678e64226shiqian // On non-Windows platforms, we rely on TERM to determine if the 4696d201456903f3ecae1f7794edfab0d5678e64226shiqian // terminal supports colors. 4697d201456903f3ecae1f7794edfab0d5678e64226shiqian 4698d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 4699d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4700d201456903f3ecae1f7794edfab0d5678e64226shiqian 4701d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "emacs"); // TERM doesn't support colors. 4702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4703d201456903f3ecae1f7794edfab0d5678e64226shiqian 4704d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "vt100"); // TERM doesn't support colors. 4705d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4706d201456903f3ecae1f7794edfab0d5678e64226shiqian 4707d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 4708d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 4709d201456903f3ecae1f7794edfab0d5678e64226shiqian 4710d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 4711d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4712d201456903f3ecae1f7794edfab0d5678e64226shiqian 4713d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-color"); // TERM supports colors. 4714d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 4715d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 4716d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4717d201456903f3ecae1f7794edfab0d5678e64226shiqian 4718d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifndef __SYMBIAN32__ 4719d201456903f3ecae1f7794edfab0d5678e64226shiqian// We will want to integrate running the unittests to a different 4720d201456903f3ecae1f7794edfab0d5678e64226shiqian// main application on Symbian. 4721d201456903f3ecae1f7794edfab0d5678e64226shiqianint main(int argc, char** argv) { 4722d201456903f3ecae1f7794edfab0d5678e64226shiqian testing::InitGoogleTest(&argc, argv); 4723d201456903f3ecae1f7794edfab0d5678e64226shiqian 4724d201456903f3ecae1f7794edfab0d5678e64226shiqian#ifdef GTEST_HAS_DEATH_TEST 4725d201456903f3ecae1f7794edfab0d5678e64226shiqian if (!testing::internal::GTEST_FLAG(internal_run_death_test).empty()) { 4726d201456903f3ecae1f7794edfab0d5678e64226shiqian // Skip the usual output capturing if we're running as the child 4727d201456903f3ecae1f7794edfab0d5678e64226shiqian // process of an threadsafe-style death test. 4728d201456903f3ecae1f7794edfab0d5678e64226shiqian freopen("/dev/null", "w", stdout); 4729d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4730d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_DEATH_TEST 4731d201456903f3ecae1f7794edfab0d5678e64226shiqian 4732d201456903f3ecae1f7794edfab0d5678e64226shiqian // Runs all tests using Google Test. 4733d201456903f3ecae1f7794edfab0d5678e64226shiqian return RUN_ALL_TESTS(); 4734d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4735d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // __SYMBIAN32_ 4736