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