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