111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Copyright 2005, Google Inc. 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// All rights reserved. 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Redistribution and use in source and binary forms, with or without 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// modification, are permitted provided that the following conditions are 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// met: 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions of source code must retain the above copyright 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// notice, this list of conditions and the following disclaimer. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Redistributions in binary form must reproduce the above 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// copyright notice, this list of conditions and the following disclaimer 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in the documentation and/or other materials provided with the 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// distribution. 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// * Neither the name of Google Inc. nor the names of its 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// contributors may be used to endorse or promote products derived from 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// this software without specific prior written permission. 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Author: wan@google.com (Zhanyong Wan) 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for Google Test itself. This verifies that the basic constructs of 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test work. 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest.h" 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that the command line flag variables can be accessed 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in code once <gtest/gtest.h> has been #included. 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Do not move it after other #includes. 4011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(break_on_failure) 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(catch_exceptions) 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(color) != "unknown" 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(filter) != "unknown" 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(list_tests) 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(output) != "unknown" 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(print_time) 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(random_seed) 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(repeat) > 0 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(show_internal_stack_frames) 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(shuffle) 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(stack_trace_depth) > 0 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(stream_result_to) != "unknown" 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert || testing::GTEST_FLAG(throw_on_failure); 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <limits.h> // For INT_MAX. 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <stdlib.h> 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <string.h> 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <time.h> 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <map> 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <vector> 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include <ostream> 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "gtest/gtest-spi.h" 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Indicates that this translation unit is part of Google Test's 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implementation. It must come before gtest-internal-inl.h is 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// included, or there will be a compiler error. This trick is to 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// prevent a user from accidentally including gtest-internal-inl.h in 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// his code. 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_IMPLEMENTATION_ 1 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#include "src/gtest-internal-inl.h" 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#undef GTEST_IMPLEMENTATION_ 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace internal { 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_STREAM_RESULTS_ 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass StreamingListenerTest : public Test { 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert class FakeSocketWriter : public StreamingListener::AbstractSocketWriter { 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Sends a string to the socket. 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void Send(const string& message) { output_ += message; } 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert string output_; 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamingListenerTest() 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : fake_sock_writer_(new FakeSocketWriter), 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_(fake_sock_writer_), 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_info_obj_("FooTest", "Bar", NULL, NULL, 0, NULL) {} 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert string* output() { return &(fake_sock_writer_->output_); } 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FakeSocketWriter* const fake_sock_writer_; 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StreamingListener streamer_; 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest unit_test_; 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestInfo test_info_obj_; // The name test_info_ was taken by testing::Test. 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestProgramEnd) { 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestProgramEnd(unit_test_); 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestProgramEnd&passed=1\n", *output()); 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestIterationEnd) { 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestIterationEnd(unit_test_, 42); 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output()); 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestCaseStart) { 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", NULL, NULL)); 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output()); 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestCaseEnd) { 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", NULL, NULL)); 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output()); 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestStart) { 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestStart(test_info_obj_); 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestStart&name=Bar\n", *output()); 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestEnd) { 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestEnd(test_info_obj_); 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("event=TestEnd&passed=1&elapsed_time=0ms\n", *output()); 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(StreamingListenerTest, OnTestPartResult) { 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output() = ""; 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamer_.OnTestPartResult(TestPartResult( 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%")); 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Meta characters in the failure message should be properly escaped. 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ( 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "event=TestPartResult&file=foo.cc&line=42&message=failed%3D%0A%26%25\n", 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *output()); 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_CAN_STREAM_RESULTS_ 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Provides access to otherwise private parts of the TestEventListeners class 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that are needed to test it. 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestEventListenersAccessor { 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static TestEventListener* GetRepeater(TestEventListeners* listeners) { 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return listeners->repeater(); 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetDefaultResultPrinter(TestEventListeners* listeners, 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListener* listener) { 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners->SetDefaultResultPrinter(listener); 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetDefaultXmlGenerator(TestEventListeners* listeners, 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListener* listener) { 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners->SetDefaultXmlGenerator(listener); 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool EventForwardingEnabled(const TestEventListeners& listeners) { 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return listeners.EventForwardingEnabled(); 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SuppressEventForwarding(TestEventListeners* listeners) { 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners->SuppressEventForwarding(); 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass UnitTestRecordPropertyTestHelper : public Test { 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordPropertyTestHelper() {} 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Forwards to UnitTest::RecordProperty() to bypass access controls. 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void UnitTestRecordProperty(const char* key, const std::string& value) { 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.RecordProperty(key, value); 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest unit_test_; 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace internal 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::AssertionFailure; 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::AssertionResult; 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::AssertionSuccess; 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::DoubleLE; 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::EmptyTestEventListener; 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::Environment; 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::FloatLE; 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(also_run_disabled_tests); 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(break_on_failure); 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(catch_exceptions); 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(color); 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(death_test_use_fork); 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(filter); 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(list_tests); 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(output); 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(print_time); 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(random_seed); 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(repeat); 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(show_internal_stack_frames); 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(shuffle); 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(stack_trace_depth); 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(stream_result_to); 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::GTEST_FLAG(throw_on_failure); 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::IsNotSubstring; 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::IsSubstring; 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::Message; 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::ScopedFakeTestPartResultReporter; 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::StaticAssertTypeEq; 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::Test; 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestCase; 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestEventListeners; 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestInfo; 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestPartResult; 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestPartResultArray; 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestProperty; 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TestResult; 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::TimeInMillis; 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::UnitTest; 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::kMaxStackTraceDepth; 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AddReference; 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AlwaysFalse; 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AlwaysTrue; 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::AppendUserMessage; 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ArrayAwareFind; 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ArrayEq; 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CodePointToUtf8; 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CompileAssertTypesEqual; 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CopyArray; 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CountIf; 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::EqFailure; 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::FloatingPoint; 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ForEach; 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::FormatEpochTimeInMillisAsIso8601; 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::FormatTimeInMillisAsSeconds; 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GTestFlagSaver; 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetCurrentOsStackTraceExceptTop; 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetElementOr; 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetNextRandomSeed; 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetRandomSeedFromFlag; 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetTestTypeId; 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetTimeInMillis; 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetTypeId; 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetUnitTestImpl; 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ImplicitlyConvertible; 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::Int32; 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::Int32FromEnvOrDie; 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::IsAProtocolMessage; 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::IsContainer; 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::IsContainerTest; 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::IsNotContainer; 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::NativeArray; 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ParseInt32Flag; 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::RemoveConst; 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::RemoveReference; 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ShouldRunTestOnShard; 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ShouldShard; 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ShouldUseColor; 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::Shuffle; 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ShuffleRange; 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::SkipPrefix; 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::StreamableToString; 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::String; 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::TestEventListenersAccessor; 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::TestResultAccessor; 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::UInt32; 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::WideStringToUtf8; 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::kCopy; 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::kMaxRandomSeed; 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::kReference; 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::kTestTypeIdInGoogleTest; 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::scoped_ptr; 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STREAM_REDIRECTION 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::CaptureStdout; 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::GetCapturedStdout; 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_IS_THREADSAFE 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::ThreadWithParam; 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestingVector : public std::vector<int> { 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert::std::ostream& operator<<(::std::ostream& os, 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestingVector& vector) { 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert os << "{ "; 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t i = 0; i < vector.size(); i++) { 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert os << vector[i] << " "; 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert os << "}"; 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os; 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This line tests that we can define tests in an unnamed namespace. 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace { 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetRandomSeedFromFlagTest, HandlesZero) { 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int seed = GetRandomSeedFromFlag(0); 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(1, seed); 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed)); 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetRandomSeedFromFlagTest, PreservesValidSeed) { 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, GetRandomSeedFromFlag(1)); 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, GetRandomSeedFromFlag(2)); 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1)); 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GetRandomSeedFromFlag(kMaxRandomSeed)); 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) { 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int seed1 = GetRandomSeedFromFlag(-1); 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(1, seed1); 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed)); 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1); 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(1, seed2); 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed)); 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetNextRandomSeedTest, WorksForValidInput) { 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, GetNextRandomSeed(1)); 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3, GetNextRandomSeed(2)); 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GetNextRandomSeed(kMaxRandomSeed - 1)); 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed)); 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We deliberately don't test GetNextRandomSeed() with invalid 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // inputs, as that requires death tests, which are expensive. This 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is fine as GetNextRandomSeed() is internal and has a 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // straightforward definition. 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void ClearCurrentTestPartResults() { 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::ClearTestPartResults( 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GetUnitTestImpl()->current_test_result()); 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GetTypeId. 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetTypeIdTest, ReturnsSameValueForSameType) { 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>()); 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>()); 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass SubClassOfTest : public Test {}; 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass AnotherSubClassOfTest : public Test {}; 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) { 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>()); 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<int>(), GetTypeId<char>()); 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<int>(), GetTestTypeId()); 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId()); 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId()); 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>()); 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that GetTestTypeId() returns the same value, no matter it 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is called from inside Google Test or outside of it. 37811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) { 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId()); 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests FormatTimeInMillisAsSeconds(). 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(FormatTimeInMillisAsSecondsTest, FormatsZero) { 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0)); 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) { 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3)); 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10)); 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200)); 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200)); 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000)); 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) { 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3)); 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10)); 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200)); 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200)); 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000)); 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests FormatEpochTimeInMillisAsIso8601(). The correctness of conversion 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// for particular dates below was verified in Python using 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// datetime.datetime.fromutctimestamp(<timetamp>/1000). 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// have to set up a particular timezone to obtain predictable results. 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass FormatEpochTimeInMillisAsIso8601Test : public Test { 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // On Cygwin, GCC doesn't allow unqualified integer literals to exceed 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 32 bits, even when 64-bit integer types are available. We have to 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // force the constants to have a 64-bit type here. 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const TimeInMillis kMillisPerSec = 1000; 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saved_tz_ = NULL; 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if _MSC_VER 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(push) // Saves the current warning state. 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(disable:4996) // Temporarily disables warning 4996 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (function or variable may be unsafe 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // for getenv, function is deprecated for 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // strdup). 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (getenv("TZ")) 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saved_tz_ = strdup(getenv("TZ")); 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(pop) // Restores the warning state again. 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (getenv("TZ")) 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saved_tz_ = strdup(getenv("TZ")); 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // cannot use the local time zone because the function's output depends 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // on the time zone. 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetTimeZone("UTC+00"); 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void TearDown() { 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetTimeZone(saved_tz_); 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert free(const_cast<char*>(saved_tz_)); 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saved_tz_ = NULL; 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetTimeZone(const char* time_zone) { 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // tzset() distinguishes between the TZ variable being present and empty 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // and not being present, so we have to consider the case of time_zone 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // being NULL. 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if _MSC_VER 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...Unless it's MSVC, whose standard library's _putenv doesn't 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // distinguish between an empty and a missing variable. 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string env_var = 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string("TZ=") + (time_zone ? time_zone : ""); 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _putenv(env_var.c_str()); 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(push) // Saves the current warning state. 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(disable:4996) // Temporarily disables warning 4996 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (function is deprecated). 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert tzset(); 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma warning(pop) // Restores the warning state again. 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (time_zone) { 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert setenv(("TZ"), time_zone, 1); 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsetenv("TZ"); 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert tzset(); 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* saved_tz_; 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec; 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) { 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("2011-10-31T18:52:42", 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec)); 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) { 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ( 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2011-10-31T18:52:42", 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234)); 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) { 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("2011-09-03T05:07:02", 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec)); 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) { 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("2011-09-28T17:08:22", 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec)); 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) { 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0)); 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_COMPARE_NULL 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef __BORLANDC__ 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Silences warnings: "Condition is always true", "Unreachable code" 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option push -w-ccc -w-rch 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pointer literal. 51011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NullLiteralTest, IsTrueForNullLiterals) { 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL)); 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0)); 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U)); 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L)); 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __BORLANDC__ 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some compilers may fail to detect some null pointer literals; 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // as long as users of the framework don't use such literals, this 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is harmless. 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(1 - 1)); 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// pointer literal. 52811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1)); 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0)); 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a')); 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL))); 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifdef __BORLANDC__ 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Restores warnings after previous "#pragma option push" suppressed them. 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option pop 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_CAN_COMPARE_NULL 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests CodePointToUtf8(). 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the NUL character L'\0' is encoded correctly. 54511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncodeNul) { 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("", CodePointToUtf8(L'\0')); 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASCII characters are encoded correctly. 55011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncodeAscii) { 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("a", CodePointToUtf8(L'a')); 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("Z", CodePointToUtf8(L'Z')); 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("&", CodePointToUtf8(L'&')); 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\x7F", CodePointToUtf8(L'\x7F')); 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 8 to 11 bits are encoded 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 110xxxxx 10xxxxxx. 55911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 000 1101 0011 => 110-00011 10-010011 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xC3\x93", CodePointToUtf8(L'\xD3')); 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 101 0111 0110 => 110-10101 10-110110 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // in wide strings and wide chars. In order to accomodate them, we have to 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // introduce such character constants as integers. 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xD5\xB6", 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CodePointToUtf8(static_cast<wchar_t>(0x576))); 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 12 to 16 bits are encoded 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 1110xxxx 10xxxxxx 10xxxxxx. 57311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xE0\xA3\x93", 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CodePointToUtf8(static_cast<wchar_t>(0x8D3))); 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xEC\x9D\x8D", 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CodePointToUtf8(static_cast<wchar_t>(0xC74D))); 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_WIDE_STRING_USES_UTF16_ 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests in this group require a wchar_t to hold > 16 bits, and thus 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 16-bit wide. This code may not compile on those systems. 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 17 to 21 bits are encoded 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 59011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3')); 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400')); 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634')); 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that encoding an invalid code-point generates the expected result. 60211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("(Invalid Unicode 0x1234ABCD)", CodePointToUtf8(L'\x1234ABCD')); 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_WIDE_STRING_USES_UTF16_ 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests WideStringToUtf8(). 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the NUL character L'\0' is encoded correctly. 61111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncodeNul) { 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASCII strings are encoded correctly. 61711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncodeAscii) { 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 8 to 11 bits are encoded 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 110xxxxx 10xxxxxx. 62611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 000 1101 0011 => 110-00011 10-010011 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 101 0111 0110 => 110-10101 10-110110 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s[] = { 0x576, '\0' }; 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str()); 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str()); 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 12 to 16 bits are encoded 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 1110xxxx 10xxxxxx 10xxxxxx. 63911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s1[] = { 0x8D3, '\0' }; 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str()); 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str()); 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s2[] = { 0xC74D, '\0' }; 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str()); 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str()); 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the conversion stops when the function encounters \0 character. 65211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the conversion stops when the function reaches the limit 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// specified by the 'length' parameter. 65811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_WIDE_STRING_USES_UTF16_ 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Unicode code-points that have 17 to 21 bits are encoded 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// on the systems using UTF-16 encoding. 66611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that encoding an invalid code-point generates the expected result. 67711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert WideStringToUtf8(L"\xABCDFF", -1).c_str()); 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else // !GTEST_WIDE_STRING_USES_UTF16_ 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that surrogate pairs are encoded correctly on the systems using 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// UTF-16 encoding in the wide strings. 68411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s[] = { 0xD801, 0xDC00, '\0' }; 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str()); 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that encoding an invalid UTF-16 surrogate pair 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// generates the expected result. 69111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Leading surrogate is at the end of the string. 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s1[] = { 0xD800, '\0' }; 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str()); 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Leading surrogate is not followed by the trailing surrogate. 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s2[] = { 0xD800, 'M', '\0' }; 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str()); 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Trailing surrogate appearas without a leading surrogate. 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' }; 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str()); 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_WIDE_STRING_USES_UTF16_ 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that codepoint concatenation works correctly. 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_WIDE_STRING_USES_UTF16_ 70611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'}; 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xF4\x88\x98\xB4" 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xEC\x9D\x8D" 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\n" 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xD5\xB6" 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xE0\xA3\x93" 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xF4\x88\x98\xB4", 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert WideStringToUtf8(s, -1).c_str()); 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 71811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'}; 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert WideStringToUtf8(s, -1).c_str()); 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_WIDE_STRING_USES_UTF16_ 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the Random class. 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) { 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random(42); 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random.Generate(0), 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Cannot generate a number in the range \\[0, 0\\)"); 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random.Generate(testing::internal::Random::kMaxRange + 1), 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Generation of a number in \\[0, 2147483649\\) was requested, " 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "but this can only generate numbers in \\[0, 2147483648\\)"); 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RandomTest, GeneratesNumbersWithinRange) { 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const UInt32 kRange = 10000; 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random(12345); 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < 10; i++) { 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i; 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random2(testing::internal::Random::kMaxRange); 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < 10; i++) { 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i; 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RandomTest, RepeatsWhenReseeded) { 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int kSeed = 123; 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int kArraySize = 10; 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const UInt32 kRange = 10000; 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UInt32 values[kArraySize]; 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random(kSeed); 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < kArraySize; i++) { 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values[i] = random.Generate(kRange); 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random.Reseed(kSeed); 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < kArraySize; i++) { 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i; 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests STL container utilities. 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests CountIf(). 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool IsPositive(int n) { return n > 0; } 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ContainerUtilityTest, CountIf) { 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<int> v; 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, CountIf(v, IsPositive)); // Works for an empty container. 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(-1); 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(0); 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, CountIf(v, IsPositive)); // Works when no value satisfies. 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(2); 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(-10); 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(10); 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, CountIf(v, IsPositive)); 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ForEach(). 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic int g_sum = 0; 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void Accumulate(int n) { g_sum += n; } 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ContainerUtilityTest, ForEach) { 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<int> v; 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert g_sum = 0; 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ForEach(v, Accumulate); 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, g_sum); // Works for an empty container; 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert g_sum = 0; 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(1); 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ForEach(v, Accumulate); 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, g_sum); // Works for a container with one element. 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert g_sum = 0; 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(20); 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.push_back(300); 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ForEach(v, Accumulate); 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(321, g_sum); 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GetElementOr(). 81311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ContainerUtilityTest, GetElementOr) { 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<char> a; 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('x', GetElementOr(a, 0, 'x')); 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a.push_back('a'); 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a.push_back('b'); 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('a', GetElementOr(a, 0, 'x')); 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('b', GetElementOr(a, 1, 'x')); 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('x', GetElementOr(a, -2, 'x')); 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('x', GetElementOr(a, 2, 'x')); 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ContainerUtilityDeathTest, ShuffleRange) { 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<int> a; 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a.push_back(0); 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a.push_back(1); 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a.push_back(2); 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random(1); 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random, -1, 1, &a), 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Invalid shuffle range start -1: must be in range \\[0, 3\\]"); 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random, 4, 4, &a), 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Invalid shuffle range start 4: must be in range \\[0, 3\\]"); 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random, 3, 2, &a), 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Invalid shuffle range finish 2: must be in range \\[3, 3\\]"); 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random, 3, 4, &a), 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Invalid shuffle range finish 4: must be in range \\[3, 3\\]"); 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass VectorShuffleTest : public Test { 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const int kVectorSize = 20; 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert VectorShuffleTest() : random_(1) { 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < kVectorSize; i++) { 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector_.push_back(i); 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool VectorIsCorrupt(const TestingVector& vector) { 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (kVectorSize != static_cast<int>(vector.size())) { 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool found_in_vector[kVectorSize] = { false }; 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t i = 0; i < vector.size(); i++) { 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int e = vector[i]; 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (e < 0 || e >= kVectorSize || found_in_vector[e]) { 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert found_in_vector[e] = true; 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Vector size is correct, elements' range is correct, no 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // duplicate elements. Therefore no corruption has occurred. 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return false; 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool VectorIsNotCorrupt(const TestingVector& vector) { 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return !VectorIsCorrupt(vector); 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) { 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = begin; i < end; i++) { 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (i != vector[i]) { 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return true; 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return false; 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool RangeIsUnshuffled( 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestingVector& vector, int begin, int end) { 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return !RangeIsShuffled(vector, begin, end); 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool VectorIsShuffled(const TestingVector& vector) { 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return RangeIsShuffled(vector, 0, static_cast<int>(vector.size())); 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static bool VectorIsUnshuffled(const TestingVector& vector) { 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return !VectorIsShuffled(vector); 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::internal::Random random_; 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestingVector vector_; 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; // class VectorShuffleTest 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst int VectorShuffleTest::kVectorSize; 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, HandlesEmptyRange) { 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests an empty range at the beginning... 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, 0, 0, &vector_); 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...in the middle... 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_); 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...at the end... 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_); 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...and past the end. 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_); 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) { 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests a size one range at the beginning... 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, 0, 1, &vector_); 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...in the middle... 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_); 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 93811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 93911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ...and at the end. 94111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_); 94211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsUnshuffled, vector_); 94411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 94511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Because we use our own random number generator and a fixed seed, 94711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// we can guarantee that the following "random" tests will succeed. 94811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, ShufflesEntireVector) { 95011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Shuffle(&random_, &vector_); 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_; 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests the first and last elements in particular to ensure that 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // there are no off-by-one problems in our shuffle algorithm. 95611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(0, vector_[0]); 95711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]); 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, ShufflesStartOfVector) { 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int kRangeSize = kVectorSize/2; 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, 0, kRangeSize, &vector_); 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize); 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize); 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, ShufflesEndOfVector) { 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int kRangeSize = kVectorSize / 2; 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_); 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize); 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, ShufflesMiddleOfVector) { 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int kRangeSize = kVectorSize/3; 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_); 98211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize); 98611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize); 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(VectorShuffleTest, ShufflesRepeatably) { 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestingVector vector2; 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < kVectorSize; i++) { 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector2.push_back(i); 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random_.Reseed(1234); 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Shuffle(&random_, &vector_); 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random_.Reseed(1234); 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Shuffle(&random_, &vector2); 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector_); 100111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(VectorIsNotCorrupt, vector2); 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < kVectorSize; i++) { 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i; 100511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the size of the AssertHelper class. 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertHelperTest, AssertHelperIsSmall) { 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To avoid breaking clients that use lots of assertions in one 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // function, we cannot grow the size of AssertHelper. 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*)); 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests String::EndsWithCaseInsensitive(). 101711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, EndsWithCaseInsensitive) { 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR")); 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar")); 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "")); 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::EndsWithCaseInsensitive("", "")); 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo")); 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo")); 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo")); 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// C++Builder's preprocessor is buggy; it fails to expand macros that 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// appear in macro parameters after wide char literals. Provide an alias 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// for NULL as a workaround. 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic const wchar_t* const kNull = NULL; 103211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests String::CaseInsensitiveWideCStringEquals 103411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, CaseInsensitiveWideCStringEquals) { 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"")); 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull)); 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar")); 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull)); 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests String::ShowWideCString(). 104811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, ShowWideCString) { 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(null)", 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert String::ShowWideCString(NULL).c_str()); 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_WINDOWS_MOBILE 105611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, AnsiAndUtf16Null) { 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, AnsiAndUtf16ConvertBasic) { 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* ansi = String::Utf16ToAnsi(L"str"); 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("str", ansi); 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete [] ansi; 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const WCHAR* utf16 = String::AnsiToUtf16("str"); 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, wcsncmp(L"str", utf16, 3)); 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete [] utf16; 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 107111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(".:\\ \"*?", ansi); 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete [] ansi; 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3)); 107611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete [] utf16; 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_WINDOWS_MOBILE 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestProperty construction. 108311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestPropertyTest, StringValue) { 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property("key", "1"); 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key", property.key()); 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", property.value()); 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestProperty replacing a value. 109011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestPropertyTest, ReplaceStringValue) { 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property("key", "1"); 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", property.value()); 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert property.SetValue("2"); 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2", property.value()); 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// AddFatalFailure() and AddNonfatalFailure() must be stand-alone 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// functions (i.e. their definitions cannot be inlined at the call 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// sites), or C++Builder won't compile the code. 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void AddFatalFailure() { 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Expected fatal failure."; 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void AddNonfatalFailure() { 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "Expected non-fatal failure."; 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ScopedFakeTestPartResultReporterTest : public Test { 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: // Must be public and not protected due to a bug in g++ 3.4.2. 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert enum FailureMode { 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FATAL_FAILURE, 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NONFATAL_FAILURE 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void AddFailure(FailureMode failure) { 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (failure == FATAL_FAILURE) { 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFatalFailure(); 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddNonfatalFailure(); 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ScopedFakeTestPartResultReporter intercepts test 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// failures. 112511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray results; 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter reporter( 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert &results); 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailure(NONFATAL_FAILURE); 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailure(FATAL_FAILURE); 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, results.size()); 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 113711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) { 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray results; 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests, that the deprecated constructor still works. 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter reporter(&results); 114511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailure(NONFATAL_FAILURE); 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, results.size()); 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_IS_THREADSAFE 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ScopedFakeTestPartResultReporterWithThreadsTest 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : public ScopedFakeTestPartResultReporterTest { 115411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void AddFailureInOtherThread(FailureMode failure) { 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert thread.Join(); 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ScopedFakeTestPartResultReporterWithThreadsTest, 116211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert InterceptsTestFailuresInAllThreads) { 116311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray results; 116411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 116511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter reporter( 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results); 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailure(NONFATAL_FAILURE); 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailure(FATAL_FAILURE); 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailureInOtherThread(NONFATAL_FAILURE); 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailureInOtherThread(FATAL_FAILURE); 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(4, results.size()); 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed()); 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed()); 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_IS_THREADSAFE 118111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// work even if the failure is generated in a called function rather than 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the current context. 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest; 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) { 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure."); 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 119311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, AcceptsStringObject) { 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure.")); 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) { 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(AddFatalFailure(), 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::string("Expected fatal failure.")); 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) { 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We have another test below to verify that the macro catches fatal 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failures generated on another thread. 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(), 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected fatal failure."); 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 121111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Silences warnings: "Condition is always true" 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option push -w-ccc 121311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 121411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void 121611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function even when the statement in it contains ASSERT_*. 121711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint NonVoidFunction() { 121911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 122011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 122111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return 0; 122211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 122311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) { 122511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NonVoidFunction(); 122611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 122711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the 122911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// current function even though 'statement' generates a fatal failure. 123011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid DoesNotAbortHelper(bool* aborted) { 123211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 123311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 123411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = false; 123611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 123711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 123911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Restores warnings after previous "#pragma option push" suppressed them. 124011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option pop 124111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 124211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, DoesNotAbort) { 124411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool aborted = true; 124511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DoesNotAbortHelper(&aborted); 124611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(aborted); 124711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 124811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a 125011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// statement that contains a macro which expands to code containing an 125111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// unprotected comma. 125211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic int global_var = 0; 125411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++ 125511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 125711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ 125811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder. 125911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ 126011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_USE_UNPROTECTED_COMMA_; 126111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFatalFailure(); 126211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 126311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 126411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE_ON_ALL_THREADS({ 126611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_USE_UNPROTECTED_COMMA_; 126711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFatalFailure(); 126811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 126911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 127011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}. 127211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest; 127411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) { 127611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 127711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected non-fatal failure."); 127811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 127911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 128011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 128111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) { 128211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 128311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::string("Expected non-fatal failure.")); 128411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 128511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 128611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 128711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) { 128811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 128911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::string("Expected non-fatal failure.")); 129011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 129111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) { 129311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We have another test below to verify that the macro catches 129411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // non-fatal failures generated on another thread. 129511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(), 129611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected non-fatal failure."); 129711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 129811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a 130011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// statement that contains a macro which expands to code containing an 130111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// unprotected comma. 130211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 130311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ 130411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_USE_UNPROTECTED_COMMA_; 130511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddNonfatalFailure(); 130611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 130711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({ 130911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_USE_UNPROTECTED_COMMA_; 131011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddNonfatalFailure(); 131111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 131211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 131311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_IS_THREADSAFE 131511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ScopedFakeTestPartResultReporterWithThreadsTest 131711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectFailureWithThreadsTest; 131811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) { 132011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE), 132111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected fatal failure."); 132211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 132311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 132411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) { 132511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS( 132611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure."); 132711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 132811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 132911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_IS_THREADSAFE 133011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the TestProperty class. 133211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestPropertyTest, ConstructorWorks) { 133411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty property("key", "value"); 133511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key", property.key()); 133611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("value", property.value()); 133711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 133811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestPropertyTest, SetValue) { 134011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property("key", "value_1"); 134111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key", property.key()); 134211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert property.SetValue("value_2"); 134311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key", property.key()); 134411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("value_2", property.value()); 134511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 134611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the TestResult class 134811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The test fixture for testing TestResult. 135011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestResultTest : public Test { 135111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 135211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef std::vector<TestPartResult> TPRVector; 135311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We make use of 2 TestPartResult objects, 135511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResult * pr1, * pr2; 135611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ... and 3 TestResult objects. 135811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult * r0, * r1, * r2; 135911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 136111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // pr1 is for success. 136211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pr1 = new TestPartResult(TestPartResult::kSuccess, 136311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo/bar.cc", 136411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10, 136511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Success!"); 136611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // pr2 is for fatal failure. 136811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert pr2 = new TestPartResult(TestPartResult::kFatalFailure, 136911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo/bar.cc", 137011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert -1, // This line number means "unknown" 137111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Failure!"); 137211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates the TestResult objects. 137411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r0 = new TestResult(); 137511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r1 = new TestResult(); 137611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r2 = new TestResult(); 137711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In order to test TestResult, we need to modify its internal 137911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // state, in particular the TestPartResult vector it holds. 138011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test_part_results() returns a const reference to this vector. 138111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We cast it to a non-const object s.t. it can be modified (yes, 138211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this is a hack). 138311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TPRVector* results1 = const_cast<TPRVector*>( 138411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert &TestResultAccessor::test_part_results(*r1)); 138511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TPRVector* results2 = const_cast<TPRVector*>( 138611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert &TestResultAccessor::test_part_results(*r2)); 138711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 138811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // r0 is an empty TestResult. 138911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // r1 contains a single SUCCESS TestPartResult. 139111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert results1->push_back(*pr1); 139211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // r2 contains a SUCCESS, and a FAILURE. 139411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert results2->push_back(*pr1); 139511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert results2->push_back(*pr2); 139611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 139711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void TearDown() { 139911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete pr1; 140011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete pr2; 140111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete r0; 140311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete r1; 140411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete r2; 140511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 140611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Helper that compares two two TestPartResults. 140811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void CompareTestPartResult(const TestPartResult& expected, 140911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestPartResult& actual) { 141011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.type(), actual.type()); 141111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.file_name(), actual.file_name()); 141211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.line_number(), actual.line_number()); 141311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.summary(), actual.summary()); 141411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.message(), actual.message()); 141511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.passed(), actual.passed()); 141611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.failed(), actual.failed()); 141711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed()); 141811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed()); 141911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 142011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 142111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::total_part_count(). 142311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestResultTest, total_part_count) { 142411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, r0->total_part_count()); 142511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, r1->total_part_count()); 142611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, r2->total_part_count()); 142711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 142811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::Passed(). 143011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestResultTest, Passed) { 143111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(r0->Passed()); 143211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(r1->Passed()); 143311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(r2->Passed()); 143411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 143511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 143611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::Failed(). 143711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestResultTest, Failed) { 143811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(r0->Failed()); 143911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(r1->Failed()); 144011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(r2->Failed()); 144111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 144211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::GetTestPartResult(). 144411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef TestResultTest TestResultDeathTest; 144611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestResultDeathTest, GetTestPartResult) { 144811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompareTestPartResult(*pr1, r2->GetTestPartResult(0)); 144911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompareTestPartResult(*pr2, r2->GetTestPartResult(1)); 145011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), ""); 145111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), ""); 145211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 145311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 145411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult has no properties when none are added. 145511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 145611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult test_result; 145711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, test_result.test_property_count()); 145811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 145911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 146011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult has the expected property when added. 146111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 146211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult test_result; 146311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property("key_1", "1"); 146411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property); 146511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, test_result.test_property_count()); 146611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& actual_property = test_result.GetTestProperty(0); 146711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", actual_property.key()); 146811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", actual_property.value()); 146911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 147011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 147111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult has multiple properties when added. 147211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 147311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult test_result; 147411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_1("key_1", "1"); 147511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_2("key_2", "2"); 147611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_1); 147711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_2); 147811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, test_result.test_property_count()); 147911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 148011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", actual_property_1.key()); 148111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", actual_property_1.value()); 148211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 148411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_2", actual_property_2.key()); 148511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2", actual_property_2.value()); 148611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 148711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::RecordProperty() overrides values for duplicate keys. 148911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 149011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult test_result; 149111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_1_1("key_1", "1"); 149211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_2_1("key_2", "2"); 149311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_1_2("key_1", "12"); 149411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_2_2("key_2", "22"); 149511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_1); 149611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_1); 149711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_2); 149811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_2); 149911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, test_result.test_property_count()); 150111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 150211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", actual_property_1.key()); 150311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("12", actual_property_1.value()); 150411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 150611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_2", actual_property_2.key()); 150711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("22", actual_property_2.value()); 150811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 150911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 151011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::GetTestProperty(). 151111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestResultPropertyTest, GetTestProperty) { 151211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResult test_result; 151311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_1("key_1", "1"); 151411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_2("key_2", "2"); 151511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestProperty property_3("key_3", "3"); 151611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_1); 151711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_2); 151811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestResultAccessor::RecordProperty(&test_result, "testcase", property_3); 151911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& fetched_property_1 = test_result.GetTestProperty(0); 152111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& fetched_property_2 = test_result.GetTestProperty(1); 152211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestProperty& fetched_property_3 = test_result.GetTestProperty(2); 152311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", fetched_property_1.key()); 152511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", fetched_property_1.value()); 152611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_2", fetched_property_2.key()); 152811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2", fetched_property_2.value()); 152911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_3", fetched_property_3.key()); 153111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("3", fetched_property_3.value()); 153211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), ""); 153411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), ""); 153511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 153611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that GTestFlagSaver works on Windows and Mac. 153811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass GTestFlagSaverTest : public Test { 154011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 154111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Saves the Google Test flags such that we can restore them later, and 154211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // then sets them to their default values. This will be called 154311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // before the first test in this test case is run. 154411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 154511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saver_ = new GTestFlagSaver; 154611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 154711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(also_run_disabled_tests) = false; 154811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(break_on_failure) = false; 154911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(catch_exceptions) = false; 155011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(death_test_use_fork) = false; 155111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "auto"; 155211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(filter) = ""; 155311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(list_tests) = false; 155411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(output) = ""; 155511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(print_time) = true; 155611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(random_seed) = 0; 155711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(repeat) = 1; 155811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(shuffle) = false; 155911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 156011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stream_result_to) = ""; 156111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(throw_on_failure) = false; 156211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 156311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Restores the Google Test flags that the tests have modified. This will 156511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // be called after the last test in this test case is run. 156611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TearDownTestCase() { 156711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete saver_; 156811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert saver_ = NULL; 156911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 157011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 157111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies that the Google Test flags have their default values, and then 157211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // modifies each of them. 157311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void VerifyAndModifyFlags() { 157411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests)); 157511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 157611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 157711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 157811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(death_test_use_fork)); 157911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 158011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(list_tests)); 158111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 158211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(GTEST_FLAG(print_time)); 158311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GTEST_FLAG(random_seed)); 158411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, GTEST_FLAG(repeat)); 158511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(shuffle)); 158611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth)); 158711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str()); 158811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(GTEST_FLAG(throw_on_failure)); 158911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 159011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(also_run_disabled_tests) = true; 159111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(break_on_failure) = true; 159211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(catch_exceptions) = true; 159311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "no"; 159411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(death_test_use_fork) = true; 159511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(filter) = "abc"; 159611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(list_tests) = true; 159711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(output) = "xml:foo.xml"; 159811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(print_time) = false; 159911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(random_seed) = 1; 160011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(repeat) = 100; 160111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(shuffle) = true; 160211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stack_trace_depth) = 1; 160311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stream_result_to) = "localhost:1234"; 160411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(throw_on_failure) = true; 160511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 160611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 160711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 160811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // For saving Google Test flags during this test case. 160911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static GTestFlagSaver* saver_; 161011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 161111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 161311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Google Test doesn't guarantee the order of tests. The following two 161511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tests are designed to work regardless of their order. 161611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Modifies the Google Test flags in the test body. 161811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 161911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert VerifyAndModifyFlags(); 162011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 162111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that the Google Test flags in the body of the previous test were 162311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// restored to their original values. 162411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 162511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert VerifyAndModifyFlags(); 162611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 162711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sets an environment variable with the given name to the given 162911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// value. If the value argument is "", unsets the environment 163011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// variable. The caller must ensure that both arguments are not NULL. 163111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void SetEnv(const char* name, const char* value) { 163211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS_MOBILE 163311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Environment variables are not supported on Windows CE. 163411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 163511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 163611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++Builder's putenv only stores a pointer to its parameter; we have to 163711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ensure that the string remains valid as long as it might be needed. 163811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use an std::map to do so. 163911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static std::map<std::string, std::string*> added_env; 164011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 164111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Because putenv stores a pointer to the string buffer, we can't delete the 164211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // previous string (if present) until after it's replaced. 164311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string *prev_env = NULL; 164411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (added_env.find(name) != added_env.end()) { 164511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert prev_env = added_env[name]; 164611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 164711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert added_env[name] = new std::string( 164811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (Message() << name << "=" << value).GetString()); 164911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The standard signature of putenv accepts a 'char*' argument. Other 165111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // implementations, like C++Builder's, accept a 'const char*'. 165211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We cast away the 'const' since that would work for both variants. 165311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert putenv(const_cast<char*>(added_env[name]->c_str())); 165411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete prev_env; 165511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#elif GTEST_OS_WINDOWS // If we are on Windows proper. 165611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _putenv((Message() << name << "=" << value).GetString().c_str()); 165711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 165811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (*value == '\0') { 165911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsetenv(name); 166011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 166111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert setenv(name, value, 1); 166211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 166311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS_MOBILE 166411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 166511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 166611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 166711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Environment variables are not supported on Windows CE. 166811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 166911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertusing testing::internal::Int32FromGTestEnv; 167011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 167111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests Int32FromGTestEnv(). 167211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 167311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromGTestEnv() returns the default value when the 167411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable is not set. 167511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 167611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", ""); 167711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 167811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 167911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromGTestEnv() returns the default value when the 168111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable overflows as an Int32. 168211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 168311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("(expecting 2 warnings)\n"); 168411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321"); 168611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 168711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321"); 168911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 169011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 169111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 169211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromGTestEnv() returns the default value when the 169311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable does not represent a valid decimal integer. 169411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 169511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("(expecting 2 warnings)\n"); 169611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 169711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1"); 169811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 169911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X"); 170111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 170211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 170311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 170411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromGTestEnv() parses and returns the value of the 170511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// environment variable when it represents a valid decimal integer in 170611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the range of an Int32. 170711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 170811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123"); 170911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 171011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 171111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321"); 171211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 171311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 171411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_WINDOWS_MOBILE 171511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 171611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ParseInt32Flag(). 171711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 171811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ParseInt32Flag() returns false and doesn't change the 171911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// output value when the flag has wrong format 172011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 172111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 value = 123; 172211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 172311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 172411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 172511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 172611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 172711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 172811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 172911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ParseInt32Flag() returns false and doesn't change the 173011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// output value when the flag overflows as an Int32. 173111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 173211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("(expecting 2 warnings)\n"); 173311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 173411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 value = 123; 173511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 173611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 173711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 173811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 173911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 174011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 174111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 174211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ParseInt32Flag() returns false and doesn't change the 174311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// output value when the flag does not represent a valid decimal 174411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// integer. 174511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 174611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("(expecting 2 warnings)\n"); 174711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 174811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 value = 123; 174911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 175011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 175111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 175211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 175311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, value); 175411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 175511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 175611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ParseInt32Flag() parses the value of the flag and 175711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// returns true when the flag represents a valid decimal integer in 175811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the range of an Int32. 175911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 176011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 value = 123; 176111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value)); 176211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(456, value); 176311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 176411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", 176511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "abc", &value)); 176611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(-789, value); 176711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 176811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 176911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromEnvOrDie() parses the value of the var or 177011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// returns the correct default. 177111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Environment variables are not supported on Windows CE. 177211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 177311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { 177411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 177511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); 177611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 177711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123"); 177811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 177911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 178011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_WINDOWS_MOBILE 178111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 178211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromEnvOrDie() aborts with an error message 178311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if the variable is not an Int32. 178411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) { 178511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx"); 178611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 178711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 178811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ".*"); 178911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 179011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 179111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Int32FromEnvOrDie() aborts with an error message 179211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if the variable cannot be represnted by an Int32. 179311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) { 179411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234"); 179511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED( 179611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 179711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ".*"); 179811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 179911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 180011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ShouldRunTestOnShard() selects all tests 180111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// where there is 1 shard. 180211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) { 180311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0)); 180411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1)); 180511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2)); 180611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3)); 180711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4)); 180811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 180911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 181011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ShouldShardTest : public testing::Test { 181111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 181211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 181311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX"; 181411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL"; 181511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 181611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 181711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void TearDown() { 181811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, ""); 181911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, ""); 182011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 182111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 182211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* index_var_; 182311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* total_var_; 182411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 182511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 182611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that sharding is disabled if neither of the environment variables 182711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// are set. 182811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) { 182911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, ""); 183011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, ""); 183111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 183211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 183311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 183411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 183511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 183611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that sharding is not enabled if total_shards == 1. 183711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) { 183811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "0"); 183911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "1"); 184011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 184111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 184211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 184311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 184411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that sharding is enabled if total_shards > 1 and 184511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// we are not in a death test subprocess. 184611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Environment variables are not supported on Windows CE. 184711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_WINDOWS_MOBILE 184811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { 184911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "4"); 185011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "22"); 185111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 185211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 185311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 185411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "8"); 185511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "9"); 185611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 185711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 185811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 185911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "0"); 186011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "9"); 186111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 186211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 186311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 186411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_WINDOWS_MOBILE 186511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 186611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that we exit in error if the sharding values are not valid. 186711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 186811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef ShouldShardTest ShouldShardDeathTest; 186911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 187011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) { 187111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "4"); 187211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "4"); 187311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 187411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 187511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "4"); 187611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "-2"); 187711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 187811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 187911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, "5"); 188011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, ""); 188111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 188211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 188311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(index_var_, ""); 188411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv(total_var_, "5"); 188511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 188611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 188711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 188811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ShouldRunTestOnShard is a partition when 5 188911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// shards are used. 189011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { 189111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Choose an arbitrary number of tests and shards. 189211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int num_tests = 17; 189311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int num_shards = 5; 189411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 189511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Check partitioning: each test should be on exactly 1 shard. 189611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int test_id = 0; test_id < num_tests; test_id++) { 189711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int prev_selected_shard_index = -1; 189811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int shard_index = 0; shard_index < num_shards; shard_index++) { 189911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) { 190011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (prev_selected_shard_index < 0) { 190111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert prev_selected_shard_index = shard_index; 190211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 190311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and " 190411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << shard_index << " are both selected to run test " << test_id; 190511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 190611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 190711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 190811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 190911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 191011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Check balance: This is not required by the sharding protocol, but is a 191111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // desirable property for performance. 191211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int shard_index = 0; shard_index < num_shards; shard_index++) { 191311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int num_tests_on_shard = 0; 191411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int test_id = 0; test_id < num_tests; test_id++) { 191511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert num_tests_on_shard += 191611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ShouldRunTestOnShard(num_shards, shard_index, test_id); 191711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 191811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(num_tests_on_shard, num_tests / num_shards); 191911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 192011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 192111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 192211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// For the same reason we are not explicitly testing everything in the 192311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Test class, there are no separate tests for the following classes 192411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (except for some trivial cases): 192511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 192611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TestCase, UnitTest, UnitTestResultPrinter. 192711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 192811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Similarly, there are no separate tests for the following macros: 192911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 193011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TEST, TEST_F, RUN_ALL_TESTS 193111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 193211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(UnitTestTest, CanGetOriginalWorkingDir) { 193311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 193411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 193511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 193611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 193711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(UnitTestTest, ReturnsPlausibleTimestamp) { 193811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp()); 193911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis()); 194011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 194111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 194211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// When a property using a reserved key is supplied to this function, it 194311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tests that a non-fatal failure is added, a fatal failure is not added, 194411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and that the property is not recorded. 194511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey( 194611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestResult& test_result, const char* key) { 194711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key"); 194811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key 194911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "' recorded unexpectedly."; 195011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 195111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 195211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 195311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* key) { 195411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); 195511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(test_info != NULL); 195611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKey(*test_info->result(), 195711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert key); 195811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 195911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 196011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 196111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* key) { 196211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); 196311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(test_case != NULL); 196411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKey( 196511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_case->ad_hoc_test_result(), key); 196611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 196711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 196811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 196911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* key) { 197011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKey( 197111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest::GetInstance()->ad_hoc_test_result(), key); 197211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 197311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 197411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that property recording functions in UnitTest outside of tests 197511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// functions correcly. Creating a separate instance of UnitTest ensures it 197611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is in a state similar to the UnitTest's singleton's between tests. 197711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass UnitTestRecordPropertyTest : 197811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public testing::internal::UnitTestRecordPropertyTestHelper { 197911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 198011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 198111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 198211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "disabled"); 198311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 198411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "errors"); 198511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 198611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "failures"); 198711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 198811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "name"); 198911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 199011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "tests"); 199111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 199211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "time"); 199311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 199411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::RecordProperty("test_case_key_1", "1"); 199511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); 199611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(test_case != NULL); 199711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 199811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count()); 199911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("test_case_key_1", 200011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_case->ad_hoc_test_result().GetTestProperty(0).key()); 200111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", 200211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert test_case->ad_hoc_test_result().GetTestProperty(0).value()); 200311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 200411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 200511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 200611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult has the expected property when added. 200711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) { 200811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_1", "1"); 200911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 201011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, unit_test_.ad_hoc_test_result().test_property_count()); 201111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 201211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", 201311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 201411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", 201511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 201611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 201711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 201811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult has multiple properties when added. 201911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) { 202011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_1", "1"); 202111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_2", "2"); 202211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 202311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count()); 202411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 202511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", 202611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 202711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 202811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 202911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_2", 203011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(1).key()); 203111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2", unit_test_.ad_hoc_test_result().GetTestProperty(1).value()); 203211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 203311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 203411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestResult::RecordProperty() overrides values for duplicate keys. 203511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) { 203611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_1", "1"); 203711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_2", "2"); 203811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_1", "12"); 203911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTestRecordProperty("key_2", "22"); 204011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 204111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count()); 204211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 204311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_1", 204411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 204511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("12", 204611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 204711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 204811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("key_2", 204911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(1).key()); 205011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("22", 205111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unit_test_.ad_hoc_test_result().GetTestProperty(1).value()); 205211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 205311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 205411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(UnitTestRecordPropertyTest, 205511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddFailureInsideTestsWhenUsingTestCaseReservedKeys) { 205611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 205711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "name"); 205811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 205911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "value_param"); 206011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 206111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "type_param"); 206211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 206311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "status"); 206411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 206511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "time"); 206611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 206711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "classname"); 206811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 206911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 207011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(UnitTestRecordPropertyTest, 207111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddRecordWithReservedKeysGeneratesCorrectPropertyList) { 207211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 207311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::RecordProperty("name", "1"), 207411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "'classname', 'name', 'status', 'time', 'type_param', and 'value_param'" 207511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " are reserved"); 207611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 207711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 207811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass UnitTestRecordPropertyTestEnvironment : public Environment { 207911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 208011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void TearDown() { 208111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 208211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "tests"); 208311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 208411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "failures"); 208511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 208611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "disabled"); 208711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 208811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "errors"); 208911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 209011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "name"); 209111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 209211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "timestamp"); 209311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 209411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "time"); 209511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 209611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "random_seed"); 209711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 209811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 209911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 210011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This will test property recording outside of any test or test case. 210111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic Environment* record_property_env = 210211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment); 210311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 210411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 210511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of various arities. They do not attempt to be exhaustive. Rather, 210611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// view them as smoke tests that can be easily reviewed and verified. 210711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A more complete set of tests for predicate assertions can be found 210811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in gtest_pred_impl_unittest.cc. 210911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 211011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// First, some predicates and predicate-formatters needed by the tests. 211111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 211211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns true iff the argument is an even number. 211311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool IsEven(int n) { 211411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (n % 2) == 0; 211511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 211611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 211711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A functor that returns true iff the argument is an even number. 211811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct IsEvenFunctor { 211911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator()(int n) { return IsEven(n); } 212011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 212111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 212211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate-formatter function that asserts the argument is an even 212311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// number. 212411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult AssertIsEven(const char* expr, int n) { 212511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsEven(n)) { 212611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionSuccess(); 212711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 212811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 212911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 213011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << expr << " evaluates to " << n << ", which is not even."; 213111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionFailure(msg); 213211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 213311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 213411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate function that returns AssertionResult for use in 213511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT/ASSERT_TRUE/FALSE. 213611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult ResultIsEven(int n) { 213711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsEven(n)) 213811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionSuccess() << n << " is even"; 213911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 214011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionFailure() << n << " is odd"; 214111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 214211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 214311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate function that returns AssertionResult but gives no 214411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// explanation why it succeeds. Needed for testing that 214511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT/ASSERT_FALSE handles such functions correctly. 214611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult ResultIsEvenNoExplanation(int n) { 214711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsEven(n)) 214811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionSuccess(); 214911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 215011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionFailure() << n << " is odd"; 215111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 215211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 215311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate-formatter functor that asserts the argument is an even 215411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// number. 215511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct AssertIsEvenFunctor { 215611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult operator()(const char* expr, int n) { 215711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertIsEven(expr, n); 215811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 215911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 216011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 216111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Returns true iff the sum of the arguments is an even number. 216211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool SumIsEven2(int n1, int n2) { 216311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return IsEven(n1 + n2); 216411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 216511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 216611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A functor that returns true iff the sum of the arguments is an even 216711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// number. 216811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct SumIsEven3Functor { 216911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator()(int n1, int n2, int n3) { 217011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return IsEven(n1 + n2 + n3); 217111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 217211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 217311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 217411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate-formatter function that asserts the sum of the 217511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// arguments is an even number. 217611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult AssertSumIsEven4( 217711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* e1, const char* e2, const char* e3, const char* e4, 217811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n1, int n2, int n3, int n4) { 217911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int sum = n1 + n2 + n3 + n4; 218011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsEven(sum)) { 218111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionSuccess(); 218211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 218311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 218411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 218511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 218611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 218711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << ") evaluates to " << sum << ", which is not even."; 218811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionFailure(msg); 218911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 219011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 219111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A predicate-formatter functor that asserts the sum of the arguments 219211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is an even number. 219311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct AssertSumIsEven5Functor { 219411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult operator()( 219511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* e1, const char* e2, const char* e3, const char* e4, 219611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* e5, int n1, int n2, int n3, int n4, int n5) { 219711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int sum = n1 + n2 + n3 + n4 + n5; 219811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (IsEven(sum)) { 219911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionSuccess(); 220011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 220111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 220211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 220311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 220411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << " (" 220511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 220611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << ") evaluates to " << sum << ", which is not even."; 220711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return AssertionFailure(msg); 220811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 220911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 221011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 221111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 221211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests unary predicate assertions. 221311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 221411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests unary predicate assertions that don't use a custom formatter. 221511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Pred1Test, WithoutFormat) { 221611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Success cases. 221711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 221811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(IsEven, 4); 221911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 222011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Failure cases. 222111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 222211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 222311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 222411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 222511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "evaluates to false"); 222611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 222711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 222811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests unary predicate assertions that use a custom formatter. 222911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Pred1Test, WithFormat) { 223011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Success cases. 223111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT1(AssertIsEven, 2); 223211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 223311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is UNEXPECTED!"; 223411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 223511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Failure cases. 223611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n = 5; 223711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 223811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "n evaluates to 5, which is not even."); 223911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 224011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 224111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 224211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 224311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 224411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that unary predicate assertions evaluates their arguments 224511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// exactly once. 224611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(Pred1Test, SingleEvaluationOnFailure) { 224711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success case. 224811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int n = 0; 224911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(IsEven, n++); 225011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 225111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 225211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure case. 225311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 225411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 225511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is expected."; 225611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 225711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 225811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 225911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 226011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 226111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests predicate assertions whose arity is >= 2. 226211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 226311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests predicate assertions that don't use a custom formatter. 226411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredTest, WithoutFormat) { 226511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Success cases. 226611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 226711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 226811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 226911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Failure cases. 227011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n1 = 1; 227111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n2 = 2; 227211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 227311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 227411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 227511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 227611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 227711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "evaluates to false"); 227811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 227911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 228011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests predicate assertions that use a custom formatter. 228111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredTest, WithFormat) { 228211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Success cases. 228311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 228411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "This failure is UNEXPECTED!"; 228511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 228611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 228711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Failure cases. 228811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n1 = 1; 228911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n2 = 2; 229011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n3 = 4; 229111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int n4 = 6; 229211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 229311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 229411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "evaluates to 13, which is not even."); 229511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 229611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 229711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is expected."; 229811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 229911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 230011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 230111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that predicate assertions evaluates their arguments 230211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// exactly once. 230311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredTest, SingleEvaluationOnFailure) { 230411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success case. 230511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n1 = 0; 230611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n2 = 0; 230711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED2(SumIsEven2, n1++, n2++); 230811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 230911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 231011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 231111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Another success case. 231211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert n1 = n2 = 0; 231311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n3 = 0; 231411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n4 = 0; 231511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n5 = 0; 231611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 231711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert n1++, n2++, n3++, n4++, n5++) 231811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is UNEXPECTED!"; 231911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 232011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 232111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 232211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 232311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 232411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 232511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure case. 232611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert n1 = n2 = n3 = 0; 232711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 232811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 232911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "This failure is expected."; 233011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 233111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 233211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 233311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 233411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 233511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Another failure case. 233611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert n1 = n2 = n3 = n4 = 0; 233711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 233811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 233911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "evaluates to 1, which is not even."); 234011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 234111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 234211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 234311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 234411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 234511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 234611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 234711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Some helper functions for testing using overloaded/template 234811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// functions with ASSERT_PREDn and EXPECT_PREDn. 234911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 235011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool IsPositive(double x) { 235111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x > 0; 235211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 235311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 235411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 235511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool IsNegative(T x) { 235611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x < 0; 235711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 235811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 235911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 236011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool GreaterThan(T1 x1, T2 x2) { 236111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x1 > x2; 236211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 236311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 236411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that overloaded functions can be used in *_PRED* as long as 236511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// their types are explicitly specified. 236611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 236711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++Builder requires C-style casts rather than static_cast. 236811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT 236911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT 237011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 237111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 237211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that template functions can be used in *_PRED* as long as 237311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// their types are explicitly specified. 237411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 237511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(IsNegative<int>, -5); 237611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Makes sure that we can handle templates with more than one 237711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // parameter. 237811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 237911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 238011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 238111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 238211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Some helper functions for testing using overloaded/template 238311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 238411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 238511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult IsPositiveFormat(const char* /* expr */, int n) { 238611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return n > 0 ? AssertionSuccess() : 238711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionFailure(Message() << "Failure"); 238811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 238911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 239011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult IsPositiveFormat(const char* /* expr */, double x) { 239111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x > 0 ? AssertionSuccess() : 239211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionFailure(Message() << "Failure"); 239311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 239411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 239511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 239611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult IsNegativeFormat(const char* /* expr */, T x) { 239711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x < 0 ? AssertionSuccess() : 239811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionFailure(Message() << "Failure"); 239911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 240011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 240111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 240211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertAssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */, 240311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const T1& x1, const T2& x2) { 240411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x1 == x2 ? AssertionSuccess() : 240511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionFailure(Message() << "Failure"); 240611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 240711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 240811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that overloaded functions can be used in *_PRED_FORMAT* 240911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// without explicitly specifying their types. 241011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 241111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 241211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 241311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 241411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 241511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that template functions can be used in *_PRED_FORMAT* without 241611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// explicitly specifying their types. 241711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 241811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 241911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 242011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 242111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 242211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 242311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests string assertions. 242411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 242511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STREQ with non-NULL arguments. 242611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STREQ) { 242711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char * const p1 = "good"; 242811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(p1, p1); 242911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 243011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Let p2 have the same content as p1, but be at a different address. 243111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char p2[] = "good"; 243211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(p1, p2); 243311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 243411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 243511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: \"bad\""); 243611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 243711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 243811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STREQ with NULL arguments. 243911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STREQ_Null) { 244011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 244111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 244211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "non-null"); 244311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 244411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 244511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STREQ with NULL arguments. 244611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 244711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 244811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "non-null"); 244911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 245011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 245111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STRNE. 245211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STRNE) { 245311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("hi", "Hi"); 245411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("Hi", NULL); 245511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE(NULL, "Hi"); 245611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("", NULL); 245711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE(NULL, ""); 245811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("", "Hi"); 245911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("Hi", ""); 246011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 246111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\"Hi\" vs \"Hi\""); 246211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 246311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 246411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STRCASEEQ. 246511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 246611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASEEQ("hi", "Hi"); 246711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 246811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 246911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASEEQ("", ""); 247011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 247111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(ignoring case)"); 247211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 247311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 247411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_STRCASENE. 247511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, ASSERT_STRCASENE) { 247611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("hi1", "Hi2"); 247711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("Hi", NULL); 247811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE(NULL, "Hi"); 247911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("", NULL); 248011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE(NULL, ""); 248111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("", "Hi"); 248211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("Hi", ""); 248311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 248411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(ignoring case)"); 248511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 248611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 248711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests *_STREQ on wide strings. 248811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, STREQ_Wide) { 248911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // NULL strings. 249011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 249111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 249211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Empty strings. 249311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(L"", L""); 249411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 249511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Non-null vs NULL. 249611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 249711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "non-null"); 249811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 249911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Equal strings. 250011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(L"Hi", L"Hi"); 250111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 250211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Unequal strings. 250311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 250411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Abc"); 250511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 250611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Strings containing wide characters. 250711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 250811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "abc"); 250911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 251011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The streaming variation. 251111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 251211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure"; 251311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Expected failure"); 251411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 251511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 251611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests *_STRNE on wide strings. 251711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StringAssertionTest, STRNE_Wide) { 251811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // NULL strings. 251911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 252011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 252111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 252211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 252311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Empty strings. 252411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 252511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "L\"\""); 252611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 252711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Non-null vs NULL. 252811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE(L"non-null", NULL); 252911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 253011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Equal strings. 253111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 253211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "L\"Hi\""); 253311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 253411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Unequal strings. 253511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE(L"abc", L"Abc"); 253611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 253711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Strings containing wide characters. 253811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 253911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "abc"); 254011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 254111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The streaming variation. 254211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen"; 254311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 254411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 254511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for ::testing::IsSubstring(). 254611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 254711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring() returns the correct result when the input 254811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const char*. 254911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 255011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 255111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 255211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 255311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 255411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 255511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 255611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 255711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 255811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring() returns the correct result when the input 255911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const wchar_t*. 256011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 256111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", kNull, L"a")); 256211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", L"b", kNull)); 256311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 256411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 256511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 256611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 256711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 256811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 256911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring() generates the correct message when the input 257011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const char*. 257111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 257211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Value of: needle_expr\n" 257311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: \"needle\"\n" 257411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: a substring of haystack_expr\n" 257511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: \"haystack\"", 257611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IsSubstring("needle_expr", "haystack_expr", 257711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "needle", "haystack").failure_message()); 257811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 257911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 258011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring returns the correct result when the input 258111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::string. 258211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 258311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 258411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 258511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 258611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 258711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STD_WSTRING 258811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring returns the correct result when the input 258911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::wstring. 259011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 259111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 259211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 259311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 259411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 259511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsSubstring() generates the correct message when the input 259611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::wstring. 259711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 259811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Value of: needle_expr\n" 259911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: L\"needle\"\n" 260011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: a substring of haystack_expr\n" 260111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: L\"haystack\"", 260211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IsSubstring( 260311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "needle_expr", "haystack_expr", 260411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::wstring(L"needle"), L"haystack").failure_message()); 260511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 260611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 260711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STD_WSTRING 260811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 260911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for ::testing::IsNotSubstring(). 261011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 261111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring() returns the correct result when the input 261211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const char*. 261311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 261411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 261511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 261611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 261711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 261811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring() returns the correct result when the input 261911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const wchar_t*. 262011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 262111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 262211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 262311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 262411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 262511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring() generates the correct message when the input 262611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is const wchar_t*. 262711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 262811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Value of: needle_expr\n" 262911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: L\"needle\"\n" 263011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: not a substring of haystack_expr\n" 263111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: L\"two needles\"", 263211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IsNotSubstring( 263311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "needle_expr", "haystack_expr", 263411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"needle", L"two needles").failure_message()); 263511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 263611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 263711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring returns the correct result when the input 263811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::string. 263911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 264011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 264111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 264211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 264311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 264411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring() generates the correct message when the input 264511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::string. 264611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 264711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Value of: needle_expr\n" 264811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: \"needle\"\n" 264911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: not a substring of haystack_expr\n" 265011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: \"two needles\"", 265111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IsNotSubstring( 265211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "needle_expr", "haystack_expr", 265311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::string("needle"), "two needles").failure_message()); 265411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 265511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 265611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STD_WSTRING 265711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 265811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsNotSubstring returns the correct result when the input 265911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// argument type is ::std::wstring. 266011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 266111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE( 266211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 266311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 266411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 266511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 266611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STD_WSTRING 266711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 266811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests floating-point assertions. 266911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 267011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename RawType> 267111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass FloatingPointTest : public Test { 267211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 267311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Pre-calculated numbers to be used by the tests. 267411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct TestValues { 267511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType close_to_positive_zero; 267611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType close_to_negative_zero; 267711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType further_from_negative_zero; 267811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 267911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType close_to_one; 268011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType further_from_one; 268111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 268211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType infinity; 268311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType close_to_infinity; 268411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType further_from_infinity; 268511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 268611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType nan1; 268711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert RawType nan2; 268811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 268911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 269011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename testing::internal::FloatingPoint<RawType> Floating; 269111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename Floating::Bits Bits; 269211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 269311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 269411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const size_t max_ulps = Floating::kMaxUlps; 269511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 269611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The bits that represent 0.0. 269711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Bits zero_bits = Floating(0).bits(); 269811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 269911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Makes some numbers close to 0.0. 270011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.close_to_positive_zero = Floating::ReinterpretBits( 270111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert zero_bits + max_ulps/2); 270211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.close_to_negative_zero = -Floating::ReinterpretBits( 270311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert zero_bits + max_ulps - max_ulps/2); 270411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.further_from_negative_zero = -Floating::ReinterpretBits( 270511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert zero_bits + max_ulps + 1 - max_ulps/2); 270611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 270711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The bits that represent 1.0. 270811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Bits one_bits = Floating(1).bits(); 270911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 271011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Makes some numbers close to 1.0. 271111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps); 271211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.further_from_one = Floating::ReinterpretBits( 271311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert one_bits + max_ulps + 1); 271411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 271511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // +infinity. 271611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.infinity = Floating::Infinity(); 271711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 271811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The bits that represent +infinity. 271911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Bits infinity_bits = Floating(values_.infinity).bits(); 272011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 272111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Makes some numbers close to infinity. 272211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.close_to_infinity = Floating::ReinterpretBits( 272311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert infinity_bits - max_ulps); 272411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.further_from_infinity = Floating::ReinterpretBits( 272511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert infinity_bits - max_ulps - 1); 272611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 272711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Makes some NAN's. Sets the most significant bit of the fraction so that 272811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // our NaN's are quiet; trying to process a signaling NaN would raise an 272911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // exception if our environment enables floating point exceptions. 273011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask 273111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1); 273211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask 273311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200); 273411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 273511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 273611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void TestSize() { 273711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 273811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 273911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 274011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static TestValues values_; 274111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 274211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 274311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename RawType> 274411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypename FloatingPointTest<RawType>::TestValues 274511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FloatingPointTest<RawType>::values_; 274611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 274711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 274811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef FloatingPointTest<float> FloatTest; 274911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 275011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the size of Float::Bits matches the size of float. 275111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, Size) { 275211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestSize(); 275311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 275411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 275511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing with +0 and -0. 275611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, Zeros) { 275711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(0.0, -0.0); 275811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 275911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.0"); 276011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 276111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.5"); 276211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 276311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 276411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers close to 0. 276511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 276611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This ensures that *_FLOAT_EQ handles the sign correctly and no 276711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// overflow occurs when comparing numbers whose absolute value is very 276811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// small. 276911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, AlmostZeros) { 277011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In C++Builder, names within local classes (such as used by 277111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 277211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // scoping class. Use a static local alias as a workaround. 277311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use the assignment syntax since some compilers, like Sun Studio, 277411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // don't allow initializing references using construction syntax 277511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (parentheses). 277611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const FloatTest::TestValues& v = this->values_; 277711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 277811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero); 277911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero); 278011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 278111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 278211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 278311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FLOAT_EQ(v.close_to_positive_zero, 278411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.further_from_negative_zero); 278511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "v.further_from_negative_zero"); 278611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 278711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 278811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers close to each other. 278911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, SmallDiff) { 279011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(1.0, values_.close_to_one); 279111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one), 279211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "values_.further_from_one"); 279311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 279411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 279511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers far apart. 279611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, LargeDiff) { 279711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 279811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "3.0"); 279911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 280011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 280111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing with infinity. 280211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 280311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This ensures that no overflow occurs when comparing numbers whose 280411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// absolute value is very large. 280511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, Infinity) { 280611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity); 280711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity); 280811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN 280911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 281011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity), 281111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "-values_.infinity"); 281211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 281311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This is interesting as the representations of infinity and nan1 281411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // are only 1 DLP apart. 281511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1), 281611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "values_.nan1"); 281711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN 281811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 281911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 282011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that comparing with NAN always returns false. 282111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, NaN) { 282211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN 282311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Nokia's STLport crashes if we try to output infinity or NaN. 282411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 282511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In C++Builder, names within local classes (such as used by 282611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 282711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // scoping class. Use a static local alias as a workaround. 282811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use the assignment syntax since some compilers, like Sun Studio, 282911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // don't allow initializing references using construction syntax 283011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (parentheses). 283111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const FloatTest::TestValues& v = this->values_; 283211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 283311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), 283411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.nan1"); 283511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), 283611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.nan2"); 283711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), 283811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.nan1"); 283911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 284011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), 284111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.infinity"); 284211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN 284311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 284411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 284511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that *_FLOAT_EQ are reflexive. 284611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, Reflexive) { 284711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(0.0, 0.0); 284811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(1.0, 1.0); 284911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FLOAT_EQ(values_.infinity, values_.infinity); 285011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 285111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 285211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that *_FLOAT_EQ are commutative. 285311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, Commutative) { 285411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one). 285511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(values_.close_to_one, 1.0); 285611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 285711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one). 285811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0), 285911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.0"); 286011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 286111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 286211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_NEAR. 286311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, EXPECT_NEAR) { 286411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 286511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NEAR(2.0f, 3.0f, 1.0f); 286611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 286711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "The difference between 1.0f and 1.5f is 0.5, " 286811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "which exceeds 0.25f"); 286911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To work around a bug in gcc 2.95.0, there is intentionally no 287011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // space after the first comma in the previous line. 287111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 287211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 287311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_NEAR. 287411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, ASSERT_NEAR) { 287511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 287611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NEAR(2.0f, 3.0f, 1.0f); 287711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 287811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "The difference between 1.0f and 1.5f is 0.5, " 287911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "which exceeds 0.25f"); 288011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To work around a bug in gcc 2.95.0, there is intentionally no 288111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // space after the first comma in the previous line. 288211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 288311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 288411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the cases where FloatLE() should succeed. 288511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, FloatLESucceeds) { 288611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 288711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 288811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 288911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or when val1 is greater than, but almost equals to, val2. 289011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f); 289111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 289211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 289311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the cases where FloatLE() should fail. 289411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FloatTest, FloatLEFails) { 289511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // When val1 is greater than val2 by a large margin, 289611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 289711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(2.0f) <= (1.0f)"); 289811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 289911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or by a small yet non-negligible margin, 290011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 290111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f); 290211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.further_from_one) <= (1.0f)"); 290311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 290411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 290511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 290611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++Builder gives bad results for ordered comparisons involving NaNs 290711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // due to compiler bugs. 290811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 290911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity); 291011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.nan1) <= (values_.infinity)"); 291111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 291211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1); 291311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(-values_.infinity) <= (values_.nan1)"); 291411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 291511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1); 291611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.nan1) <= (values_.nan1)"); 291711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 291811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 291911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 292011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 292111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef FloatingPointTest<double> DoubleTest; 292211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 292311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the size of Double::Bits matches the size of double. 292411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, Size) { 292511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestSize(); 292611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 292711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 292811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing with +0 and -0. 292911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, Zeros) { 293011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(0.0, -0.0); 293111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 293211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.0"); 293311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 293411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.0"); 293511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 293611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 293711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers close to 0. 293811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 293911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This ensures that *_DOUBLE_EQ handles the sign correctly and no 294011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// overflow occurs when comparing numbers whose absolute value is very 294111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// small. 294211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, AlmostZeros) { 294311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In C++Builder, names within local classes (such as used by 294411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 294511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // scoping class. Use a static local alias as a workaround. 294611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use the assignment syntax since some compilers, like Sun Studio, 294711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // don't allow initializing references using construction syntax 294811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (parentheses). 294911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const DoubleTest::TestValues& v = this->values_; 295011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 295111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero); 295211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero); 295311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 295411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 295511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 295611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DOUBLE_EQ(v.close_to_positive_zero, 295711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert v.further_from_negative_zero); 295811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "v.further_from_negative_zero"); 295911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 296011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 296111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers close to each other. 296211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, SmallDiff) { 296311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(1.0, values_.close_to_one); 296411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one), 296511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "values_.further_from_one"); 296611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 296711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 296811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing numbers far apart. 296911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, LargeDiff) { 297011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 297111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "3.0"); 297211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 297311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 297411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests comparing with infinity. 297511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 297611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This ensures that no overflow occurs when comparing numbers whose 297711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// absolute value is very large. 297811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, Infinity) { 297911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity); 298011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity); 298111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN 298211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 298311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity), 298411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "-values_.infinity"); 298511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 298611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This is interesting as the representations of infinity_ and nan1_ 298711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // are only 1 DLP apart. 298811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1), 298911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "values_.nan1"); 299011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN 299111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 299211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 299311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that comparing with NAN always returns false. 299411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, NaN) { 299511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN 299611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // In C++Builder, names within local classes (such as used by 299711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 299811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // scoping class. Use a static local alias as a workaround. 299911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We use the assignment syntax since some compilers, like Sun Studio, 300011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // don't allow initializing references using construction syntax 300111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (parentheses). 300211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const DoubleTest::TestValues& v = this->values_; 300311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 300411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 300511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), 300611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.nan1"); 300711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2"); 300811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1"); 300911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), 301011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "v.infinity"); 301111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN 301211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 301311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 301411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that *_DOUBLE_EQ are reflexive. 301511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, Reflexive) { 301611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(0.0, 0.0); 301711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(1.0, 1.0); 301811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN 301911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 302011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity); 302111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN 302211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 302311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 302411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that *_DOUBLE_EQ are commutative. 302511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, Commutative) { 302611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one). 302711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0); 302811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 302911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one). 303011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0), 303111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1.0"); 303211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 303311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 303411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_NEAR. 303511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, EXPECT_NEAR) { 303611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NEAR(-1.0, -1.1, 0.2); 303711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NEAR(2.0, 3.0, 1.0); 303811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25), // NOLINT 303911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "The difference between 1.0 and 1.5 is 0.5, " 304011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "which exceeds 0.25"); 304111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To work around a bug in gcc 2.95.0, there is intentionally no 304211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // space after the first comma in the previous statement. 304311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 304411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 304511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_NEAR. 304611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, ASSERT_NEAR) { 304711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NEAR(-1.0, -1.1, 0.2); 304811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NEAR(2.0, 3.0, 1.0); 304911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25), // NOLINT 305011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "The difference between 1.0 and 1.5 is 0.5, " 305111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "which exceeds 0.25"); 305211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To work around a bug in gcc 2.95.0, there is intentionally no 305311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // space after the first comma in the previous statement. 305411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 305511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 305611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the cases where DoubleLE() should succeed. 305711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, DoubleLESucceeds) { 305811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 305911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 306011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 306111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or when val1 is greater than, but almost equals to, val2. 306211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0); 306311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 306411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 306511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the cases where DoubleLE() should fail. 306611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DoubleTest, DoubleLEFails) { 306711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // When val1 is greater than val2 by a large margin, 306811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 306911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(2.0) <= (1.0)"); 307011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 307111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // or by a small yet non-negligible margin, 307211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 307311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0); 307411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.further_from_one) <= (1.0)"); 307511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 307611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 307711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Nokia's STLport crashes if we try to output infinity or NaN. 307811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++Builder gives bad results for ordered comparisons involving NaNs 307911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // due to compiler bugs. 308011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 308111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity); 308211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.nan1) <= (values_.infinity)"); 308311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 308411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1); 308511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, " (-values_.infinity) <= (values_.nan1)"); 308611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 308711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1); 308811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(values_.nan1) <= (values_.nan1)"); 308911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 309011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 309111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 309211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 309311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that a test or test case whose name starts with DISABLED_ is 309411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// not run. 309511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 309611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test whose name starts with DISABLED_. 309711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Should not run. 309811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(DisabledTest, DISABLED_TestShouldNotRun) { 309911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Disabled test should not be run."; 310011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 310111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 310211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test whose name does not start with DISABLED_. 310311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Should run. 310411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(DisabledTest, NotDISABLED_TestShouldRun) { 310511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, 1); 310611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 310711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 310811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test case whose name starts with DISABLED_. 310911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Should not run. 311011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(DISABLED_TestCase, TestShouldNotRun) { 311111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 311211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 311311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 311411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test case and test whose names start with DISABLED_. 311511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Should not run. 311611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 311711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 311811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 311911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 312011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Check that when all tests in a test case are disabled, SetupTestCase() and 312111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TearDownTestCase() are not called. 312211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass DisabledTestsTest : public Test { 312311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 312411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 312511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: All tests disabled in test case. " 312611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "SetupTestCase() should not be called."; 312711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 312811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 312911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TearDownTestCase() { 313011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: All tests disabled in test case. " 313111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "TearDownTestCase() should not be called."; 313211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 313311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 313411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 313511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 313611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Disabled test should not be run."; 313711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 313811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 313911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 314011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Disabled test should not be run."; 314111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 314211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 314311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that disabled typed tests aren't run. 314411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 314511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_TYPED_TEST 314611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 314711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 314811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TypedTest : public Test { 314911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 315011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 315111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef testing::Types<int, double> NumericTypes; 315211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_CASE(TypedTest, NumericTypes); 315311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 315411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 315511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Disabled typed test should not run."; 315611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 315711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 315811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 315911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass DISABLED_TypedTest : public Test { 316011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 316111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 316211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 316311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 316411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 316511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: Disabled typed test should not run."; 316611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 316711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 316811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_TYPED_TEST 316911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 317011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that disabled type-parameterized tests aren't run. 317111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 317211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_TYPED_TEST_P 317311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 317411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 317511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TypedTestP : public Test { 317611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 317711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 317811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_CASE_P(TypedTestP); 317911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 318011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 318111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: " 318211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Disabled type-parameterized test should not run."; 318311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 318411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 318511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 318611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 318711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 318811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 318911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 319011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass DISABLED_TypedTestP : public Test { 319111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 319211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 319311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_CASE_P(DISABLED_TypedTestP); 319411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 319511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 319611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Unexpected failure: " 319711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Disabled type-parameterized test should not run."; 319811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 319911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 320011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 320111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 320211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 320311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 320411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_TYPED_TEST_P 320511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 320611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that assertion macros evaluate their arguments exactly once. 320711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 320811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass SingleEvaluationTest : public Test { 320911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: // Must be public and not protected due to a bug in g++ 3.4.2. 321011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This helper function is needed by the FailedASSERT_STREQ test 321111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // below. It's public to work around C++Builder's bug with scoping local 321211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // classes. 321311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void CompareAndIncrementCharPtrs() { 321411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(p1_++, p2_++); 321511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 321611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 321711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This helper function is needed by the FailedASSERT_NE test below. It's 321811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // public to work around C++Builder's bug with scoping local classes. 321911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void CompareAndIncrementInts() { 322011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(a_++, b_++); 322111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 322211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 322311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 322411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SingleEvaluationTest() { 322511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert p1_ = s1_; 322611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert p2_ = s2_; 322711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a_ = 0; 322811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert b_ = 0; 322911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 323011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 323111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* const s1_; 323211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* const s2_; 323311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* p1_; 323411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* p2_; 323511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 323611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int a_; 323711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int b_; 323811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 323911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 324011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* const SingleEvaluationTest::s1_ = "01234"; 324111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* const SingleEvaluationTest::s2_ = "abcde"; 324211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* SingleEvaluationTest::p1_; 324311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* SingleEvaluationTest::p2_; 324411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint SingleEvaluationTest::a_; 324511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint SingleEvaluationTest::b_; 324611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 324711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that when ASSERT_STREQ fails, it evaluates its arguments 324811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// exactly once. 324911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 325011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(), 325111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p2_++"); 325211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s1_ + 1, p1_); 325311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s2_ + 1, p2_); 325411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 325511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 325611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that string assertion arguments are evaluated exactly once. 325711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SingleEvaluationTest, ASSERT_STR) { 325811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_STRNE 325911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE(p1_++, p2_++); 326011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s1_ + 1, p1_); 326111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s2_ + 1, p2_); 326211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 326311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_STRCASEEQ 326411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 326511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "ignoring case"); 326611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s1_ + 2, p1_); 326711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(s2_ + 2, p2_); 326811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 326911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 327011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 327111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// once. 327211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 327311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(), 327411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(a_++) != (b_++)"); 327511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, a_); 327611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, b_); 327711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 327811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 327911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that assertion arguments are evaluated exactly once. 328011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SingleEvaluationTest, OtherCases) { 328111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_TRUE 328211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(0 == a_++); // NOLINT 328311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, a_); 328411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 328511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_TRUE 328611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 328711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, a_); 328811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 328911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_GT 329011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GT(a_++, b_++); 329111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3, a_); 329211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, b_); 329311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 329411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_LT 329511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 329611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(4, a_); 329711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, b_); 329811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 329911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful ASSERT_TRUE 330011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(0 < a_++); // NOLINT 330111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(5, a_); 330211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 330311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful ASSERT_GT 330411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GT(a_++, b_++); 330511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(6, a_); 330611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3, b_); 330711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 330811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 330911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 331011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 331111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ThrowAnInteger() { 331211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert throw 1; 331311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 331411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 331511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that assertion arguments are evaluated exactly once. 331611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SingleEvaluationTest, ExceptionTests) { 331711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_THROW 331811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW({ // NOLINT 331911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a_++; 332011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThrowAnInteger(); 332111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, int); 332211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, a_); 332311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 332411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_THROW, throws different 332511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 332611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a_++; 332711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThrowAnInteger(); 332811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, bool), "throws a different type"); 332911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, a_); 333011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 333111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_THROW, throws nothing 333211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 333311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3, a_); 333411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 333511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_NO_THROW 333611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(a_++); 333711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(4, a_); 333811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 333911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_NO_THROW 334011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 334111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a_++; 334211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThrowAnInteger(); 334311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }), "it throws"); 334411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(5, a_); 334511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 334611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // successful EXPECT_ANY_THROW 334711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW({ // NOLINT 334811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert a_++; 334911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ThrowAnInteger(); 335011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }); 335111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(6, a_); 335211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 335311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // failed EXPECT_ANY_THROW 335411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 335511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(7, a_); 335611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 335711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 335811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 335911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 336011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE. 336111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass NoFatalFailureTest : public Test { 336211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 336311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Succeeds() {} 336411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void FailsNonFatal() { 336511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "some non-fatal failure"; 336611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 336711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void Fails() { 336811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "some fatal failure"; 336911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 337011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 337111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void DoAssertNoFatalFailureOnFails() { 337211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_FATAL_FAILURE(Fails()); 337311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "shold not reach here."; 337411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 337511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 337611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void DoExpectNoFatalFailureOnFails() { 337711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(Fails()); 337811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "other failure"; 337911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 338011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 338111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 338211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(NoFatalFailureTest, NoFailure) { 338311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(Succeeds()); 338411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_FATAL_FAILURE(Succeeds()); 338511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 338611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 338711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(NoFatalFailureTest, NonFatalIsNoFailure) { 338811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 338911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(FailsNonFatal()), 339011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "some non-fatal failure"); 339111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 339211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_FATAL_FAILURE(FailsNonFatal()), 339311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "some non-fatal failure"); 339411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 339511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 339611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) { 339711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray gtest_failures; 339811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 339911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 340011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DoAssertNoFatalFailureOnFails(); 340111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 340211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, gtest_failures.size()); 340311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kFatalFailure, 340411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).type()); 340511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kFatalFailure, 340611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).type()); 340711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 340811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).message()); 340911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 341011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).message()); 341111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 341211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 341311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) { 341411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray gtest_failures; 341511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 341611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 341711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert DoExpectNoFatalFailureOnFails(); 341811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 341911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3, gtest_failures.size()); 342011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kFatalFailure, 342111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).type()); 342211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kNonFatalFailure, 342311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).type()); 342411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kNonFatalFailure, 342511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(2).type()); 342611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 342711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).message()); 342811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 342911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).message()); 343011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure", 343111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(2).message()); 343211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 343311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 343411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(NoFatalFailureTest, MessageIsStreamable) { 343511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestPartResultArray gtest_failures; 343611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 343711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 343811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message"; 343911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 344011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2, gtest_failures.size()); 344111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kNonFatalFailure, 344211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).type()); 344311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(TestPartResult::kNonFatalFailure, 344411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).type()); 344511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo", 344611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(0).message()); 344711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message", 344811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gtest_failures.GetTestPartResult(1).message()); 344911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 345011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 345111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests non-string assertions. 345211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 345311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EqFailure(), used for implementing *EQ* assertions. 345411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, EqFailure) { 345511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string foo_val("5"), bar_val("6"); 345611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string msg1( 345711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EqFailure("foo", "bar", foo_val, bar_val, false) 345811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert .failure_message()); 345911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 346011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: bar\n" 346111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 6\n" 346211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: foo\n" 346311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: 5", 346411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg1.c_str()); 346511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 346611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string msg2( 346711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EqFailure("foo", "6", foo_val, bar_val, false) 346811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert .failure_message()); 346911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 347011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 6\n" 347111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: foo\n" 347211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: 5", 347311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg2.c_str()); 347411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 347511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string msg3( 347611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EqFailure("5", "bar", foo_val, bar_val, false) 347711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert .failure_message()); 347811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 347911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: bar\n" 348011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 6\n" 348111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 5", 348211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg3.c_str()); 348311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 348411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string msg4( 348511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 348611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 348711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 6\n" 348811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 5", 348911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg4.c_str()); 349011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 349111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string msg5( 349211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EqFailure("foo", "bar", 349311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string("\"x\""), std::string("\"y\""), 349411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true).failure_message()); 349511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ( 349611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: bar\n" 349711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: \"y\"\n" 349811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: foo (ignoring case)\n" 349911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: \"x\"", 350011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg5.c_str()); 350111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 350211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 350311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests AppendUserMessage(), used for implementing the *EQ* macros. 350411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AppendUserMessage) { 350511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string foo("foo"); 350611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 350711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 350811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("foo", 350911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AppendUserMessage(foo, msg).c_str()); 351011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 351111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << "bar"; 351211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("foo\nbar", 351311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AppendUserMessage(foo, msg).c_str()); 351411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 351511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 351611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 351711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Silences warnings: "Condition is always true", "Unreachable code" 351811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option push -w-ccc -w-rch 351911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 352011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 352111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_TRUE. 352211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_TRUE) { 352311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(2 > 1); // NOLINT 352411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 352511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2 < 1"); 352611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 352711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 352811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult. 352911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AssertTrueWithAssertionResult) { 353011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ResultIsEven(2)); 353111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ 353211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder. 353311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)), 353411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEven(3)\n" 353511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: false (3 is odd)\n" 353611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: true"); 353711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 353811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(ResultIsEvenNoExplanation(2)); 353911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)), 354011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEvenNoExplanation(3)\n" 354111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: false (3 is odd)\n" 354211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: true"); 354311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 354411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 354511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_FALSE. 354611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_FALSE) { 354711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(2 < 1); // NOLINT 354811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 354911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 2 > 1\n" 355011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true\n" 355111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 355211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 355311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 355411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult. 355511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AssertFalseWithAssertionResult) { 355611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(ResultIsEven(3)); 355711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ 355811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder. 355911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)), 356011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEven(2)\n" 356111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true (2 is even)\n" 356211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 356311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 356411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(ResultIsEvenNoExplanation(3)); 356511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)), 356611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEvenNoExplanation(2)\n" 356711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true\n" 356811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 356911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 357011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 357111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 357211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Restores warnings after previous "#pragma option push" supressed them 357311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option pop 357411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 357511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 357611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ASSERT_EQ on double values. The purpose is to make 357711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// sure that the specialization we did for integer and anonymous enums 357811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// isn't used for double arguments. 357911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, ASSERT_EQ_Double) { 358011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 358111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(5.6, 5.6); 358211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 358311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 358411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 358511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "5.1"); 358611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 358711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 358811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_EQ. 358911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_EQ) { 359011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(5, 2 + 3); 359111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 359211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 2*3\n" 359311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 6\n" 359411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 5"); 359511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 359611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 359711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_EQ(NULL, pointer). 359811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_COMPARE_NULL 359911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_EQ_NULL) { 360011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 360111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* p = NULL; 360211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some older GCC versions may issue a spurious waring in this or the next 360311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // assertion statement. This warning should not be suppressed with 360411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // static_cast since the test verifies the ability to use bare NULL as the 360511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // expected parameter to the macro. 360611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(NULL, p); 360711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 360811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 360911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int n = 0; 361011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 361111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: &n\n"); 361211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 361311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_CAN_COMPARE_NULL 361411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 361511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 361611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// treated as a null pointer by the compiler, we need to make sure 361711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 361811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 361911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, ASSERT_EQ_0) { 362011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 362111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 362211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 362311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, n); 362411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 362511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 362611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 362711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 0"); 362811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 362911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 363011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_NE. 363111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_NE) { 363211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(6, 7); 363311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 363411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ('a') != ('a'), " 363511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 363611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 363711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 363811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_LE. 363911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_LE) { 364011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LE(2, 3); 364111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LE(2, 2); 364211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 364311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) <= (0), actual: 2 vs 0"); 364411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 364511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 364611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_LT. 364711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_LT) { 364811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(2, 3); 364911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 365011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) < (2), actual: 2 vs 2"); 365111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 365211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 365311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_GE. 365411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_GE) { 365511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GE(2, 1); 365611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GE(2, 2); 365711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 365811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) >= (3), actual: 2 vs 3"); 365911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 366011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 366111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_GT. 366211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_GT) { 366311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GT(2, 1); 366411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 366511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) > (2), actual: 2 vs 2"); 366611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 366711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 366811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 366911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 367011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ThrowNothing() {} 367111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 367211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_THROW. 367311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_THROW) { 367411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_THROW(ThrowAnInteger(), int); 367511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 367611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __BORLANDC__ 367711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 367811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder 2007 and 2009. 367911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE( 368011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_THROW(ThrowAnInteger(), bool), 368111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowAnInteger() throws an exception of type bool.\n" 368211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: it throws a different type."); 368311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 368411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 368511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE( 368611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_THROW(ThrowNothing(), bool), 368711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowNothing() throws an exception of type bool.\n" 368811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: it throws nothing."); 368911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 369011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 369111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_NO_THROW. 369211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_NO_THROW) { 369311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_THROW(ThrowNothing()); 369411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 369511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowAnInteger() doesn't throw an exception." 369611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\n Actual: it throws."); 369711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 369811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 369911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ASSERT_ANY_THROW. 370011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ASSERT_ANY_THROW) { 370111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_ANY_THROW(ThrowAnInteger()); 370211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE( 370311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_ANY_THROW(ThrowNothing()), 370411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowNothing() throws an exception.\n" 370511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: it doesn't."); 370611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 370711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 370811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 370911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 371011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Makes sure we deal with the precedence of <<. This test should 371111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// compile. 371211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AssertPrecedence) { 371311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1 < 2, true); 371411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool false_value = false; 371511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(true && false_value, false); 371611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 371711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 371811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A subroutine used by the following test. 371911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestEq1(int x) { 372011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, x); 372111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 372211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 372311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests calling a test subroutine that's not part of a fixture. 372411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, NonFixtureSubroutine) { 372511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(TestEq1(2), 372611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: x"); 372711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 372811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 372911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// An uncopyable class. 373011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Uncopyable { 373111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 373211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit Uncopyable(int a_value) : value_(a_value) {} 373311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 373411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int value() const { return value_; } 373511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator==(const Uncopyable& rhs) const { 373611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return value() == rhs.value(); 373711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 373811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 373911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This constructor deliberately has no implementation, as we don't 374011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // want this class to be copyable. 374111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable(const Uncopyable&); // NOLINT 374211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 374311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int value_; 374411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 374511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 374611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 374711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << value.value(); 374811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 374911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 375011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 375111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool IsPositiveUncopyable(const Uncopyable& x) { 375211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return x.value() > 0; 375311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 375411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 375511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A subroutine used by the following test. 375611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestAssertNonPositive() { 375711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable y(-1); 375811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(IsPositiveUncopyable, y); 375911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 376011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A subroutine used by the following test. 376111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestAssertEqualsUncopyable() { 376211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable x(5); 376311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable y(-1); 376411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(x, y); 376511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 376611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 376711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that uncopyable objects can be used in assertions. 376811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AssertWorksWithUncopyableObject) { 376911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable x(5); 377011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_PRED1(IsPositiveUncopyable, x); 377111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(x, x); 377211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 377311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 377411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 377511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 377611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 377711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 377811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that uncopyable objects can be used in expects. 377911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 378011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable x(5); 378111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED1(IsPositiveUncopyable, x); 378211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Uncopyable y(-1); 378311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 378411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 378511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(x, x); 378611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 378711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 378811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 378911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 379011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertenum NamedEnum { 379111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kE1 = 0, 379211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kE2 = 1 379311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 379411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 379511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, NamedEnum) { 379611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kE1, kE1); 379711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(kE1, kE2); 379811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0"); 379911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1"); 380011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 380111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 380211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The version of gcc used in XCode 2.2 has a bug and doesn't allow 380311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// anonymous enums in assertions. Therefore the following test is not 380411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// done on Mac. 380511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sun Studio and HP aCC also reject this code. 380611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC) 380711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 380811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using assertions with anonymous enums. 380911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertenum { 381011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kCaseA = -1, 381111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 381211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX 381311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 381411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We want to test the case where the size of the anonymous enum is 381511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // larger than sizeof(int), to make sure our implementation of the 381611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // assertions doesn't truncate the enums. However, MSVC 381711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // (incorrectly) doesn't allow an enum value to exceed the range of 381811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // an int, so this has to be conditionally compiled. 381911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // 382011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // On Linux, kCaseB and kCaseA have the same value when truncated to 382111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // int size. We want to test whether this will confuse the 382211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // assertions. 382311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kCaseB = testing::internal::kMaxBiggestInt, 382411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 382511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# else 382611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 382711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kCaseB = INT_MAX, 382811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 382911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX 383011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 383111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert kCaseC = 42 383211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 383311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 383411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionTest, AnonymousEnum) { 383511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if GTEST_OS_LINUX 383611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 383711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB)); 383811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 383911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif // GTEST_OS_LINUX 384011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 384111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kCaseA, kCaseA); 384211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(kCaseA, kCaseB); 384311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(kCaseA, kCaseB); 384411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(kCaseA, kCaseB); 384511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GT(kCaseB, kCaseA); 384611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(kCaseA, kCaseA); 384711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB), 384811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(kCaseA) >= (kCaseB)"); 384911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC), 385011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "-1 vs 42"); 385111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 385211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(kCaseA, kCaseA); 385311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(kCaseA, kCaseB); 385411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(kCaseA, kCaseB); 385511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LE(kCaseA, kCaseB); 385611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GT(kCaseB, kCaseA); 385711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GE(kCaseA, kCaseA); 385811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 385911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __BORLANDC__ 386011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 386111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder. 386211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), 386311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: kCaseB"); 386411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 386511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Actual: 42"); 386611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 386711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 386811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 386911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: -1"); 387011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 387111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 387211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC) 387311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 387411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 387511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 387611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic HRESULT UnexpectedHRESULTFailure() { 387711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return E_UNEXPECTED; 387811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 387911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 388011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic HRESULT OkHRESULTSuccess() { 388111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return S_OK; 388211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 388311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 388411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic HRESULT FalseHRESULTSuccess() { 388511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return S_FALSE; 388611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 388711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 388811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// HRESULT assertion tests test both zero and non-zero 388911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// success codes as well as failure message for each. 389011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 389111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Windows CE doesn't support message texts. 389211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 389311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_SUCCEEDED(S_OK); 389411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_SUCCEEDED(S_FALSE); 389511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 389611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 389711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 389811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x8000FFFF"); 389911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 390011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 390111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 390211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_SUCCEEDED(S_OK); 390311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_SUCCEEDED(S_FALSE); 390411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 390511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 390611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 390711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x8000FFFF"); 390811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 390911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 391011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 391111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_FAILED(E_UNEXPECTED); 391211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 391311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 391411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (OkHRESULTSuccess()) fails.\n" 391511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x0"); 391611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 391711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (FalseHRESULTSuccess()) fails.\n" 391811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x1"); 391911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 392011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 392111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 392211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_FAILED(E_UNEXPECTED); 392311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 392411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __BORLANDC__ 392511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 392611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder 2007 and 2009. 392711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 392811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (OkHRESULTSuccess()) fails.\n" 392911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x0"); 393011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 393111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 393211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 393311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (FalseHRESULTSuccess()) fails.\n" 393411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 0x1"); 393511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 393611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 393711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that streaming to the HRESULT macros works. 393811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HRESULTAssertionTest, Streaming) { 393911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 394011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 394111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 394211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 394311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 394411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 394511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 394611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 394711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 394811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __BORLANDC__ 394911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 395011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder 2007 and 2009. 395111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE( 395211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 395311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 395411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 395511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 395611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 395711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 395811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 395911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 396011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE( 396111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 396211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 396311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 396411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 396511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 396611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 396711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 396811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Silences warnings: "Condition is always true", "Unreachable code" 396911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option push -w-ccc -w-rch 397011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 397111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 397211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the assertion macros behave like single statements. 397311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) { 397411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 397511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(false) << "This should never be executed; " 397611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "It's a compilation test only."; 397711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 397811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 397911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(false); 398011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 398111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 398211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 398311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 398411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(1, 3); 398511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 398611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 398711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 398811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 398911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GT(3, 2) << ""; 399011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 399111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 399211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 399311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the compiler will not complain about unreachable code in the 399411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros. 399511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) { 399611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 399711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 399811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(throw 1, int); 399911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), ""); 400011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), ""); 400111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(n++); 400211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), ""); 400311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(throw 1); 400411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), ""); 400511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 400611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 400711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) { 400811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 400911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowNothing(), bool); 401011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 401111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 401211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowAnInteger(), int); 401311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 401411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 401511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 401611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 401711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(ThrowAnInteger()); 401811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 401911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 402011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(ThrowNothing()); 402111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 402211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 402311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 402411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 402511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(ThrowNothing()); 402611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 402711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 402811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(ThrowAnInteger()); 402911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 403011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 403111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 403211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 403311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 403411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) { 403511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 403611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. " 403711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "It's a compilation test only."; 403811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 403911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 404011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 404111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 404211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_FATAL_FAILURE(FAIL()) << ""; 404311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 404411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 404511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 404611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysTrue()) 404711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_FATAL_FAILURE(SUCCEED()); 404811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 404911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 405011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 405111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (AlwaysFalse()) 405211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ; // NOLINT 405311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 405411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_FATAL_FAILURE(SUCCEED()); 405511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 405611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 405711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the assertion macros work well with switch statements. 405811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionSyntaxTest, WorksWithSwitch) { 405911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) { 406011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 1: 406111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 406211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 406311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(true); 406411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 406511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 406611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 406711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 0: 406811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 406911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 407011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Binary assertions are implemented using a different code path 407111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // than the Boolean assertions. Hence we test them separately. 407211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) { 407311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 1: 407411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default: 407511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 407611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 407711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 407811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert switch (0) 407911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert case 0: 408011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(1, 2); 408111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 408211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 408311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 408411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 408511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid ThrowAString() { 408611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert throw "std::string"; 408711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 408811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 408911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Test that the exception assertion macros compile and work with const 409011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// type qualifier. 409111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionSyntaxTest, WorksWithConst) { 409211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_THROW(ThrowAString(), const char*); 409311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 409411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowAString(), const char*); 409511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 409611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 409711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 409811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 409911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace 410011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 410111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 410211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 410311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test tracks SUCCEED*. 410411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessfulAssertionTest, SUCCEED) { 410511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED(); 410611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED() << "OK"; 410711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count()); 410811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 410911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 411011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test doesn't track successful EXPECT_*. 411111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessfulAssertionTest, EXPECT) { 411211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(true); 411311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 411411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 411511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 411611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test doesn't track successful EXPECT_STR*. 411711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessfulAssertionTest, EXPECT_STR) { 411811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", ""); 411911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 412011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 412111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 412211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test doesn't track successful ASSERT_*. 412311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessfulAssertionTest, ASSERT) { 412411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(true); 412511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 412611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 412711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 412811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test doesn't track successful ASSERT_STR*. 412911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SuccessfulAssertionTest, ASSERT_STR) { 413011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("", ""); 413111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 413211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 413311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 413411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 413511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 413611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace { 413711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 413811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the message streaming variation of assertions. 413911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 414011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, EXPECT) { 414111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, 1) << "This should succeed."; 414211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.", 414311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #1"); 414411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(1, 2) << "This should succeed."; 414511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.", 414611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #2."); 414711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(1, 0) << "This should succeed."; 414811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.", 414911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #3."); 415011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 415111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1", "1") << "This should succeed."; 415211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.", 415311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #4."); 415411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRCASEEQ("a", "A") << "This should succeed."; 415511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.", 415611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #5."); 415711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 415811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(1, 1) << "This should succeed."; 415911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.", 416011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure #6."); 416111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed."; 416211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 416311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 416411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, ASSERT) { 416511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, 1) << "This should succeed."; 416611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NE(1, 2) << "This should succeed."; 416711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LE(1, 2) << "This should succeed."; 416811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(1, 2) << "This should succeed."; 416911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GE(1, 0) << "This should succeed."; 417011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.", 417111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure."); 417211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 417311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 417411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, ASSERT_STR) { 417511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("1", "1") << "This should succeed."; 417611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("1", "2") << "This should succeed."; 417711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASEEQ("a", "A") << "This should succeed."; 417811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.", 417911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected failure."); 418011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 418111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 418211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, ASSERT_FLOATING) { 418311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FLOAT_EQ(1, 1) << "This should succeed."; 418411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_DOUBLE_EQ(1, 1) << "This should succeed."; 418511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.", // NOLINT 418611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expect failure."); 418711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // To work around a bug in gcc 2.95.0, there is intentionally no 418811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // space after the first comma in the previous statement. 418911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 419011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 419111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ASSERT_FALSE with a streamed message. 419211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, ASSERT_FALSE) { 419311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(false) << "This shouldn't fail."; 419411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 419511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1 419611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << " evaluates to " << true; 419711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Expected failure"); 419811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 419911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 420011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using FAIL with a streamed message. 420111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, FAIL) { 420211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << 0, 420311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "0"); 420411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 420511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 420611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using SUCCEED with a streamed message. 420711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, SUCCEED) { 420811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED() << "Success == " << 1; 420911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 421011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 421111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ASSERT_TRUE with a streamed message. 421211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, ASSERT_TRUE) { 421311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(true) << "This should succeed."; 421411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(true) << true; 421511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 421611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(false) << static_cast<const char *>(NULL) 421711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << static_cast<char *>(NULL); 421811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "(null)(null)"); 421911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 422011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 422111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 422211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using wide strings in assertion messages. 422311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionWithMessageTest, WideStringMessage) { 422411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 422511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(false) << L"This failure is expected.\x8119"; 422611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected."); 422711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 422811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, 2) << "This failure is " 422911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << L"expected too.\x8120"; 423011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "This failure is expected too."); 423111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 423211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 423311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 423411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_TRUE. 423511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_TRUE) { 423611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(true) << "Intentional success"; 423711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.", 423811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure #1."); 423911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.", 424011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure #2."); 424111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(2 > 1); // NOLINT 424211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 424311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 2 < 1\n" 424411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: false\n" 424511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: true"); 424611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 424711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2 > 3"); 424811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 424911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 425011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult. 425111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, ExpectTrueWithAssertionResult) { 425211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ResultIsEven(2)); 425311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)), 425411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEven(3)\n" 425511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: false (3 is odd)\n" 425611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: true"); 425711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ResultIsEvenNoExplanation(2)); 425811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)), 425911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEvenNoExplanation(3)\n" 426011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: false (3 is odd)\n" 426111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: true"); 426211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 426311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 426411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_FALSE with a streamed message. 426511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_FALSE) { 426611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(2 < 1); // NOLINT 426711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(false) << "Intentional success"; 426811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.", 426911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure #1."); 427011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.", 427111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure #2."); 427211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 427311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 2 > 1\n" 427411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true\n" 427511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 427611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 427711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2 < 3"); 427811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 427911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 428011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult. 428111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, ExpectFalseWithAssertionResult) { 428211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ResultIsEven(3)); 428311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)), 428411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEven(2)\n" 428511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true (2 is even)\n" 428611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 428711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ResultIsEvenNoExplanation(3)); 428811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)), 428911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: ResultIsEvenNoExplanation(2)\n" 429011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: true\n" 429111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: false"); 429211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 429311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 429411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 429511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Restores warnings after previous "#pragma option push" supressed them 429611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option pop 429711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 429811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 429911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_EQ. 430011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_EQ) { 430111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(5, 2 + 3); 430211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 430311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: 2*3\n" 430411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: 6\n" 430511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 5"); 430611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 430711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2 - 3"); 430811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 430911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 431011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using EXPECT_EQ on double values. The purpose is to make 431111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// sure that the specialization we did for integer and anonymous enums 431211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// isn't used for double arguments. 431311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_EQ_Double) { 431411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 431511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(5.6, 5.6); 431611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 431711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 431811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 431911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "5.1"); 432011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 432111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 432211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_CAN_COMPARE_NULL 432311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_EQ(NULL, pointer). 432411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_EQ_NULL) { 432511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 432611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* p = NULL; 432711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some older GCC versions may issue a spurious warning in this or the next 432811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // assertion statement. This warning should not be suppressed with 432911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // static_cast since the test verifies the ability to use bare NULL as the 433011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // expected parameter to the macro. 433111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(NULL, p); 433211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 433311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 433411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 433511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 433611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: &n\n"); 433711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 433811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_CAN_COMPARE_NULL 433911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 434011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 434111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// treated as a null pointer by the compiler, we need to make sure 434211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 434311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 434411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_EQ_0) { 434511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 434611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 434711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A success. 434811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, n); 434911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 435011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // A failure. 435111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 435211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: 0"); 435311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 435411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 435511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_NE. 435611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_NE) { 435711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(6, 7); 435811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 435911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 436011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ('a') != ('a'), " 436111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 436211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 436311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "2"); 436411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p0 = NULL; 436511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 436611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p0"); 436711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Only way to get the Nokia compiler to compile the cast 436811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is to have a separate void* variable first. Putting 436911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the two casts on the same line doesn't work, neither does 437011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // a direct C-style to char*. 437111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv1 = (void*)0x1234; // NOLINT 437211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p1 = reinterpret_cast<char*>(pv1); 437311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 437411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p1"); 437511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 437611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 437711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_LE. 437811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_LE) { 437911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(2, 3); 438011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(2, 2); 438111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 438211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) <= (0), actual: 2 vs 0"); 438311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 438411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(1.1) <= (0.9)"); 438511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 438611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 438711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_LT. 438811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_LT) { 438911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(2, 3); 439011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 439111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) < (2), actual: 2 vs 2"); 439211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 439311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(2) < (1)"); 439411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 439511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 439611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_GE. 439711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_GE) { 439811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(2, 1); 439911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(2, 2); 440011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 440111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) >= (3), actual: 2 vs 3"); 440211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 440311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(0.9) >= (1.1)"); 440411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 440511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 440611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_GT. 440711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_GT) { 440811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GT(2, 1); 440911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 441011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: (2) > (2), actual: 2 vs 2"); 441111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 441211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(2) > (3)"); 441311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 441411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 441511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 441611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 441711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_THROW. 441811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_THROW) { 441911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowAnInteger(), int); 442011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 442111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowAnInteger() throws an exception of " 442211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "type bool.\n Actual: it throws a different type."); 442311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 442411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowNothing(), bool), 442511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowNothing() throws an exception of type bool.\n" 442611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: it throws nothing."); 442711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 442811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 442911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_NO_THROW. 443011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_NO_THROW) { 443111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(ThrowNothing()); 443211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 443311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowAnInteger() doesn't throw an " 443411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "exception.\n Actual: it throws."); 443511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 443611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 443711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests EXPECT_ANY_THROW. 443811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, EXPECT_ANY_THROW) { 443911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(ThrowAnInteger()); 444011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE( 444111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(ThrowNothing()), 444211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: ThrowNothing() throws an exception.\n" 444311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: it doesn't."); 444411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 444511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 444611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 444711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 444811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Make sure we deal with the precedence of <<. 444911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ExpectTest, ExpectPrecedence) { 445011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1 < 2, true); 445111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 445211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: true && false"); 445311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 445411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 445511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 445611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the StreamableToString() function. 445711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 445811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using StreamableToString() on a scalar. 445911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableToStringTest, Scalar) { 446011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("5", StreamableToString(5).c_str()); 446111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 446211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 446311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using StreamableToString() on a non-char pointer. 446411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableToStringTest, Pointer) { 446511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 446611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int* p = &n; 446711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 446811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 446911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 447011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using StreamableToString() on a NULL non-char pointer. 447111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableToStringTest, NullPointer) { 447211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int* p = NULL; 447311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 447411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 447511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 447611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using StreamableToString() on a C string. 447711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableToStringTest, CString) { 447811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 447911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 448011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 448111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using StreamableToString() on a NULL C string. 448211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableToStringTest, NullCString) { 448311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* p = NULL; 448411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 448511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 448611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 448711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using streamable values as assertion messages. 448811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 448911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using std::string as an assertion message. 449011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, string) { 449111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const std::string str( 449211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "This failure message is a std::string, and is expected."); 449311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << str, 449411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert str.c_str()); 449511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 449611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 449711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that we can output strings containing embedded NULs. 449811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Limited to Linux because we can only do this with std::string's. 449911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, stringWithEmbeddedNUL) { 450011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char char_array_with_nul[] = 450111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Here's a NUL\0 and some more string"; 450211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const std::string string_with_nul(char_array_with_nul, 450311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sizeof(char_array_with_nul) 450411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert - 1); // drops the trailing NUL 450511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 450611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Here's a NUL\\0 and some more string"); 450711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 450811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 450911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that we can output a NUL char. 451011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, NULChar) { 451111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 451211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "A NUL" << '\0' << " and some more string"; 451311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "A NUL\\0 and some more string"); 451411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 451511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 451611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using int as an assertion message. 451711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, int) { 451811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << 900913, 451911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "900913"); 452011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 452111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 452211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using NULL char pointer as an assertion message. 452311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 452411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// In MSVC, streaming a NULL char * causes access violation. Google Test 452511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// implemented a workaround (substituting "(null)" for NULL). This 452611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// tests whether the workaround works. 452711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, NullCharPtr) { 452811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 452911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "(null)"); 453011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 453111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 453211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that basic IO manipulators (endl, ends, and flush) can be 453311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// streamed to testing::Message. 453411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamableTest, BasicIoManip) { 453511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 453611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FAIL() << "Line 1." << std::endl 453711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "A NUL char " << std::ends << std::flush << " in line 2."; 453811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Line 1.\nA NUL char \\0 in line 2."); 453911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 454011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 454111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the macros that haven't been covered so far. 454211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 454311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid AddFailureHelper(bool* aborted) { 454411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = true; 454511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE() << "Intentional failure."; 454611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *aborted = false; 454711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 454811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 454911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ADD_FAILURE. 455011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MacroTest, ADD_FAILURE) { 455111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool aborted = true; 455211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 455311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure."); 455411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(aborted); 455511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 455611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 455711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ADD_FAILURE_AT. 455811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MacroTest, ADD_FAILURE_AT) { 455911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and 456011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the failure message contains the user-streamed part. 456111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!"); 456211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 456311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies that the user-streamed part is optional. 456411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed"); 456511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 456611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Unfortunately, we cannot verify that the failure message contains 456711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the right file path and line number the same way, as 456811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and 456911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // line number. Instead, we do that in gtest_output_test_.cc. 457011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 457111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 457211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests FAIL. 457311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MacroTest, FAIL) { 457411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL(), 457511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Failed"); 457611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 457711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Intentional failure."); 457811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 457911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 458011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests SUCCEED 458111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MacroTest, SUCCEED) { 458211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED(); 458311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED() << "Explicit success."; 458411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 458511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 458611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for EXPECT_EQ() and ASSERT_EQ(). 458711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 458811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// These tests fail *intentionally*, s.t. the failure messages can be 458911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// generated and tested. 459011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 459111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We have different tests for different argument types. 459211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 459311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using bool values in {EXPECT|ASSERT}_EQ. 459411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, Bool) { 459511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(true, true); 459611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ 459711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool false_value = false; 459811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(false_value, true); 459911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Value of: true"); 460011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 460111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 460211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using int values in {EXPECT|ASSERT}_EQ. 460311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, Int) { 460411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(32, 32); 460511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 460611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "33"); 460711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 460811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 460911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using time_t values in {EXPECT|ASSERT}_EQ. 461011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, Time_T) { 461111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(static_cast<time_t>(0), 461211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<time_t>(0)); 461311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 461411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<time_t>(1234)), 461511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1234"); 461611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 461711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 461811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using char values in {EXPECT|ASSERT}_EQ. 461911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, Char) { 462011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ('z', 'z'); 462111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char ch = 'b'; 462211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 462311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "ch"); 462411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 462511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "ch"); 462611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 462711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 462811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 462911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, WideChar) { 463011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(L'b', L'b'); 463111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 463211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 463311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: L'x'\n" 463411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: L'x' (120, 0x78)\n" 463511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Expected: L'\0'\n" 463611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Which is: L'\0' (0, 0x0)"); 463711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 463811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static wchar_t wchar; 463911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar = L'b'; 464011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 464111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "wchar"); 464211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar = 0x8119; 464311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar), 464411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: wchar"); 464511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 464611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 464711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 464811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, StdString) { 464911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a const char* to an std::string that has identical 465011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content. 465111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ("Test", ::std::string("Test")); 465211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 465311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two identical std::strings. 465411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const ::std::string str1("A * in the middle"); 465511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const ::std::string str2(str1); 465611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(str1, str2); 465711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 465811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a const char* to an std::string that has different 465911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content 466011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 466111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "\"test\""); 466211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 466311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares an std::string to a char* that has different content. 466411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p1 = const_cast<char*>("foo"); 466511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 466611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p1"); 466711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 466811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two std::strings that have different contents, one of 466911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // which having a NUL character in the middle. This should fail. 467011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static ::std::string str3(str1); 467111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert str3.at(2) = '\0'; 467211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 467311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: str3\n" 467411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert " Actual: \"A \\0 in the middle\""); 467511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 467611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 467711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STD_WSTRING 467811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 467911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 468011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, StdWideString) { 468111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two identical std::wstrings. 468211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::std::wstring wstr1(L"A * in the middle"); 468311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::std::wstring wstr2(wstr1); 468411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(wstr1, wstr2); 468511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 468611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares an std::wstring to a const wchar_t* that has identical 468711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content. 468811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 468911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119); 469011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 469111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares an std::wstring to a const wchar_t* that has different 469211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content. 469311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 469411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 469511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120); 469611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "kTestX8120"); 469711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 469811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two std::wstrings that have different contents, one of 469911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // which having a NUL character in the middle. 470011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::std::wstring wstr3(wstr1); 470111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wstr3.at(2) = L'\0'; 470211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 470311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "wstr3"); 470411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 470511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a wchar_t* to an std::wstring that has different 470611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content. 470711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 470811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 470911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 471011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 471111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 471211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STD_WSTRING 471311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 471411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_STRING 471511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ::string values in {EXPECT|ASSERT}_EQ. 471611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, GlobalString) { 471711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a const char* to a ::string that has identical content. 471811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ("Test", ::string("Test")); 471911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 472011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two identical ::strings. 472111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::string str1("A * in the middle"); 472211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ::string str2(str1); 472311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(str1, str2); 472411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 472511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a ::string to a const char* that has different content. 472611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 472711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "test"); 472811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 472911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two ::strings that have different contents, one of which 473011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // having a NUL character in the middle. 473111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::string str3(str1); 473211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert str3.at(2) = '\0'; 473311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 473411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "str3"); 473511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 473611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a ::string to a char* that has different content. 473711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE({ // NOLINT 473811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 473911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, ""); 474011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 474111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 474211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_STRING 474311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 474411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_GLOBAL_WSTRING 474511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 474611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 474711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, GlobalWideString) { 474811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two identical ::wstrings. 474911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const ::wstring wstr1(L"A * in the middle"); 475011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const ::wstring wstr2(wstr1); 475111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(wstr1, wstr2); 475211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 475311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a const wchar_t* to a ::wstring that has identical content. 475411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 475511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(kTestX8119, ::wstring(kTestX8119)); 475611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 475711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a const wchar_t* to a ::wstring that has different 475811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // content. 475911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 476011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE({ // NOLINT 476111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(kTestX8120, ::wstring(kTestX8119)); 476211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }, "Test\\x8119"); 476311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 476411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares a wchar_t* to a ::wstring that has different content. 476511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 476611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 476711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "bar"); 476811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 476911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Compares two ::wstrings that have different contents, one of which 477011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // having a NUL character in the middle. 477111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static ::wstring wstr3; 477211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wstr3 = wstr1; 477311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wstr3.at(2) = L'\0'; 477411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 477511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "wstr3"); 477611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 477711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 477811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_GLOBAL_WSTRING 477911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 478011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using char pointers in {EXPECT|ASSERT}_EQ. 478111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, CharPointer) { 478211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p0 = NULL; 478311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Only way to get the Nokia compiler to compile the cast 478411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is to have a separate void* variable first. Putting 478511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the two casts on the same line doesn't work, neither does 478611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // a direct C-style to char*. 478711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv1 = (void*)0x1234; // NOLINT 478811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv2 = (void*)0xABC0; // NOLINT 478911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p1 = reinterpret_cast<char*>(pv1); 479011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p2 = reinterpret_cast<char*>(pv2); 479111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(p1, p1); 479211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 479311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 479411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: p2"); 479511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 479611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p2"); 479711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 479811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert reinterpret_cast<char*>(0xABC0)), 479911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "ABC0"); 480011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 480111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 480211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 480311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, WideCharPointer) { 480411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar_t* const p0 = NULL; 480511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Only way to get the Nokia compiler to compile the cast 480611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is to have a separate void* variable first. Putting 480711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the two casts on the same line doesn't work, neither does 480811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // a direct C-style to char*. 480911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv1 = (void*)0x1234; // NOLINT 481011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv2 = (void*)0xABC0; // NOLINT 481111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 481211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 481311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(p0, p0); 481411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 481511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 481611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "Value of: p2"); 481711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 481811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p2"); 481911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv3 = (void*)0x1234; // NOLINT 482011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void* pv4 = (void*)0xABC0; // NOLINT 482111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 482211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 482311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 482411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "p4"); 482511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 482611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 482711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 482811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EqAssertionTest, OtherPointer) { 482911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(static_cast<const int*>(NULL), 483011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static_cast<const int*>(NULL)); 483111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 483211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert reinterpret_cast<const int*>(0x1234)), 483311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "0x1234"); 483411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 483511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 483611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A class that supports binary comparison operators but not streaming. 483711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass UnprintableChar { 483811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 483911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit UnprintableChar(char ch) : char_(ch) {} 484011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 484111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator==(const UnprintableChar& rhs) const { 484211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ == rhs.char_; 484311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 484411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator!=(const UnprintableChar& rhs) const { 484511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ != rhs.char_; 484611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 484711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator<(const UnprintableChar& rhs) const { 484811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ < rhs.char_; 484911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 485011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator<=(const UnprintableChar& rhs) const { 485111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ <= rhs.char_; 485211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 485311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator>(const UnprintableChar& rhs) const { 485411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ > rhs.char_; 485511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 485611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator>=(const UnprintableChar& rhs) const { 485711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return char_ >= rhs.char_; 485811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 485911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 486011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 486111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char char_; 486211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 486311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 486411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ASSERT_EQ() and friends don't require the arguments to 486511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be printable. 486611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ComparisonAssertionTest, AcceptsUnprintableArgs) { 486711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const UnprintableChar x('x'), y('y'); 486811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(x, x); 486911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(x, y); 487011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(x, y); 487111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LE(x, y); 487211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_GT(y, x); 487311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_GE(x, x); 487411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 487511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>"); 487611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>"); 487711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>"); 487811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>"); 487911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>"); 488011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 488111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Code tested by EXPECT_FATAL_FAILURE cannot reference local 488211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // variables, so we have to write UnprintableChar('x') instead of x. 488311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ 488411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ICE's in C++Builder. 488511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')), 488611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1-byte object <78>"); 488711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 488811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1-byte object <78>"); 488911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 489011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 489111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1-byte object <79>"); 489211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 489311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1-byte object <78>"); 489411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 489511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "1-byte object <79>"); 489611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 489711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 489811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the FRIEND_TEST macro. 489911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 490011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class has a private member we want to test. We will test it 490111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// both in a TEST and in a TEST_F. 490211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Foo { 490311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 490411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Foo() {} 490511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 490611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 490711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int Bar() const { return 1; } 490811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 490911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Declares the friend tests that can access the private member 491011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Bar(). 491111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FRIEND_TEST(FRIEND_TEST_Test, TEST); 491211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 491311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 491411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 491511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the FRIEND_TEST declaration allows a TEST to access a 491611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// class's private members. This should compile. 491711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(FRIEND_TEST_Test, TEST) { 491811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, Foo().Bar()); 491911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 492011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 492111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The fixture needed to test using FRIEND_TEST with TEST_F. 492211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass FRIEND_TEST_Test2 : public Test { 492311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 492411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Foo foo; 492511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 492611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 492711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 492811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// class's private members. This should compile. 492911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(FRIEND_TEST_Test2, TEST_F) { 493011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, foo.Bar()); 493111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 493211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 493311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the life cycle of Test objects. 493411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 493511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The test fixture for testing the life cycle of Test objects. 493611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 493711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This class counts the number of live test objects that uses this 493811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// fixture. 493911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestLifeCycleTest : public Test { 494011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 494111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Constructor. Increments the number of test objects that uses 494211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this fixture. 494311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestLifeCycleTest() { count_++; } 494411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 494511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Destructor. Decrements the number of test objects that uses this 494611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fixture. 494711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~TestLifeCycleTest() { count_--; } 494811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 494911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Returns the number of live test objects that uses this fixture. 495011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int count() const { return count_; } 495111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 495211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 495311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int count_; 495411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 495511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 495611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint TestLifeCycleTest::count_ = 0; 495711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 495811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the life cycle of test objects. 495911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestLifeCycleTest, Test1) { 496011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // There should be only one test object in this test case that's 496111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // currently alive. 496211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, count()); 496311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 496411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 496511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the life cycle of test objects. 496611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestLifeCycleTest, Test2) { 496711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // After Test1 is done and Test2 is started, there should still be 496811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // only one live test object, as the object for Test1 should've been 496911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // deleted. 497011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, count()); 497111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 497211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 497311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace 497411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 497511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the copy constructor works when it is NOT optimized away by 497611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the compiler. 497711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) { 497811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Checks that the copy constructor doesn't try to dereference NULL pointers 497911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // in the source object. 498011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r1 = AssertionSuccess(); 498111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r2 = r1; 498211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The following line is added to prevent the compiler from optimizing 498311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // away the constructor call. 498411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r1 << "abc"; 498511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 498611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r3 = r1; 498711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1)); 498811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abc", r1.message()); 498911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 499011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 499111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that AssertionSuccess and AssertionFailure construct 499211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// AssertionResult objects as expected. 499311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionResultTest, ConstructionWorks) { 499411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r1 = AssertionSuccess(); 499511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(r1); 499611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", r1.message()); 499711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 499811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r2 = AssertionSuccess() << "abc"; 499911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(r2); 500011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abc", r2.message()); 500111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 500211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r3 = AssertionFailure(); 500311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(r3); 500411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", r3.message()); 500511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 500611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r4 = AssertionFailure() << "def"; 500711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(r4); 500811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("def", r4.message()); 500911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 501011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r5 = AssertionFailure(Message() << "ghi"); 501111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(r5); 501211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("ghi", r5.message()); 501311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 501411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 501511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the negation flips the predicate result but keeps the message. 501611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionResultTest, NegationWorks) { 501711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r1 = AssertionSuccess() << "abc"; 501811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(!r1); 501911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abc", (!r1).message()); 502011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 502111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r2 = AssertionFailure() << "def"; 502211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(!r2); 502311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("def", (!r2).message()); 502411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 502511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 502611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionResultTest, StreamingWorks) { 502711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r = AssertionSuccess(); 502811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r << "abc" << 'd' << 0 << true; 502911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abcd0true", r.message()); 503011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 503111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 503211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AssertionResultTest, CanStreamOstreamManipulators) { 503311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertionResult r = AssertionSuccess(); 503411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert r << "Data" << std::endl << std::flush << std::ends << "Will be visible"; 503511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("Data\n\\0Will be visible", r.message()); 503611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 503711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 503811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming a user type whose definition and operator << are 503911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// both in the global namespace. 504011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Base { 504111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 504211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit Base(int an_x) : x_(an_x) {} 504311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int x() const { return x_; } 504411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 504511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int x_; 504611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 504711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 504811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Base& val) { 504911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << val.x(); 505011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 505111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 505211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Base* pointer) { 505311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << "(" << pointer->x() << ")"; 505411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 505511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 505611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 505711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 505811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Base a(1); 505911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 506011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << a << &a; // Uses ::operator<<. 506111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1(1)", msg.GetString().c_str()); 506211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 506311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 506411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming a user type whose definition and operator<< are 506511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// both in an unnamed namespace. 506611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace { 506711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MyTypeInUnnamedNameSpace : public Base { 506811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 506911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {} 507011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 507111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 507211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const MyTypeInUnnamedNameSpace& val) { 507311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << val.x(); 507411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 507511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 507611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const MyTypeInUnnamedNameSpace* pointer) { 507711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << "(" << pointer->x() << ")"; 507811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 507911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace 508011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 508111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 508211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 508311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert MyTypeInUnnamedNameSpace a(1); 508411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 508511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << a << &a; // Uses <unnamed_namespace>::operator<<. 508611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1(1)", msg.GetString().c_str()); 508711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 508811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 508911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming a user type whose definition and operator<< are 509011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// both in a user namespace. 509111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace namespace1 { 509211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MyTypeInNameSpace1 : public Base { 509311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 509411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit MyTypeInNameSpace1(int an_x): Base(an_x) {} 509511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 509611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 509711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const MyTypeInNameSpace1& val) { 509811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << val.x(); 509911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 510011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 510111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const MyTypeInNameSpace1* pointer) { 510211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << "(" << pointer->x() << ")"; 510311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 510411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace namespace1 510511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 510611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 510711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 510811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert namespace1::MyTypeInNameSpace1 a(1); 510911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 511011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << a << &a; // Uses namespace1::operator<<. 511111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1(1)", msg.GetString().c_str()); 511211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 511311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 511411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming a user type whose definition is in a user namespace 511511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// but whose operator<< is in the global namespace. 511611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace namespace2 { 511711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass MyTypeInNameSpace2 : public ::Base { 511811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 511911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit MyTypeInNameSpace2(int an_x): Base(an_x) {} 512011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 512111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace namespace2 512211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 512311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const namespace2::MyTypeInNameSpace2& val) { 512411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << val.x(); 512511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 512611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstd::ostream& operator<<(std::ostream& os, 512711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const namespace2::MyTypeInNameSpace2* pointer) { 512811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return os << "(" << pointer->x() << ")"; 512911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 513011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 513111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 513211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 513311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert namespace2::MyTypeInNameSpace2 a(1); 513411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 513511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << a << &a; // Uses ::operator<<. 513611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1(1)", msg.GetString().c_str()); 513711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 513811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 513911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming NULL pointers to testing::Message. 514011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, NullPointers) { 514111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message msg; 514211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char* const p1 = NULL; 514311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned char* const p2 = NULL; 514411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int* p3 = NULL; 514511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert double* p4 = NULL; 514611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool* p5 = NULL; 514711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message* p6 = NULL; 514811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 514911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg << p1 << p2 << p3 << p4 << p5 << p6; 515011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 515111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert msg.GetString().c_str()); 515211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 515311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 515411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests streaming wide strings to testing::Message. 515511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(MessageTest, WideStrings) { 515611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Streams a NULL of type const wchar_t*. 515711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t* const_wstr = NULL; 515811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(null)", 515911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (Message() << const_wstr).GetString().c_str()); 516011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 516111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Streams a NULL of type wchar_t*. 516211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wchar_t* wstr = NULL; 516311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("(null)", 516411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (Message() << wstr).GetString().c_str()); 516511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 516611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Streams a non-NULL of type const wchar_t*. 516711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const_wstr = L"abc\x8119"; 516811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abc\xe8\x84\x99", 516911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (Message() << const_wstr).GetString().c_str()); 517011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 517111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Streams a non-NULL of type wchar_t*. 517211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert wstr = const_cast<wchar_t*>(const_wstr); 517311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("abc\xe8\x84\x99", 517411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (Message() << wstr).GetString().c_str()); 517511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 517611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 517711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 517811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This line tests that we can define tests in the testing namespace. 517911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 518011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 518111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the TestInfo class. 518211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 518311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestInfoTest : public Test { 518411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 518511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const TestInfo* GetTestInfo(const char* test_name) { 518611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestCase* const test_case = GetUnitTestImpl()-> 518711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GetTestCase("TestInfoTest", "", NULL, NULL); 518811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 518911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (int i = 0; i < test_case->total_test_count(); ++i) { 519011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* const test_info = test_case->GetTestInfo(i); 519111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (strcmp(test_name, test_info->name()) == 0) 519211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return test_info; 519311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 519411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return NULL; 519511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 519611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 519711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const TestResult* GetTestResult( 519811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info) { 519911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return test_info->result(); 520011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 520111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 520211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 520311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestInfo::test_case_name() and TestInfo::name(). 520411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestInfoTest, Names) { 520511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* const test_info = GetTestInfo("Names"); 520611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 520711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 520811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("Names", test_info->name()); 520911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 521011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 521111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests TestInfo::result(). 521211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(TestInfoTest, result) { 521311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* const test_info = GetTestInfo("result"); 521411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 521511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Initially, there is no TestPartResult for this test. 521611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 521711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 521811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // After the previous assertion, there is still none. 521911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 522011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 522111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 522211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests setting up and tearing down a test case. 522311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 522411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass SetUpTestCaseTest : public Test { 522511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 522611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This will be called once before the first test in this test case 522711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // is run. 522811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 522911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("Setting up the test case . . .\n"); 523011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 523111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Initializes some shared resource. In this simple example, we 523211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // just create a C string. More complex stuff can be done if 523311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // desired. 523411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert shared_resource_ = "123"; 523511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 523611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Increments the number of test cases that have been set up. 523711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert counter_++; 523811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 523911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // SetUpTestCase() should be called only once. 524011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, counter_); 524111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 524211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 524311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This will be called once after the last test in this test case is 524411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // run. 524511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TearDownTestCase() { 524611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert printf("Tearing down the test case . . .\n"); 524711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 524811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Decrements the number of test cases that have been set up. 524911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert counter_--; 525011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 525111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // TearDownTestCase() should be called only once. 525211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, counter_); 525311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 525411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Cleans up the shared resource. 525511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert shared_resource_ = NULL; 525611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 525711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 525811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This will be called before each test in this test case. 525911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 526011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // SetUpTestCase() should be called only once, so counter_ should 526111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // always be 1. 526211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, counter_); 526311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 526411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 526511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Number of test cases that have been set up. 526611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static int counter_; 526711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 526811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Some resource to be shared by all tests in this test case. 526911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static const char* shared_resource_; 527011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 527111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 527211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint SetUpTestCaseTest::counter_ = 0; 527311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertconst char* SetUpTestCaseTest::shared_resource_ = NULL; 527411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 527511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A test that uses the shared resource. 527611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SetUpTestCaseTest, Test1) { 527711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE(NULL, shared_resource_); 527811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 527911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 528011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Another test that uses the shared resource. 528111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(SetUpTestCaseTest, Test2) { 528211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("123", shared_resource_); 528311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 528411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 528511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 528611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 528711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The Flags struct stores a copy of all Google Test flags. 528811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct Flags { 528911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Constructs a Flags struct where each flag has its default value. 529011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags() : also_run_disabled_tests(false), 529111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break_on_failure(false), 529211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert catch_exceptions(false), 529311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert death_test_use_fork(false), 529411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert filter(""), 529511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert list_tests(false), 529611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert output(""), 529711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert print_time(true), 529811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert random_seed(0), 529911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert repeat(1), 530011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert shuffle(false), 530111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert stack_trace_depth(kMaxStackTraceDepth), 530211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert stream_result_to(""), 530311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert throw_on_failure(false) {} 530411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 530511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Factory methods. 530611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 530711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_also_run_disabled_tests flag has 530811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 530911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { 531011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 531111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.also_run_disabled_tests = also_run_disabled_tests; 531211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 531311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 531411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 531511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_break_on_failure flag has 531611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 531711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags BreakOnFailure(bool break_on_failure) { 531811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 531911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.break_on_failure = break_on_failure; 532011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 532111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 532211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 532311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_catch_exceptions flag has 532411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 532511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags CatchExceptions(bool catch_exceptions) { 532611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 532711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.catch_exceptions = catch_exceptions; 532811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 532911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 533011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 533111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_death_test_use_fork flag has 533211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 533311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags DeathTestUseFork(bool death_test_use_fork) { 533411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 533511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.death_test_use_fork = death_test_use_fork; 533611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 533711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 533811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 533911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_filter flag has the given 534011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value. 534111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags Filter(const char* filter) { 534211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 534311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.filter = filter; 534411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 534511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 534611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 534711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_list_tests flag has the 534811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // given value. 534911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags ListTests(bool list_tests) { 535011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 535111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.list_tests = list_tests; 535211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 535311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 535411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 535511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_output flag has the given 535611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value. 535711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags Output(const char* output) { 535811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 535911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.output = output; 536011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 536111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 536211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 536311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_print_time flag has the given 536411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value. 536511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags PrintTime(bool print_time) { 536611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 536711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.print_time = print_time; 536811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 536911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 537011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 537111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_random_seed flag has 537211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 537311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags RandomSeed(Int32 random_seed) { 537411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 537511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.random_seed = random_seed; 537611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 537711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 537811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 537911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_repeat flag has the given 538011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // value. 538111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags Repeat(Int32 repeat) { 538211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 538311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.repeat = repeat; 538411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 538511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 538611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 538711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_shuffle flag has 538811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 538911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags Shuffle(bool shuffle) { 539011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 539111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.shuffle = shuffle; 539211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 539311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 539411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 539511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has 539611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 539711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags StackTraceDepth(Int32 stack_trace_depth) { 539811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 539911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.stack_trace_depth = stack_trace_depth; 540011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 540111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 540211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 540311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has 540411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 540511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags StreamResultTo(const char* stream_result_to) { 540611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 540711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.stream_result_to = stream_result_to; 540811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 540911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 541011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 541111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Creates a Flags struct where the gtest_throw_on_failure flag has 541211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the given value. 541311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static Flags ThrowOnFailure(bool throw_on_failure) { 541411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 541511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.throw_on_failure = throw_on_failure; 541611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return flags; 541711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 541811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 541911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // These fields store the flag values. 542011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool also_run_disabled_tests; 542111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool break_on_failure; 542211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool catch_exceptions; 542311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool death_test_use_fork; 542411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* filter; 542511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool list_tests; 542611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* output; 542711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool print_time; 542811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 random_seed; 542911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 repeat; 543011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool shuffle; 543111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Int32 stack_trace_depth; 543211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* stream_result_to; 543311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool throw_on_failure; 543411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 543511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 543611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Fixture for testing InitGoogleTest(). 543711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass InitGoogleTestTest : public Test { 543811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 543911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Clears the flags before each test. 544011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 544111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(also_run_disabled_tests) = false; 544211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(break_on_failure) = false; 544311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(catch_exceptions) = false; 544411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(death_test_use_fork) = false; 544511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(filter) = ""; 544611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(list_tests) = false; 544711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(output) = ""; 544811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(print_time) = true; 544911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(random_seed) = 0; 545011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(repeat) = 1; 545111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(shuffle) = false; 545211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 545311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stream_result_to) = ""; 545411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(throw_on_failure) = false; 545511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 545611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 545711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Asserts that two narrow or wide string arrays are equal. 545811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert template <typename CharType> 545911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void AssertStringArrayEq(size_t size1, CharType** array1, 546011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t size2, CharType** array2) { 546111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(size1, size2) << " Array sizes different."; 546211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 546311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t i = 0; i != size1; i++) { 546411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 546511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 546611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 546711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 546811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies that the flag values match the expected values. 546911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void CheckFlags(const Flags& expected) { 547011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.also_run_disabled_tests, 547111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(also_run_disabled_tests)); 547211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 547311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 547411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork)); 547511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 547611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 547711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 547811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 547911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed)); 548011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 548111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle)); 548211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth)); 548311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ(expected.stream_result_to, 548411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(stream_result_to).c_str()); 548511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure)); 548611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 548711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 548811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Parses a command line (specified by argc1 and argv1), then 548911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // verifies that the flag values are expected and that the 549011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // recognized flags are removed from the command line. 549111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert template <typename CharType> 549211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TestParsingFlags(int argc1, const CharType** argv1, 549311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int argc2, const CharType** argv2, 549411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const Flags& expected, bool should_print_help) { 549511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool saved_help_flag = ::testing::internal::g_help_flag; 549611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::testing::internal::g_help_flag = false; 549711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 549811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STREAM_REDIRECTION 549911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CaptureStdout(); 550011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 550111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 550211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Parses the command line. 550311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); 550411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 550511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STREAM_REDIRECTION 550611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const std::string captured_stdout = GetCapturedStdout(); 550711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 550811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 550911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies the flag values. 551011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CheckFlags(expected); 551111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 551211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Verifies that the recognized flags are removed from the command 551311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // line. 551411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 551511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 551611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the 551711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // help message for the flags it recognizes. 551811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag); 551911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 552011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_STREAM_REDIRECTION 552111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* const expected_help_fragment = 552211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "This program contains tests written using"; 552311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (should_print_help) { 552411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout); 552511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else { 552611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_PRED_FORMAT2(IsNotSubstring, 552711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert expected_help_fragment, captured_stdout); 552811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 552911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_STREAM_REDIRECTION 553011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 553111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::testing::internal::g_help_flag = saved_help_flag; 553211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 553311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 553411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // This macro wraps TestParsingFlags s.t. the user doesn't need 553511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // to specify the array sizes. 553611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 553711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \ 553811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 553911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sizeof(argv2)/sizeof(*argv2) - 1, argv2, \ 554011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert expected, should_print_help) 554111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 554211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 554311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing an empty command line. 554411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, Empty) { 554511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 554611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 554711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 554811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 554911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 555011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 555111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 555211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 555311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 555411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 555511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 555611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a command line that has no flag. 555711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, NoFlag) { 555811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 555911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 556011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 556111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 556211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 556311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 556411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 556511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 556611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 556711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 556811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 556911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 557011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 557111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a bad --gtest_filter flag. 557211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, FilterBad) { 557311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 557411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 557511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter", 557611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 557711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 557811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 557911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 558011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 558111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter", 558211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 558311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 558411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 558511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true); 558611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 558711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 558811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing an empty --gtest_filter flag. 558911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, FilterEmpty) { 559011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 559111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 559211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter=", 559311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 559411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 559511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 559611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 559711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 559811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 559911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 560011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 560111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false); 560211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 560311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 560411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a non-empty --gtest_filter flag. 560511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, FilterNonEmpty) { 560611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 560711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 560811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter=abc", 560911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 561011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 561111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 561211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 561311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 561411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 561511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 561611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 561711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); 561811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 561911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 562011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_break_on_failure. 562111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) { 562211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 562311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 562411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure", 562511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 562611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 562711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 562811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 562911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 563011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 563111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 563211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 563311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 563411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 563511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 563611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_break_on_failure=0. 563711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 563811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 563911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 564011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure=0", 564111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 564211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 564311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 564411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 564511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 564611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 564711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 564811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 564911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 565011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 565111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 565211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_break_on_failure=f. 565311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 565411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 565511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 565611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure=f", 565711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 565811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 565911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 566011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 566111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 566211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 566311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 566411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 566511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 566611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 566711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 566811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_break_on_failure=F. 566911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 567011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 567111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 567211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure=F", 567311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 567411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 567511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 567611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 567711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 567811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 567911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 568011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 568111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 568211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 568311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 568411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a --gtest_break_on_failure flag that has a "true" 568511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// definition. 568611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 568711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 568811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 568911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure=1", 569011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 569111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 569211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 569311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 569411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 569511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 569611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 569711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 569811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 569911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 570011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 570111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_catch_exceptions. 570211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, CatchExceptions) { 570311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 570411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 570511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_catch_exceptions", 570611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 570711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 570811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 570911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 571011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 571111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 571211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 571311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 571411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false); 571511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 571611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 571711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_death_test_use_fork. 571811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, DeathTestUseFork) { 571911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 572011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 572111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_death_test_use_fork", 572211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 572311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 572411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 572511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 572611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 572711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 572811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 572911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 573011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false); 573111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 573211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 573311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having the same flag twice with different values. The 573411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// expected behavior is that the one coming last takes precedence. 573511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, DuplicatedFlags) { 573611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 573711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 573811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter=a", 573911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter=b", 574011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 574111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 574211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 574311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 574411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 574511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 574611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 574711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 574811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false); 574911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 575011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 575111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having an unrecognized flag on the command line. 575211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 575311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 575411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 575511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_break_on_failure", 575611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "bar", // Unrecognized by Google Test. 575711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_filter=b", 575811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 575911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 576011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 576111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 576211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 576311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "bar", 576411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 576511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 576611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 576711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags flags; 576811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.break_on_failure = true; 576911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert flags.filter = "b"; 577011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false); 577111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 577211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 577311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_list_tests flag 577411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ListTestsFlag) { 577511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 577611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 577711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_list_tests", 577811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 577911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 578011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 578111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 578211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 578311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 578411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 578511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 578611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 578711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 578811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 578911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_list_tests flag with a "true" value 579011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ListTestsTrue) { 579111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 579211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 579311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_list_tests=1", 579411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 579511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 579611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 579711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 579811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 579911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 580011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 580111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 580211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 580311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 580411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 580511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_list_tests flag with a "false" value 580611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ListTestsFalse) { 580711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 580811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 580911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_list_tests=0", 581011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 581111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 581211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 581311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 581411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 581511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 581611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 581711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 581811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 581911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 582011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 582111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_list_tests=f. 582211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 582311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 582411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 582511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_list_tests=f", 582611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 582711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 582811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 582911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 583011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 583111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 583211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 583311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 583411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 583511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 583611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 583711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_list_tests=F. 583811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 583911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 584011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 584111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_list_tests=F", 584211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 584311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 584411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 584511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 584611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 584711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 584811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 584911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 585011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 585111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 585211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 585311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_output (invalid). 585411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, OutputEmpty) { 585511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 585611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 585711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_output", 585811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 585911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 586011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 586111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 586211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 586311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_output", 586411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 586511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 586611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 586711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true); 586811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 586911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 587011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_output=xml 587111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, OutputXml) { 587211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 587311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 587411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_output=xml", 587511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 587611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 587711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 587811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 587911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 588011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 588111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 588211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 588311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false); 588411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 588511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 588611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_output=xml:file 588711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, OutputXmlFile) { 588811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 588911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 589011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_output=xml:file", 589111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 589211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 589311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 589411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 589511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 589611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 589711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 589811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 589911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false); 590011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 590111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 590211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_output=xml:directory/path/ 590311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 590411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 590511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 590611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_output=xml:directory/path/", 590711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 590811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 590911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 591011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 591111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 591211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 591311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 591411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 591511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, 591611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags::Output("xml:directory/path/"), false); 591711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 591811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 591911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_print_time flag 592011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, PrintTimeFlag) { 592111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 592211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 592311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_print_time", 592411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 592511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 592611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 592711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 592811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 592911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 593011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 593111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 593211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 593311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 593411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 593511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_print_time flag with a "true" value 593611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, PrintTimeTrue) { 593711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 593811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 593911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_print_time=1", 594011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 594111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 594211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 594311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 594411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 594511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 594611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 594711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 594811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 594911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 595011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 595111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_print_time flag with a "false" value 595211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, PrintTimeFalse) { 595311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 595411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 595511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_print_time=0", 595611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 595711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 595811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 595911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 596011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 596111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 596211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 596311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 596411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 596511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 596611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 596711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_print_time=f. 596811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 596911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 597011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 597111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_print_time=f", 597211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 597311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 597411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 597511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 597611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 597711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 597811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 597911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 598011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 598111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 598211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 598311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_print_time=F. 598411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 598511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 598611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 598711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_print_time=F", 598811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 598911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 599011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 599111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 599211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 599311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 599411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 599511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 599611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 599711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 599811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 599911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_random_seed=number 600011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, RandomSeed) { 600111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 600211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 600311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_random_seed=1000", 600411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 600511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 600611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 600711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 600811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 600911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 601011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 601111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 601211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false); 601311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 601411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 601511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_repeat=number 601611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, Repeat) { 601711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 601811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 601911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_repeat=1000", 602011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 602111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 602211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 602311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 602411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 602511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 602611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 602711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 602811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false); 602911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 603011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 603111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_also_run_disabled_tests flag 603211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { 603311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 603411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 603511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_also_run_disabled_tests", 603611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 603711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 603811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 603911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 604011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 604111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 604211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 604311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 604411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, 604511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags::AlsoRunDisabledTests(true), false); 604611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 604711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 604811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_also_run_disabled_tests flag with a "true" value 604911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { 605011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 605111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 605211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_also_run_disabled_tests=1", 605311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 605411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 605511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 605611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 605711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 605811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 605911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 606011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 606111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, 606211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags::AlsoRunDisabledTests(true), false); 606311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 606411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 606511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests having a --gtest_also_run_disabled_tests flag with a "false" value 606611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { 606711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 606811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 606911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_also_run_disabled_tests=0", 607011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 607111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 607211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 607311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 607411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 607511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 607611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 607711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 607811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, 607911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags::AlsoRunDisabledTests(false), false); 608011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 608111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 608211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_shuffle. 608311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ShuffleWithoutValue) { 608411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 608511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 608611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_shuffle", 608711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 608811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 608911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 609011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 609111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 609211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 609311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 609411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 609511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 609611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 609711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 609811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_shuffle=0. 609911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ShuffleFalse_0) { 610011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 610111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 610211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_shuffle=0", 610311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 610411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 610511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 610611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 610711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 610811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 610911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 611011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 611111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false); 611211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 611311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 611411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a --gtest_shuffle flag that has a "true" 611511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// definition. 611611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ShuffleTrue) { 611711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 611811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 611911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_shuffle=1", 612011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 612111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 612211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 612311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 612411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 612511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 612611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 612711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 612811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 612911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 613011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 613111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_stack_trace_depth=number. 613211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, StackTraceDepth) { 613311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 613411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 613511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_stack_trace_depth=5", 613611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 613711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 613811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 613911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 614011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 614111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 614211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 614311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 614411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false); 614511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 614611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 614711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, StreamResultTo) { 614811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 614911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 615011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_stream_result_to=localhost:1234", 615111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 615211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 615311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 615411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 615511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 615611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 615711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 615811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 615911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_( 616011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert argv, argv2, Flags::StreamResultTo("localhost:1234"), false); 616111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 616211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 616311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_throw_on_failure. 616411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) { 616511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 616611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 616711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_throw_on_failure", 616811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 616911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 617011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 617111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 617211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 617311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 617411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 617511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 617611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 617711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 617811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 617911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing --gtest_throw_on_failure=0. 618011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { 618111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 618211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 618311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_throw_on_failure=0", 618411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 618511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 618611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 618711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 618811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 618911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 619011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 619111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 619211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false); 619311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 619411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 619511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing a --gtest_throw_on_failure flag that has a "true" 619611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// definition. 619711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { 619811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv[] = { 619911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 620011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "--gtest_throw_on_failure=1", 620111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 620211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 620311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 620411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* argv2[] = { 620511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "foo.exe", 620611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 620711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 620811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 620911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 621011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 621111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 621211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 621311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests parsing wide strings. 621411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(InitGoogleTestTest, WideStrings) { 621511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t* argv[] = { 621611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"foo.exe", 621711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"--gtest_filter=Foo*", 621811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"--gtest_list_tests=1", 621911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"--gtest_break_on_failure", 622011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"--non_gtest_flag", 622111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 622211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 622311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 622411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const wchar_t* argv2[] = { 622511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"foo.exe", 622611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert L"--non_gtest_flag", 622711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL 622811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert }; 622911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 623011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Flags expected_flags; 623111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert expected_flags.break_on_failure = true; 623211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert expected_flags.filter = "Foo*"; 623311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert expected_flags.list_tests = true; 623411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 623511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false); 623611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 623711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 623811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 623911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests current_test_info() in UnitTest. 624011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass CurrentTestInfoTest : public Test { 624111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 624211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that current_test_info() returns NULL before the first test in 624311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the test case is run. 624411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void SetUpTestCase() { 624511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // There should be no tests running at this point. 624611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info = 624711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest::GetInstance()->current_test_info(); 624811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(test_info == NULL) 624911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "There should be no tests running at this point."; 625011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 625111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 625211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Tests that current_test_info() returns NULL after the last test in 625311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the test case has run. 625411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert static void TearDownTestCase() { 625511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info = 625611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest::GetInstance()->current_test_info(); 625711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(test_info == NULL) 625811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "There should be no tests running at this point."; 625911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 626011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 626111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 626211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that current_test_info() returns TestInfo for currently running 626311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// test by checking the expected test name against the actual one. 626411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 626511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info = 626611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest::GetInstance()->current_test_info(); 626711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != test_info) 626811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "There is a test running so we should have a valid TestInfo."; 626911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 627011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Expected the name of the currently running test case."; 627111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 627211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Expected the name of the currently running test."; 627311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 627411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 627511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that current_test_info() returns TestInfo for currently running 627611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// test by checking the expected test name against the actual one. We 627711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use this test to see that the TestInfo object actually changed from 627811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the previous invocation. 627911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 628011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const TestInfo* test_info = 628111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert UnitTest::GetInstance()->current_test_info(); 628211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(NULL != test_info) 628311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "There is a test running so we should have a valid TestInfo."; 628411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 628511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Expected the name of the currently running test case."; 628611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 628711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert << "Expected the name of the currently running test."; 628811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 628911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 629011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 629111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 629211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// These two lines test that we can define tests in a namespace that 629311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// has the name "testing" and is nested in another namespace. 629411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace my_namespace { 629511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertnamespace testing { 629611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 629711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Makes sure that TEST knows to use ::testing::Test instead of 629811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::my_namespace::testing::Test. 629911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Test {}; 630011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 630111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Makes sure that an assertion knows to use ::testing::Message instead of 630211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::my_namespace::testing::Message. 630311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass Message {}; 630411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 630511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Makes sure that an assertion knows to use 630611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::testing::AssertionResult instead of 630711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ::my_namespace::testing::AssertionResult. 630811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass AssertionResult {}; 630911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 631011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that an assertion that should succeed works as expected. 631111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NestedTestingNamespaceTest, Success) { 631211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, 1) << "This shouldn't fail."; 631311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 631411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 631511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that an assertion that should fail works as expected. 631611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NestedTestingNamespaceTest, Failure) { 631711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 631811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "This failure is expected."); 631911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 632011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 632111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace testing 632211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} // namespace my_namespace 632311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 632411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that one can call superclass SetUp and TearDown methods-- 632511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that is, that they are not private. 632611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// No tests are based on this fixture; the test "passes" if it compiles 632711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// successfully. 632811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ProtectedFixtureMethodsTest : public Test { 632911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 633011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void SetUp() { 633111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::SetUp(); 633211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 633311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void TearDown() { 633411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Test::TearDown(); 633511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 633611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 633711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 633811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// StreamingAssertionsTest tests the streaming versions of a representative 633911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// sample of assertions. 634011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, Unconditional) { 634111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SUCCEED() << "expected success"; 634211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 634311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 634411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 634511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 634611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 634711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 634811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 634911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Silences warnings: "Condition is always true", "Unreachable code" 635011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option push -w-ccc -w-rch 635111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 635211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 635311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, Truth) { 635411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(true) << "unexpected failure"; 635511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(true) << "unexpected failure"; 635611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 635711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 635811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 635911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 636011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 636111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 636211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, Truth2) { 636311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(false) << "unexpected failure"; 636411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(false) << "unexpected failure"; 636511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 636611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 636711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 636811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 636911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 637011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 637111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef __BORLANDC__ 637211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Restores warnings after previous "#pragma option push" supressed them 637311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# pragma option pop 637411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 637511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 637611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, IntegerEquals) { 637711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, 1) << "unexpected failure"; 637811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(1, 1) << "unexpected failure"; 637911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 638011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 638111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 638211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 638311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 638411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 638511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, IntegerLessThan) { 638611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_LT(1, 2) << "unexpected failure"; 638711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_LT(1, 2) << "unexpected failure"; 638811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 638911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 639011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 639111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 639211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 639311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 639411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, StringsEqual) { 639511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("foo", "foo") << "unexpected failure"; 639611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STREQ("foo", "foo") << "unexpected failure"; 639711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 639811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 639911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 640011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 640111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 640211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 640311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, StringsNotEqual) { 640411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRNE("foo", "bar") << "unexpected failure"; 640511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRNE("foo", "bar") << "unexpected failure"; 640611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 640711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 640811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 640911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 641011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 641111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 641211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 641311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 641411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 641511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 641611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 641711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 641811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 641911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 642011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 642111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 642211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 642311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 642411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 642511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 642611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 642711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 642811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 642911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 643011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, FloatingPointEquals) { 643111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 643211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 643311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 643411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 643511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 643611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 643711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 643811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 643911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_HAS_EXCEPTIONS 644011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 644111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, Throw) { 644211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 644311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 644411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 644511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 644611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 644711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 644811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 644911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 645011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, NoThrow) { 645111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure"; 645211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure"; 645311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 645411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 645511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 645611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 645711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 645811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 645911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StreamingAssertionsTest, AnyThrow) { 646011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 646111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 646211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) << 646311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 646411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << 646511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure", "expected failure"); 646611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 646711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 646811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_HAS_EXCEPTIONS 646911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 647011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that Google Test correctly decides whether to use colors in the output. 647111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 647211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 647311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "yes"; 647411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 647511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); // TERM supports colors. 647611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 647711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 647811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 647911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "dumb"); // TERM doesn't support colors. 648011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 648111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 648211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 648311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 648411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 648511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "dumb"); // TERM doesn't support colors. 648611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 648711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "True"; 648811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 648911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 649011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "t"; 649111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 649211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 649311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "1"; 649411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 649511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 649611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 649711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 649811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "no"; 649911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 650011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); // TERM supports colors. 650111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 650211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 650311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 650411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "dumb"); // TERM doesn't support colors. 650511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 650611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 650711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 650811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 650911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 651011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); // TERM supports colors. 651111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 651211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "F"; 651311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 651411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 651511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "0"; 651611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 651711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 651811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "unknown"; 651911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 652011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 652111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 652211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 652311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "auto"; 652411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 652511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); // TERM supports colors. 652611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 652711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 652811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 652911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 653011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 653111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_FLAG(color) = "auto"; 653211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 653311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if GTEST_OS_WINDOWS 653411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // On Windows, we ignore the TERM variable as it's usually not set. 653511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 653611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "dumb"); 653711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 653811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 653911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", ""); 654011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 654111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 654211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); 654311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 654411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 654511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // On non-Windows platforms, we rely on TERM to determine if the 654611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // terminal supports colors. 654711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 654811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "dumb"); // TERM doesn't support colors. 654911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 655011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 655111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "emacs"); // TERM doesn't support colors. 655211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 655311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 655411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "vt100"); // TERM doesn't support colors. 655511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 655611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 655711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 655811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 655911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 656011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm"); // TERM supports colors. 656111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 656211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 656311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm-color"); // TERM supports colors. 656411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 656511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 656611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "xterm-256color"); // TERM supports colors. 656711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 656811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 656911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "screen"); // TERM supports colors. 657011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 657111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 657211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "screen-256color"); // TERM supports colors. 657311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 657411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 657511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "linux"); // TERM supports colors. 657611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 657711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 657811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SetEnv("TERM", "cygwin"); // TERM supports colors. 657911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 658011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif // GTEST_OS_WINDOWS 658111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 658211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 658311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that StaticAssertTypeEq works in a namespace scope. 658411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 658511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>(); 658611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool dummy2 GTEST_ATTRIBUTE_UNUSED_ = 658711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<const int, const int>(); 658811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 658911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that StaticAssertTypeEq works in a class. 659011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 659111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T> 659211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass StaticAssertTypeEqTestHelper { 659311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 659411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); } 659511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 659611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 659711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StaticAssertTypeEqTest, WorksInClass) { 659811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEqTestHelper<bool>(); 659911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 660011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 660111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Verifies that StaticAssertTypeEq works inside a function. 660211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 660311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef int IntAlias; 660411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 660511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(StaticAssertTypeEqTest, CompilesForEqualTypes) { 660611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<int, IntAlias>(); 660711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<int*, IntAlias*>(); 660811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 660911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 661011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) { 661111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert testing::UnitTest* const unit_test = testing::UnitTest::GetInstance(); 661211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 661311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We don't have a stack walker in Google Test yet. 661411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str()); 661511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str()); 661611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 661711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 661811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) { 661911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(HasNonfatalFailure()); 662011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 662111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 662211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic void FailFatally() { FAIL(); } 662311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 662411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) { 662511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FailFatally(); 662611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_nonfatal_failure = HasNonfatalFailure(); 662711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 662811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(has_nonfatal_failure); 662911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 663011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 663111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 663211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 663311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_nonfatal_failure = HasNonfatalFailure(); 663411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 663511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_nonfatal_failure); 663611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 663711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 663811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 663911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FailFatally(); 664011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 664111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_nonfatal_failure = HasNonfatalFailure(); 664211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 664311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_nonfatal_failure); 664411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 664511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 664611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A wrapper for calling HasNonfatalFailure outside of a test body. 664711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool HasNonfatalFailureHelper() { 664811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return testing::Test::HasNonfatalFailure(); 664911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 665011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 665111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) { 665211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(HasNonfatalFailureHelper()); 665311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 665411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 665511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) { 665611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 665711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_nonfatal_failure = HasNonfatalFailureHelper(); 665811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 665911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_nonfatal_failure); 666011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 666111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 666211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) { 666311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(HasFailure()); 666411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 666511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 666611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) { 666711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FailFatally(); 666811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_failure = HasFailure(); 666911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 667011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_failure); 667111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 667211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 667311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 667411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 667511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_failure = HasFailure(); 667611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 667711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_failure); 667811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 667911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 668011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 668111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert FailFatally(); 668211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 668311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_failure = HasFailure(); 668411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 668511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_failure); 668611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 668711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 668811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A wrapper for calling HasFailure outside of a test body. 668911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstatic bool HasFailureHelper() { return testing::Test::HasFailure(); } 669011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 669111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, WorksOutsideOfTestBody) { 669211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(HasFailureHelper()); 669311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 669411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 669511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(HasFailureTest, WorksOutsideOfTestBody2) { 669611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ADD_FAILURE(); 669711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const bool has_failure = HasFailureHelper(); 669811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ClearCurrentTestPartResults(); 669911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(has_failure); 670011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 670111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 670211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass TestListener : public EmptyTestEventListener { 670311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 670411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {} 670511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener(int* on_start_counter, bool* is_destroyed) 670611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : on_start_counter_(on_start_counter), 670711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert is_destroyed_(is_destroyed) {} 670811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 670911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual ~TestListener() { 671011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (is_destroyed_) 671111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *is_destroyed_ = true; 671211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 671311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 671411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 671511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 671611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (on_start_counter_ != NULL) 671711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*on_start_counter_)++; 671811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 671911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 672011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 672111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int* on_start_counter_; 672211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool* is_destroyed_; 672311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 672411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 672511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests the constructor. 672611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestEventListenersTest, ConstructionWorks) { 672711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 672811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 672911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL); 673011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_result_printer() == NULL); 673111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_xml_generator() == NULL); 673211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 673311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 673411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the TestEventListeners destructor deletes all the listeners it 673511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// owns. 673611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestEventListenersTest, DestructionWorks) { 673711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool default_result_printer_is_destroyed = false; 673811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool default_xml_printer_is_destroyed = false; 673911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool extra_listener_is_destroyed = false; 674011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* default_result_printer = new TestListener( 674111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL, &default_result_printer_is_destroyed); 674211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* default_xml_printer = new TestListener( 674311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL, &default_xml_printer_is_destroyed); 674411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* extra_listener = new TestListener( 674511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NULL, &extra_listener_is_destroyed); 674611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 674711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 674811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 674911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, 675011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default_result_printer); 675111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, 675211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert default_xml_printer); 675311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(extra_listener); 675411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 675511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(default_result_printer_is_destroyed); 675611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(default_xml_printer_is_destroyed); 675711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(extra_listener_is_destroyed); 675811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 675911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 676011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a listener Append'ed to a TestEventListeners list starts 676111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// receiving events. 676211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestEventListenersTest, Append) { 676311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 676411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 676511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 676611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 676711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 676811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(listener); 676911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 677011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 677111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, on_start_counter); 677211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 677311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(is_destroyed); 677411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 677511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 677611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that listeners receive events in the order they were appended to 677711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the list, except for *End requests, which must be received in the reverse 677811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// order. 677911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass SequenceTestingListener : public EmptyTestEventListener { 678011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert public: 678111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert SequenceTestingListener(std::vector<std::string>* vector, const char* id) 678211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : vector_(vector), id_(id) {} 678311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 678411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert protected: 678511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 678611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector_->push_back(GetEventDescription("OnTestProgramStart")); 678711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 678811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 678911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) { 679011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector_->push_back(GetEventDescription("OnTestProgramEnd")); 679111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 679211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 679311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, 679411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int /*iteration*/) { 679511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector_->push_back(GetEventDescription("OnTestIterationStart")); 679611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 679711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 679811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, 679911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int /*iteration*/) { 680011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vector_->push_back(GetEventDescription("OnTestIterationEnd")); 680111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 680211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 680311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert private: 680411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::string GetEventDescription(const char* method) { 680511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Message message; 680611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert message << id_ << "." << method; 680711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return message.GetString(); 680811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 680911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 681011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<std::string>* vector_; 681111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* const id_; 681211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 681311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener); 681411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 681511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 681611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, AppendKeepsOrder) { 681711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert std::vector<std::string> vec; 681811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 681911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(new SequenceTestingListener(&vec, "1st")); 682011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(new SequenceTestingListener(&vec, "2nd")); 682111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(new SequenceTestingListener(&vec, "3rd")); 682211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 682311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 682411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 682511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3U, vec.size()); 682611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str()); 682711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str()); 682811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str()); 682911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 683011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vec.clear(); 683111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd( 683211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 683311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3U, vec.size()); 683411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str()); 683511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str()); 683611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str()); 683711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 683811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vec.clear(); 683911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart( 684011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance(), 0); 684111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3U, vec.size()); 684211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str()); 684311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str()); 684411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str()); 684511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 684611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert vec.clear(); 684711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd( 684811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance(), 0); 684911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3U, vec.size()); 685011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str()); 685111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str()); 685211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str()); 685311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 685411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 685511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a listener removed from a TestEventListeners list stops receiving 685611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// events and is not deleted when the list is destroyed. 685711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(TestEventListenersTest, Release) { 685811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 685911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 686011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Although Append passes the ownership of this object to the list, 686111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the following calls release it, and we need to delete it before the 686211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test ends. 686311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 686411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 686511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 686611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(listener); 686711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(listener, listeners.Release(listener)); 686811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 686911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 687011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.Release(listener) == NULL); 687111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 687211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, on_start_counter); 687311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(is_destroyed); 687411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete listener; 687511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 687611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 687711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that no events are forwarded when event forwarding is disabled. 687811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, SuppressEventForwarding) { 687911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 688011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, NULL); 688111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 688211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 688311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert listeners.Append(listener); 688411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 688511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SuppressEventForwarding(&listeners); 688611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 688711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 688811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 688911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, on_start_counter); 689011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 689111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 689211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that events generated by Google Test are not forwarded in 689311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// death test subprocesses. 689411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) { 689511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_DEATH_IF_SUPPORTED({ 689611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled( 689711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *GetUnitTestImpl()->listeners())) << "expected failure";}, 689811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "expected failure"); 689911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 690011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 690111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a listener installed via SetDefaultResultPrinter() starts 690211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// receiving events and is returned via default_result_printer() and that 690311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the previous default_result_printer is removed from the list and deleted. 690411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, default_result_printer) { 690511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 690611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 690711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 690811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 690911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 691011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 691111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 691211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(listener, listeners.default_result_printer()); 691311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 691411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 691511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 691611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 691711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, on_start_counter); 691811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 691911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Replacing default_result_printer with something else should remove it 692011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // from the list and destroy it. 692111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL); 692211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 692311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_result_printer() == NULL); 692411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(is_destroyed); 692511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 692611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // After broadcasting an event the counter is still the same, indicating 692711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the listener is not in the list anymore. 692811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 692911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 693011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, on_start_counter); 693111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 693211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 693311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the default_result_printer listener stops receiving events 693411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// when removed via Release and that is not owned by the list anymore. 693511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, RemovingDefaultResultPrinterWorks) { 693611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 693711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 693811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Although Append passes the ownership of this object to the list, 693911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the following calls release it, and we need to delete it before the 694011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test ends. 694111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 694211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 694311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 694411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 694511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 694611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(listener, listeners.Release(listener)); 694711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_result_printer() == NULL); 694811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(is_destroyed); 694911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 695011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Broadcasting events now should not affect default_result_printer. 695111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 695211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 695311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, on_start_counter); 695411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 695511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Destroying the list should not affect the listener now, too. 695611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(is_destroyed); 695711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete listener; 695811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 695911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 696011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that a listener installed via SetDefaultXmlGenerator() starts 696111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// receiving events and is returned via default_xml_generator() and that 696211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the previous default_xml_generator is removed from the list and deleted. 696311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, default_xml_generator) { 696411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 696511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 696611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 696711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 696811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 696911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 697011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 697111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(listener, listeners.default_xml_generator()); 697211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 697311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 697411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 697511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 697611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, on_start_counter); 697711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 697811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Replacing default_xml_generator with something else should remove it 697911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // from the list and destroy it. 698011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL); 698111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 698211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_xml_generator() == NULL); 698311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(is_destroyed); 698411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 698511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // After broadcasting an event the counter is still the same, indicating 698611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the listener is not in the list anymore. 698711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 698811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 698911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, on_start_counter); 699011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 699111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 699211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that the default_xml_generator listener stops receiving events 699311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// when removed via Release and that is not owned by the list anymore. 699411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) { 699511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int on_start_counter = 0; 699611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool is_destroyed = false; 699711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Although Append passes the ownership of this object to the list, 699811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // the following calls release it, and we need to delete it before the 699911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // test ends. 700011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 700111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { 700211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListeners listeners; 700311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 700411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 700511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(listener, listeners.Release(listener)); 700611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(listeners.default_xml_generator() == NULL); 700711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(is_destroyed); 700811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 700911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Broadcasting events now should not affect default_xml_generator. 701011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 701111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *UnitTest::GetInstance()); 701211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, on_start_counter); 701311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 701411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Destroying the list should not affect the listener now, too. 701511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(is_destroyed); 701611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete listener; 701711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 701811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 701911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Sanity tests to ensure that the alternative, verbose spellings of 702011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// some of the macros work. We don't test them thoroughly as that 702111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// would be quite involved. Since their implementations are 702211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// straightforward, and they are rarely used, we'll just rely on the 702311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// users to tell us when they are broken. 702411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertGTEST_TEST(AlternativeNameTest, Works) { // GTEST_TEST is the same as TEST. 702511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_SUCCEED() << "OK"; // GTEST_SUCCEED is the same as SUCCEED. 702611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 702711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // GTEST_FAIL is the same as FAIL. 702811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure", 702911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 703011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 703111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // GTEST_ASSERT_XY is the same as ASSERT_XY. 703211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 703311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_EQ(0, 0); 703411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure", 703511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 703611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure", 703711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 703811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 703911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_NE(0, 1); 704011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_NE(1, 0); 704111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure", 704211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 704311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 704411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_LE(0, 0); 704511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_LE(0, 1); 704611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure", 704711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 704811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 704911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_LT(0, 1); 705011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure", 705111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 705211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure", 705311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 705411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 705511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_GE(0, 0); 705611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_GE(1, 0); 705711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure", 705811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 705911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 706011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_ASSERT_GT(1, 0); 706111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure", 706211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 706311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure", 706411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert "An expected failure"); 706511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 706611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 706711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests for internal utilities necessary for implementation of the universal 706811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// printing. 706911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// TODO(vladl@google.com): Find a better home for them. 707011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 707111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ConversionHelperBase {}; 707211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass ConversionHelperDerived : public ConversionHelperBase {}; 707311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 707411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsAProtocolMessage<T>::value is a compile-time constant. 707511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) { 707611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value, 707711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const_true); 707811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false); 707911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 708011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 708111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsAProtocolMessage<T>::value is true when T is 708211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// proto2::Message or a sub-class of it. 708311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) { 708411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value); 708511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value); 708611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 708711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 708811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that IsAProtocolMessage<T>::value is false when T is neither 708911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ProtocolMessage nor a sub-class of it. 709011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) { 709111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsAProtocolMessage<int>::value); 709211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value); 709311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 709411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 709511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that CompileAssertTypesEqual compiles when the type arguments are 709611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// equal. 709711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) { 709811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<void, void>(); 709911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int*, int*>(); 710011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 710111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 710211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that RemoveReference does not affect non-reference types. 710311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) { 710411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int, RemoveReference<int>::type>(); 710511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<const char, RemoveReference<const char>::type>(); 710611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 710711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 710811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that RemoveReference removes reference from reference types. 710911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveReferenceTest, RemovesReference) { 711011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int, RemoveReference<int&>::type>(); 711111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>(); 711211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 711311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 711411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GTEST_REMOVE_REFERENCE_. 711511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 711611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 711711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestGTestRemoveReference() { 711811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>(); 711911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 712011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 712111cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveReferenceTest, MacroVersion) { 712211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReference<int, int>(); 712311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReference<const char, const char&>(); 712411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 712511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 712611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 712711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that RemoveConst does not affect non-const types. 712811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveConstTest, DoesNotAffectNonConstType) { 712911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int, RemoveConst<int>::type>(); 713011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<char&, RemoveConst<char&>::type>(); 713111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 713211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 713311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that RemoveConst removes const from const types. 713411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveConstTest, RemovesConst) { 713511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int, RemoveConst<const int>::type>(); 713611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>(); 713711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>(); 713811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 713911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 714011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GTEST_REMOVE_CONST_. 714111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 714211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 714311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestGTestRemoveConst() { 714411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>(); 714511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 714611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 714711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveConstTest, MacroVersion) { 714811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveConst<int, int>(); 714911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveConst<double&, double&>(); 715011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveConst<char, const char>(); 715111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 715211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 715311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GTEST_REMOVE_REFERENCE_AND_CONST_. 715411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 715511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 715611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestGTestRemoveReferenceAndConst() { 715711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>(); 715811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 715911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 716011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(RemoveReferenceToConstTest, Works) { 716111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReferenceAndConst<int, int>(); 716211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReferenceAndConst<double, double&>(); 716311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReferenceAndConst<char, const char>(); 716411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReferenceAndConst<char, const char&>(); 716511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestRemoveReferenceAndConst<const char*, const char*>(); 716611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 716711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 716811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that AddReference does not affect reference types. 716911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AddReferenceTest, DoesNotAffectReferenceType) { 717011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int&, AddReference<int&>::type>(); 717111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<const char&, AddReference<const char&>::type>(); 717211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 717311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 717411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that AddReference adds reference to non-reference types. 717511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AddReferenceTest, AddsReference) { 717611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<int&, AddReference<int>::type>(); 717711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<const char&, AddReference<const char>::type>(); 717811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 717911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 718011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GTEST_ADD_REFERENCE_. 718111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 718211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 718311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestGTestAddReference() { 718411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>(); 718511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 718611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 718711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(AddReferenceTest, MacroVersion) { 718811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestAddReference<int&, int>(); 718911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestAddReference<const char&, const char&>(); 719011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 719111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 719211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests GTEST_REFERENCE_TO_CONST_. 719311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 719411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <typename T1, typename T2> 719511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid TestGTestReferenceToConst() { 719611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>(); 719711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 719811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 719911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(GTestReferenceToConstTest, Works) { 720011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestReferenceToConst<const char&, char>(); 720111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestReferenceToConst<const int&, const int>(); 720211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestReferenceToConst<const double&, double>(); 720311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert TestGTestReferenceToConst<const std::string&, const std::string&>(); 720411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 720511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 720611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant. 720711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) { 720811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true); 720911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value), 721011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const_false); 721111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 721211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 721311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can 721411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be implicitly converted to T2. 721511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) { 721611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<int, double>::value)); 721711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<double, int>::value)); 721811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value)); 721911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value)); 722011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&, 722111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ConversionHelperBase&>::value)); 722211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase, 722311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ConversionHelperBase>::value)); 722411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 722511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 722611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1 722711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// cannot be implicitly converted to T2. 722811cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) { 722911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value)); 723011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value)); 723111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value)); 723211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&, 723311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ConversionHelperDerived&>::value)); 723411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 723511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 723611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests IsContainerTest. 723711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 723811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass NonContainer {}; 723911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 724011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsContainerTestTest, WorksForNonContainer) { 724111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0))); 724211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0))); 724311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0))); 724411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 724511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 724611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(IsContainerTestTest, WorksForContainer) { 724711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(IsContainer), 724811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sizeof(IsContainerTest<std::vector<bool> >(0))); 724911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(sizeof(IsContainer), 725011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sizeof(IsContainerTest<std::map<int, double> >(0))); 725111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 725211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 725311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ArrayEq(). 725411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 725511cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ArrayEqTest, WorksForDegeneratedArrays) { 725611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(5, 5L)); 725711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ArrayEq('a', 0)); 725811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 725911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 726011cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ArrayEqTest, WorksForOneDimensionalArrays) { 726111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Note that a and b are distinct but compatible types. 726211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int a[] = { 0, 1 }; 726311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long b[] = { 0, 1 }; 726411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, b)); 726511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, 2, b)); 726611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 726711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert b[0] = 2; 726811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ArrayEq(a, b)); 726911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ArrayEq(a, 1, b)); 727011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 727111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 727211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ArrayEqTest, WorksForTwoDimensionalArrays) { 727311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char a[][3] = { "hi", "lo" }; 727411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char b[][3] = { "hi", "lo" }; 727511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char c[][3] = { "hi", "li" }; 727611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 727711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, b)); 727811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, 2, b)); 727911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 728011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ArrayEq(a, c)); 728111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(ArrayEq(a, 2, c)); 728211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 728311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 728411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests ArrayAwareFind(). 728511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 728611cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ArrayAwareFindTest, WorksForOneDimensionalArray) { 728711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char a[] = "hello"; 728811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o')); 728911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x')); 729011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 729111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 729211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) { 729311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } }; 729411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int b[2] = { 2, 3 }; 729511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b)); 729611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 729711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int c[2] = { 6, 7 }; 729811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c)); 729911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 730011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 730111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests CopyArray(). 730211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 730311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CopyArrayTest, WorksForDegeneratedArrays) { 730411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int n = 0; 730511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CopyArray('a', &n); 730611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ('a', n); 730711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 730811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 730911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CopyArrayTest, WorksForOneDimensionalArrays) { 731011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char a[3] = "hi"; 731111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int b[3]; 731211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions. 731311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CopyArray(a, &b); 731411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, b)); 731511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 731611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 731711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int c[3]; 731811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CopyArray(a, 3, c); 731911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, c)); 732011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 732111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 732211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(CopyArrayTest, WorksForTwoDimensionalArrays) { 732311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; 732411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int b[2][3]; 732511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions. 732611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CopyArray(a, &b); 732711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, b)); 732811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 732911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 733011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int c[2][3]; 733111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert CopyArray(a, 2, c); 733211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(ArrayEq(a, c)); 733311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 733411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 733511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests NativeArray. 733611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 733711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NativeArrayTest, ConstructorFromArrayWorks) { 733811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int a[3] = { 0, 1, 2 }; 733911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<int> na(a, 3, kReference); 734011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3U, na.size()); 734111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a, na.begin()); 734211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 734311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 734411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) { 734511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef int Array[2]; 734611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert Array* a = new Array[1]; 734711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*a)[0] = 0; 734811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*a)[1] = 1; 734911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<int> na(*a, 2, kCopy); 735011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_NE(*a, na.begin()); 735111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert delete[] a; 735211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, na.begin()[0]); 735311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, na.begin()[1]); 735411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 735511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We rely on the heap checker to verify that na deletes the copy of 735611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // array. 735711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 735811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 735911cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NativeArrayTest, TypeMembersAreCorrect) { 736011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<char, NativeArray<char>::value_type>(); 736111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>(); 736211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 736311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>(); 736411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>(); 736511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 736611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 736711cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NativeArrayTest, MethodsWork) { 736811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int a[3] = { 0, 1, 2 }; 736911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<int> na(a, 3, kCopy); 737011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(3U, na.size()); 737111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(3, na.end() - na.begin()); 737211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 737311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<int>::const_iterator it = na.begin(); 737411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(0, *it); 737511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++it; 737611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(1, *it); 737711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert it++; 737811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(2, *it); 737911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++it; 738011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(na.end(), it); 738111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 738211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(na == na); 738311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 738411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<int> na2(a, 3, kReference); 738511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(na == na2); 738611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 738711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int b1[3] = { 0, 1, 1 }; 738811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const int b2[4] = { 0, 1, 2, 3 }; 738911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(na == NativeArray<int>(b1, 3, kReference)); 739011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(na == NativeArray<int>(b2, 4, kCopy)); 739111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 739211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 739311cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(NativeArrayTest, WorksForTwoDimensionalArray) { 739411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char a[2][3] = { "hi", "lo" }; 739511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert NativeArray<char[3]> na(a, 2, kReference); 739611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ASSERT_EQ(2U, na.size()); 739711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(a, na.begin()); 739811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 739911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 740011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Tests SkipPrefix(). 740111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 740211cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SkipPrefixTest, SkipsWhenPrefixMatches) { 740311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* const str = "hello"; 740411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 740511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* p = str; 740611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(SkipPrefix("", &p)); 740711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(str, p); 740811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 740911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert p = str; 741011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_TRUE(SkipPrefix("hell", &p)); 741111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(str + 4, p); 741211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 741311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 741411cd02dfb91661c65134cac258cf5924270e9d2Dan AlbertTEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) { 741511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* const str = "world"; 741611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 741711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char* p = str; 741811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(SkipPrefix("W", &p)); 741911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(str, p); 742011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 742111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert p = str; 742211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_FALSE(SkipPrefix("world!", &p)); 742311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert EXPECT_EQ(str, p); 742411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 7425