1d201456903f3ecae1f7794edfab0d5678e64226shiqian// Copyright 2005, Google Inc. 2d201456903f3ecae1f7794edfab0d5678e64226shiqian// All rights reserved. 3d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4d201456903f3ecae1f7794edfab0d5678e64226shiqian// Redistribution and use in source and binary forms, with or without 5d201456903f3ecae1f7794edfab0d5678e64226shiqian// modification, are permitted provided that the following conditions are 6d201456903f3ecae1f7794edfab0d5678e64226shiqian// met: 7d201456903f3ecae1f7794edfab0d5678e64226shiqian// 8d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions of source code must retain the above copyright 9d201456903f3ecae1f7794edfab0d5678e64226shiqian// notice, this list of conditions and the following disclaimer. 10d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Redistributions in binary form must reproduce the above 11d201456903f3ecae1f7794edfab0d5678e64226shiqian// copyright notice, this list of conditions and the following disclaimer 12d201456903f3ecae1f7794edfab0d5678e64226shiqian// in the documentation and/or other materials provided with the 13d201456903f3ecae1f7794edfab0d5678e64226shiqian// distribution. 14d201456903f3ecae1f7794edfab0d5678e64226shiqian// * Neither the name of Google Inc. nor the names of its 15d201456903f3ecae1f7794edfab0d5678e64226shiqian// contributors may be used to endorse or promote products derived from 16d201456903f3ecae1f7794edfab0d5678e64226shiqian// this software without specific prior written permission. 17d201456903f3ecae1f7794edfab0d5678e64226shiqian// 18d201456903f3ecae1f7794edfab0d5678e64226shiqian// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19d201456903f3ecae1f7794edfab0d5678e64226shiqian// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21d201456903f3ecae1f7794edfab0d5678e64226shiqian// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22d201456903f3ecae1f7794edfab0d5678e64226shiqian// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23d201456903f3ecae1f7794edfab0d5678e64226shiqian// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24d201456903f3ecae1f7794edfab0d5678e64226shiqian// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25d201456903f3ecae1f7794edfab0d5678e64226shiqian// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26d201456903f3ecae1f7794edfab0d5678e64226shiqian// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27d201456903f3ecae1f7794edfab0d5678e64226shiqian// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28d201456903f3ecae1f7794edfab0d5678e64226shiqian// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29d201456903f3ecae1f7794edfab0d5678e64226shiqian// 30d201456903f3ecae1f7794edfab0d5678e64226shiqian// Author: wan@google.com (Zhanyong Wan) 31d201456903f3ecae1f7794edfab0d5678e64226shiqian// 32d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for Google Test itself. This verifies that the basic constructs of 33d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test work. 34d201456903f3ecae1f7794edfab0d5678e64226shiqian 35dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest.h" 36ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 37ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Verifies that the command line flag variables can be accessed 38ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// in code once <gtest/gtest.h> has been #included. 39ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan// Do not move it after other #includes. 40ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wanTEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { 41ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) 42ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(break_on_failure) 43ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(catch_exceptions) 44ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(color) != "unknown" 45ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(filter) != "unknown" 46ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(list_tests) 47ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(output) != "unknown" 48ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(print_time) 498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(random_seed) 50ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(repeat) > 0 51ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan || testing::GTEST_FLAG(show_internal_stack_frames) 528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan || testing::GTEST_FLAG(shuffle) 5340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(stack_trace_depth) > 0 54a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan || testing::GTEST_FLAG(stream_result_to) != "unknown" 5540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan || testing::GTEST_FLAG(throw_on_failure); 56ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan EXPECT_TRUE(dummy || !dummy); // Suppresses warning that dummy is unused. 57ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan} 58ad99ca14461f0e929d835d29518e11c05e8d41f0zhanyong.wan 598965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <limits.h> // For INT_MAX. 608965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <stdlib.h> 618965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <string.h> 628965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <time.h> 638965a6a0d2165f32e6413594bba6367f271f51e7vladlosev 648965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <map> 658965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <vector> 668965a6a0d2165f32e6413594bba6367f271f51e7vladlosev#include <ostream> 678965a6a0d2165f32e6413594bba6367f271f51e7vladlosev 68dac3e879c56a50696a36f53e1e5e353e48fa665fzhanyong.wan#include "gtest/gtest-spi.h" 69d201456903f3ecae1f7794edfab0d5678e64226shiqian 70d201456903f3ecae1f7794edfab0d5678e64226shiqian// Indicates that this translation unit is part of Google Test's 71d201456903f3ecae1f7794edfab0d5678e64226shiqian// implementation. It must come before gtest-internal-inl.h is 72d201456903f3ecae1f7794edfab0d5678e64226shiqian// included, or there will be a compiler error. This trick is to 73d201456903f3ecae1f7794edfab0d5678e64226shiqian// prevent a user from accidentally including gtest-internal-inl.h in 74d201456903f3ecae1f7794edfab0d5678e64226shiqian// his code. 750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#define GTEST_IMPLEMENTATION_ 1 76d201456903f3ecae1f7794edfab0d5678e64226shiqian#include "src/gtest-internal-inl.h" 770af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#undef GTEST_IMPLEMENTATION_ 78d201456903f3ecae1f7794edfab0d5678e64226shiqian 79d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 80d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace internal { 81b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 82ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak#if GTEST_CAN_STREAM_RESULTS_ 83ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 84ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakclass StreamingListenerTest : public Test { 85ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak public: 86ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak class FakeSocketWriter : public StreamingListener::AbstractSocketWriter { 87ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak public: 88ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak // Sends a string to the socket. 89ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak virtual void Send(const string& message) { output_ += message; } 90ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 91ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak string output_; 92ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak }; 93ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 94ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak StreamingListenerTest() 95ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak : fake_sock_writer_(new FakeSocketWriter), 96ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_(fake_sock_writer_), 974f8dc917ebce062f75defee3d4890bbcd07e277bkosak test_info_obj_("FooTest", "Bar", NULL, NULL, 984f8dc917ebce062f75defee3d4890bbcd07e277bkosak CodeLocation(__FILE__, __LINE__), 0, NULL) {} 99ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 100ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak protected: 101ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak string* output() { return &(fake_sock_writer_->output_); } 102ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 103ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak FakeSocketWriter* const fake_sock_writer_; 104ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak StreamingListener streamer_; 105ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak UnitTest unit_test_; 106ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak TestInfo test_info_obj_; // The name test_info_ was taken by testing::Test. 107ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak}; 108ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 109ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestProgramEnd) { 110ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 111ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestProgramEnd(unit_test_); 112ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestProgramEnd&passed=1\n", *output()); 113ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 114ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 115ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestIterationEnd) { 116ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 117ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestIterationEnd(unit_test_, 42); 118ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestIterationEnd&passed=1&elapsed_time=0ms\n", *output()); 119ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 120ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 121ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestCaseStart) { 122ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 123ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestCaseStart(TestCase("FooTest", "Bar", NULL, NULL)); 124ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestCaseStart&name=FooTest\n", *output()); 125ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 126ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 127ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestCaseEnd) { 128ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 129ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestCaseEnd(TestCase("FooTest", "Bar", NULL, NULL)); 130ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestCaseEnd&passed=1&elapsed_time=0ms\n", *output()); 131ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 132ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 133ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestStart) { 134ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 135ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestStart(test_info_obj_); 136ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestStart&name=Bar\n", *output()); 137ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 138ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 139ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestEnd) { 140ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 141ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestEnd(test_info_obj_); 142ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ("event=TestEnd&passed=1&elapsed_time=0ms\n", *output()); 143ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 144ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 145ba072ccca41212e3ac3ac1eca3381d226187c0d1kosakTEST_F(StreamingListenerTest, OnTestPartResult) { 146ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output() = ""; 147ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak streamer_.OnTestPartResult(TestPartResult( 148ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak TestPartResult::kFatalFailure, "foo.cc", 42, "failed=\n&%")); 149ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 150ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak // Meta characters in the failure message should be properly escaped. 151ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak EXPECT_EQ( 152ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak "event=TestPartResult&file=foo.cc&line=42&message=failed%3D%0A%26%25\n", 153ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak *output()); 154ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak} 155ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 156ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak#endif // GTEST_CAN_STREAM_RESULTS_ 157ba072ccca41212e3ac3ac1eca3381d226187c0d1kosak 158f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Provides access to otherwise private parts of the TestEventListeners class 15916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// that are needed to test it. 160f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanclass TestEventListenersAccessor { 16116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 162f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static TestEventListener* GetRepeater(TestEventListeners* listeners) { 163b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan return listeners->repeater(); 164b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan } 16516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 166f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SetDefaultResultPrinter(TestEventListeners* listeners, 167b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan TestEventListener* listener) { 16816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SetDefaultResultPrinter(listener); 16916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 170f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SetDefaultXmlGenerator(TestEventListeners* listeners, 171b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan TestEventListener* listener) { 17216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SetDefaultXmlGenerator(listener); 17316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 17416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 175f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static bool EventForwardingEnabled(const TestEventListeners& listeners) { 17616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan return listeners.EventForwardingEnabled(); 17716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 17816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 179f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan static void SuppressEventForwarding(TestEventListeners* listeners) { 18016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners->SuppressEventForwarding(); 18116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 18216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 18316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 184f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevclass UnitTestRecordPropertyTestHelper : public Test { 185f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev protected: 186f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordPropertyTestHelper() {} 187f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 188f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev // Forwards to UnitTest::RecordProperty() to bypass access controls. 189f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev void UnitTestRecordProperty(const char* key, const std::string& value) { 190f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.RecordProperty(key, value); 191f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev } 192f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 193f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTest unit_test_; 194f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev}; 195f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 196d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace internal 197d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 198d201456903f3ecae1f7794edfab0d5678e64226shiqian 1999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionFailure; 2009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionResult; 2019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::AssertionSuccess; 2029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::DoubleLE; 203b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::EmptyTestEventListener; 204f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevusing testing::Environment; 2059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::FloatLE; 206fe186c382905dcf57014985ccea8e067275e9f5fshiqianusing testing::GTEST_FLAG(also_run_disabled_tests); 2079b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(break_on_failure); 2089b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(catch_exceptions); 209d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::GTEST_FLAG(color); 210c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::GTEST_FLAG(death_test_use_fork); 2119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(filter); 2129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(list_tests); 2139b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(output); 2149b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(print_time); 2158bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(random_seed); 2169b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(repeat); 2179b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(show_internal_stack_frames); 2188bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::GTEST_FLAG(shuffle); 2199b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::GTEST_FLAG(stack_trace_depth); 220a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wanusing testing::GTEST_FLAG(stream_result_to); 22140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanusing testing::GTEST_FLAG(throw_on_failure); 2229b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsNotSubstring; 2239b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::IsSubstring; 2249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::Message; 225d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::ScopedFakeTestPartResultReporter; 22653e0dc4041f660b6517b15b08b496e164be614f1shiqianusing testing::StaticAssertTypeEq; 227c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::Test; 228b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestCase; 2292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::TestEventListeners; 230f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevusing testing::TestInfo; 231c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::TestPartResult; 232c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::TestPartResultArray; 233b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestProperty; 234b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::TestResult; 235431a8be1662a3bc9601240914f412b0436d94703vladlosevusing testing::TimeInMillis; 236d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::UnitTest; 2372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::AddReference; 238f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysFalse; 239f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::AlwaysTrue; 240d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::AppendUserMessage; 2412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ArrayAwareFind; 2422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ArrayEq; 2430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::CodePointToUtf8; 2442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::CompileAssertTypesEqual; 2452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::CopyArray; 2460d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::CountIf; 247d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::EqFailure; 2489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::FloatingPoint; 2490d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::ForEach; 250431a8be1662a3bc9601240914f412b0436d94703vladlosevusing testing::internal::FormatEpochTimeInMillisAsIso8601; 2512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::FormatTimeInMillisAsSeconds; 252c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::internal::GTestFlagSaver; 2533d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevusing testing::internal::GetCurrentOsStackTraceExceptTop; 2540d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::GetElementOr; 2558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetNextRandomSeed; 2568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanusing testing::internal::GetRandomSeedFromFlag; 257c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTestTypeId; 258431a8be1662a3bc9601240914f412b0436d94703vladlosevusing testing::internal::GetTimeInMillis; 259c440a6923aa65d5be64134a6f430a5867a63df3fshiqianusing testing::internal::GetTypeId; 260aaebfcdc4005afb22b68df61b58edd1ccc002913zhanyong.wanusing testing::internal::GetUnitTestImpl; 2612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::ImplicitlyConvertible; 262d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::Int32; 263cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::Int32FromEnvOrDie; 2642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsAProtocolMessage; 2652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsContainer; 2662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsContainerTest; 2672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::IsNotContainer; 2682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::NativeArray; 269f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::ParseInt32Flag; 2708120f66c3249e253f03fdb48bee7e528bc038d31billydonahueusing testing::internal::RelationToSourceCopy; 2718120f66c3249e253f03fdb48bee7e528bc038d31billydonahueusing testing::internal::RelationToSourceReference; 2722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::RemoveConst; 2732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanusing testing::internal::RemoveReference; 274cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldRunTestOnShard; 275cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanusing testing::internal::ShouldShard; 276d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::ShouldUseColor; 2770d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::Shuffle; 2780d27868d0faef474594682f25336229daa89d6d7zhanyong.wanusing testing::internal::ShuffleRange; 279985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanusing testing::internal::SkipPrefix; 280d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::StreamableToString; 281d201456903f3ecae1f7794edfab0d5678e64226shiqianusing testing::internal::String; 282f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanusing testing::internal::TestEventListenersAccessor; 283b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanusing testing::internal::TestResultAccessor; 2842534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanusing testing::internal::UInt32; 2850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevusing testing::internal::WideStringToUtf8; 286b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakusing testing::internal::edit_distance::CalculateOptimalEdits; 287b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakusing testing::internal::edit_distance::CreateUnifiedDiff; 288b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakusing testing::internal::edit_distance::EditType; 289b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wanusing testing::internal::kMaxRandomSeed; 290c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanusing testing::internal::kTestTypeIdInGoogleTest; 2918120f66c3249e253f03fdb48bee7e528bc038d31billydonahueusing testing::kMaxStackTraceDepth; 292d201456903f3ecae1f7794edfab0d5678e64226shiqian 29335c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 29481e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wanusing testing::internal::CaptureStdout; 29581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wanusing testing::internal::GetCapturedStdout; 29635c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 29781e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 29812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 29912a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wanusing testing::internal::ThreadWithParam; 30012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif 30112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan 3020d27868d0faef474594682f25336229daa89d6d7zhanyong.wanclass TestingVector : public std::vector<int> { 303bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan}; 304bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 305bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan::std::ostream& operator<<(::std::ostream& os, 306bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const TestingVector& vector) { 307bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan os << "{ "; 3080d27868d0faef474594682f25336229daa89d6d7zhanyong.wan for (size_t i = 0; i < vector.size(); i++) { 3090d27868d0faef474594682f25336229daa89d6d7zhanyong.wan os << vector[i] << " "; 310bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 311bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan os << "}"; 312bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return os; 313bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 314bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 315d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in an unnamed namespace. 316d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 317d201456903f3ecae1f7794edfab0d5678e64226shiqian 3188bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, HandlesZero) { 3198bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed = GetRandomSeedFromFlag(0); 3208bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed); 3218bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed, static_cast<int>(kMaxRandomSeed)); 3228bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 3238bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 3248bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, PreservesValidSeed) { 3258bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetRandomSeedFromFlag(1)); 3268bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetRandomSeedFromFlag(2)); 3278bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(kMaxRandomSeed - 1, GetRandomSeedFromFlag(kMaxRandomSeed - 1)); 3288bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 3298bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetRandomSeedFromFlag(kMaxRandomSeed)); 3308bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 3318bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 3328bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetRandomSeedFromFlagTest, NormalizesInvalidSeed) { 3338bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed1 = GetRandomSeedFromFlag(-1); 3348bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed1); 3358bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed1, static_cast<int>(kMaxRandomSeed)); 3368bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 3378bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const int seed2 = GetRandomSeedFromFlag(kMaxRandomSeed + 1); 3388bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(1, seed2); 3398bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_LE(seed2, static_cast<int>(kMaxRandomSeed)); 3408bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 3418bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 3428bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST(GetNextRandomSeedTest, WorksForValidInput) { 3438bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(2, GetNextRandomSeed(1)); 3448bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(3, GetNextRandomSeed(2)); 3458bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(static_cast<int>(kMaxRandomSeed), 3468bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GetNextRandomSeed(kMaxRandomSeed - 1)); 3478bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(1, GetNextRandomSeed(kMaxRandomSeed)); 3488bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 3498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // We deliberately don't test GetNextRandomSeed() with invalid 3508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // inputs, as that requires death tests, which are expensive. This 3518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // is fine as GetNextRandomSeed() is internal and has a 3528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // straightforward definition. 3538bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 3548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 355b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wanstatic void ClearCurrentTestPartResults() { 356b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan TestResultAccessor::ClearTestPartResults( 357b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetUnitTestImpl()->current_test_result()); 358b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan} 359b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 360c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Tests GetTypeId. 361c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 362c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsSameValueForSameType) { 363c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<int>(), GetTypeId<int>()); 364c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(GetTypeId<Test>(), GetTypeId<Test>()); 365c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 366c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 367c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass SubClassOfTest : public Test {}; 368c440a6923aa65d5be64134a6f430a5867a63df3fshiqianclass AnotherSubClassOfTest : public Test {}; 369c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 370c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTypeIdTest, ReturnsDifferentValuesForDifferentTypes) { 371c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<const int>()); 372c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTypeId<char>()); 373c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<int>(), GetTestTypeId()); 374c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<SubClassOfTest>(), GetTestTypeId()); 375c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTestTypeId()); 376c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_NE(GetTypeId<AnotherSubClassOfTest>(), GetTypeId<SubClassOfTest>()); 377c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 378c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 379c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// Verifies that GetTestTypeId() returns the same value, no matter it 380c440a6923aa65d5be64134a6f430a5867a63df3fshiqian// is called from inside Google Test or outside of it. 381c440a6923aa65d5be64134a6f430a5867a63df3fshiqianTEST(GetTestTypeIdTest, ReturnsTheSameValueInsideOrOutsideOfGoogleTest) { 382c440a6923aa65d5be64134a6f430a5867a63df3fshiqian EXPECT_EQ(kTestTypeIdInGoogleTest, GetTestTypeId()); 383c440a6923aa65d5be64134a6f430a5867a63df3fshiqian} 384c440a6923aa65d5be64134a6f430a5867a63df3fshiqian 38564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian// Tests FormatTimeInMillisAsSeconds(). 38664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 38764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsZero) { 388e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0", FormatTimeInMillisAsSeconds(0)); 38964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 39064cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 39164cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsPositiveNumber) { 392e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.003", FormatTimeInMillisAsSeconds(3)); 393e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.01", FormatTimeInMillisAsSeconds(10)); 394e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("0.2", FormatTimeInMillisAsSeconds(200)); 395e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("1.2", FormatTimeInMillisAsSeconds(1200)); 396e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("3", FormatTimeInMillisAsSeconds(3000)); 39764cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 39864cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 39964cdcb69b28fc26e78d95c574187f7dd9830c84cshiqianTEST(FormatTimeInMillisAsSecondsTest, FormatsNegativeNumber) { 400e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.003", FormatTimeInMillisAsSeconds(-3)); 401e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.01", FormatTimeInMillisAsSeconds(-10)); 402e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-0.2", FormatTimeInMillisAsSeconds(-200)); 403e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-1.2", FormatTimeInMillisAsSeconds(-1200)); 404e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_EQ("-3", FormatTimeInMillisAsSeconds(-3000)); 40564cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian} 40664cdcb69b28fc26e78d95c574187f7dd9830c84cshiqian 407431a8be1662a3bc9601240914f412b0436d94703vladlosev// Tests FormatEpochTimeInMillisAsIso8601(). The correctness of conversion 408431a8be1662a3bc9601240914f412b0436d94703vladlosev// for particular dates below was verified in Python using 409431a8be1662a3bc9601240914f412b0436d94703vladlosev// datetime.datetime.fromutctimestamp(<timetamp>/1000). 410431a8be1662a3bc9601240914f412b0436d94703vladlosev 411431a8be1662a3bc9601240914f412b0436d94703vladlosev// FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we 412431a8be1662a3bc9601240914f412b0436d94703vladlosev// have to set up a particular timezone to obtain predictable results. 413431a8be1662a3bc9601240914f412b0436d94703vladlosevclass FormatEpochTimeInMillisAsIso8601Test : public Test { 414431a8be1662a3bc9601240914f412b0436d94703vladlosev public: 415431a8be1662a3bc9601240914f412b0436d94703vladlosev // On Cygwin, GCC doesn't allow unqualified integer literals to exceed 416431a8be1662a3bc9601240914f412b0436d94703vladlosev // 32 bits, even when 64-bit integer types are available. We have to 417431a8be1662a3bc9601240914f412b0436d94703vladlosev // force the constants to have a 64-bit type here. 418431a8be1662a3bc9601240914f412b0436d94703vladlosev static const TimeInMillis kMillisPerSec = 1000; 419431a8be1662a3bc9601240914f412b0436d94703vladlosev 420431a8be1662a3bc9601240914f412b0436d94703vladlosev private: 421431a8be1662a3bc9601240914f412b0436d94703vladlosev virtual void SetUp() { 422431a8be1662a3bc9601240914f412b0436d94703vladlosev saved_tz_ = NULL; 4238120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 4248120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* getenv, strdup: deprecated */) 425431a8be1662a3bc9601240914f412b0436d94703vladlosev if (getenv("TZ")) 426431a8be1662a3bc9601240914f412b0436d94703vladlosev saved_tz_ = strdup(getenv("TZ")); 4278120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_POP_() 428431a8be1662a3bc9601240914f412b0436d94703vladlosev 429431a8be1662a3bc9601240914f412b0436d94703vladlosev // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We 430431a8be1662a3bc9601240914f412b0436d94703vladlosev // cannot use the local time zone because the function's output depends 431431a8be1662a3bc9601240914f412b0436d94703vladlosev // on the time zone. 432431a8be1662a3bc9601240914f412b0436d94703vladlosev SetTimeZone("UTC+00"); 433431a8be1662a3bc9601240914f412b0436d94703vladlosev } 434431a8be1662a3bc9601240914f412b0436d94703vladlosev 435431a8be1662a3bc9601240914f412b0436d94703vladlosev virtual void TearDown() { 436431a8be1662a3bc9601240914f412b0436d94703vladlosev SetTimeZone(saved_tz_); 437431a8be1662a3bc9601240914f412b0436d94703vladlosev free(const_cast<char*>(saved_tz_)); 438431a8be1662a3bc9601240914f412b0436d94703vladlosev saved_tz_ = NULL; 439431a8be1662a3bc9601240914f412b0436d94703vladlosev } 440431a8be1662a3bc9601240914f412b0436d94703vladlosev 441431a8be1662a3bc9601240914f412b0436d94703vladlosev static void SetTimeZone(const char* time_zone) { 442431a8be1662a3bc9601240914f412b0436d94703vladlosev // tzset() distinguishes between the TZ variable being present and empty 443431a8be1662a3bc9601240914f412b0436d94703vladlosev // and not being present, so we have to consider the case of time_zone 444431a8be1662a3bc9601240914f412b0436d94703vladlosev // being NULL. 445431a8be1662a3bc9601240914f412b0436d94703vladlosev#if _MSC_VER 446431a8be1662a3bc9601240914f412b0436d94703vladlosev // ...Unless it's MSVC, whose standard library's _putenv doesn't 447431a8be1662a3bc9601240914f412b0436d94703vladlosev // distinguish between an empty and a missing variable. 448431a8be1662a3bc9601240914f412b0436d94703vladlosev const std::string env_var = 449431a8be1662a3bc9601240914f412b0436d94703vladlosev std::string("TZ=") + (time_zone ? time_zone : ""); 450431a8be1662a3bc9601240914f412b0436d94703vladlosev _putenv(env_var.c_str()); 4518120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */) 452431a8be1662a3bc9601240914f412b0436d94703vladlosev tzset(); 4538120f66c3249e253f03fdb48bee7e528bc038d31billydonahue GTEST_DISABLE_MSC_WARNINGS_POP_() 454431a8be1662a3bc9601240914f412b0436d94703vladlosev#else 455431a8be1662a3bc9601240914f412b0436d94703vladlosev if (time_zone) { 456431a8be1662a3bc9601240914f412b0436d94703vladlosev setenv(("TZ"), time_zone, 1); 457431a8be1662a3bc9601240914f412b0436d94703vladlosev } else { 458431a8be1662a3bc9601240914f412b0436d94703vladlosev unsetenv("TZ"); 459431a8be1662a3bc9601240914f412b0436d94703vladlosev } 460431a8be1662a3bc9601240914f412b0436d94703vladlosev tzset(); 461431a8be1662a3bc9601240914f412b0436d94703vladlosev#endif 462431a8be1662a3bc9601240914f412b0436d94703vladlosev } 463431a8be1662a3bc9601240914f412b0436d94703vladlosev 464431a8be1662a3bc9601240914f412b0436d94703vladlosev const char* saved_tz_; 465431a8be1662a3bc9601240914f412b0436d94703vladlosev}; 466431a8be1662a3bc9601240914f412b0436d94703vladlosev 467431a8be1662a3bc9601240914f412b0436d94703vladlosevconst TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec; 468431a8be1662a3bc9601240914f412b0436d94703vladlosev 469431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsTwoDigitSegments) { 470431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_EQ("2011-10-31T18:52:42", 471431a8be1662a3bc9601240914f412b0436d94703vladlosev FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec)); 472431a8be1662a3bc9601240914f412b0436d94703vladlosev} 473431a8be1662a3bc9601240914f412b0436d94703vladlosev 474431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST_F(FormatEpochTimeInMillisAsIso8601Test, MillisecondsDoNotAffectResult) { 475431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_EQ( 476431a8be1662a3bc9601240914f412b0436d94703vladlosev "2011-10-31T18:52:42", 477431a8be1662a3bc9601240914f412b0436d94703vladlosev FormatEpochTimeInMillisAsIso8601(1320087162 * kMillisPerSec + 234)); 478431a8be1662a3bc9601240914f412b0436d94703vladlosev} 479431a8be1662a3bc9601240914f412b0436d94703vladlosev 480431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsLeadingZeroes) { 481431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_EQ("2011-09-03T05:07:02", 482431a8be1662a3bc9601240914f412b0436d94703vladlosev FormatEpochTimeInMillisAsIso8601(1315026422 * kMillisPerSec)); 483431a8be1662a3bc9601240914f412b0436d94703vladlosev} 484431a8be1662a3bc9601240914f412b0436d94703vladlosev 485431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST_F(FormatEpochTimeInMillisAsIso8601Test, Prints24HourTime) { 486431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_EQ("2011-09-28T17:08:22", 487431a8be1662a3bc9601240914f412b0436d94703vladlosev FormatEpochTimeInMillisAsIso8601(1317229702 * kMillisPerSec)); 488431a8be1662a3bc9601240914f412b0436d94703vladlosev} 489431a8be1662a3bc9601240914f412b0436d94703vladlosev 490431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST_F(FormatEpochTimeInMillisAsIso8601Test, PrintsEpochStart) { 491431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_EQ("1970-01-01T00:00:00", FormatEpochTimeInMillisAsIso8601(0)); 492431a8be1662a3bc9601240914f412b0436d94703vladlosev} 493431a8be1662a3bc9601240914f412b0436d94703vladlosev 49406d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 495d201456903f3ecae1f7794edfab0d5678e64226shiqian 496ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifdef __BORLANDC__ 497c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 498ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option push -w-ccc -w-rch 499ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 500c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 501e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is true when x is a null 502d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 503d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsTrueForNullLiterals) { 504e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(NULL)); 505e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0)); 506e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0U)); 507e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(GTEST_IS_NULL_LITERAL_(0L)); 508d201456903f3ecae1f7794edfab0d5678e64226shiqian} 509d201456903f3ecae1f7794edfab0d5678e64226shiqian 510e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that GTEST_IS_NULL_LITERAL_(x) is false when x is not a null 511d201456903f3ecae1f7794edfab0d5678e64226shiqian// pointer literal. 512d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NullLiteralTest, IsFalseForNonNullLiterals) { 513e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(1)); 514e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(0.0)); 515e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_('a')); 516e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FALSE(GTEST_IS_NULL_LITERAL_(static_cast<void*>(NULL))); 517d201456903f3ecae1f7794edfab0d5678e64226shiqian} 518d201456903f3ecae1f7794edfab0d5678e64226shiqian 519ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifdef __BORLANDC__ 520d21c142eb89ce42817165368641329072e2ad8fbvladlosev// Restores warnings after previous "#pragma option push" suppressed them. 521ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option pop 522ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 523c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 52406d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 5250c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 5260c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests CodePointToUtf8(). 527d201456903f3ecae1f7794edfab0d5678e64226shiqian 528d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the NUL character L'\0' is encoded correctly. 5290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeNul) { 530cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("", CodePointToUtf8(L'\0')); 531d201456903f3ecae1f7794edfab0d5678e64226shiqian} 532d201456903f3ecae1f7794edfab0d5678e64226shiqian 533d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ASCII characters are encoded correctly. 5340c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeAscii) { 535cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("a", CodePointToUtf8(L'a')); 536cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("Z", CodePointToUtf8(L'Z')); 537cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("&", CodePointToUtf8(L'&')); 538cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\x7F", CodePointToUtf8(L'\x7F')); 539d201456903f3ecae1f7794edfab0d5678e64226shiqian} 540d201456903f3ecae1f7794edfab0d5678e64226shiqian 541d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 8 to 11 bits are encoded 542d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 110xxxxx 10xxxxxx. 5430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode8To11Bits) { 544d201456903f3ecae1f7794edfab0d5678e64226shiqian // 000 1101 0011 => 110-00011 10-010011 545cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xC3\x93", CodePointToUtf8(L'\xD3')); 546d201456903f3ecae1f7794edfab0d5678e64226shiqian 547d201456903f3ecae1f7794edfab0d5678e64226shiqian // 101 0111 0110 => 110-10101 10-110110 548c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Some compilers (e.g., GCC on MinGW) cannot handle non-ASCII codepoints 549c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // in wide strings and wide chars. In order to accomodate them, we have to 550c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // introduce such character constants as integers. 551cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xD5\xB6", 552cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak CodePointToUtf8(static_cast<wchar_t>(0x576))); 553d201456903f3ecae1f7794edfab0d5678e64226shiqian} 554d201456903f3ecae1f7794edfab0d5678e64226shiqian 555d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 12 to 16 bits are encoded 556d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 1110xxxx 10xxxxxx 10xxxxxx. 5570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode12To16Bits) { 558d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 559cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xE0\xA3\x93", 560cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak CodePointToUtf8(static_cast<wchar_t>(0x8D3))); 561d201456903f3ecae1f7794edfab0d5678e64226shiqian 562d201456903f3ecae1f7794edfab0d5678e64226shiqian // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 563cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xEC\x9D\x8D", 564cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak CodePointToUtf8(static_cast<wchar_t>(0xC74D))); 565d201456903f3ecae1f7794edfab0d5678e64226shiqian} 566d201456903f3ecae1f7794edfab0d5678e64226shiqian 5670af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 568d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests in this group require a wchar_t to hold > 16 bits, and thus 569e0ecb7ac588e4061fe57207ff3734e465637b14dshiqian// are skipped on Windows, Cygwin, and Symbian, where a wchar_t is 5700c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// 16-bit wide. This code may not compile on those systems. 571d201456903f3ecae1f7794edfab0d5678e64226shiqian 572d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Unicode code-points that have 17 to 21 bits are encoded 573d201456903f3ecae1f7794edfab0d5678e64226shiqian// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. 5740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncode17To21Bits) { 575d201456903f3ecae1f7794edfab0d5678e64226shiqian // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 576cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xF0\x90\xA3\x93", CodePointToUtf8(L'\x108D3')); 5770c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5780c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 0100 0000 0000 => 11110-000 10-010000 10-010000 10-000000 579cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xF0\x90\x90\x80", CodePointToUtf8(L'\x10400')); 580d201456903f3ecae1f7794edfab0d5678e64226shiqian 5810c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 582cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("\xF4\x88\x98\xB4", CodePointToUtf8(L'\x108634')); 583d201456903f3ecae1f7794edfab0d5678e64226shiqian} 584d201456903f3ecae1f7794edfab0d5678e64226shiqian 585d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that encoding an invalid code-point generates the expected result. 5860c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(CodePointToUtf8Test, CanEncodeInvalidCodePoint) { 587cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak EXPECT_EQ("(Invalid Unicode 0x1234ABCD)", CodePointToUtf8(L'\x1234ABCD')); 5880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5890c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5900af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 5910c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests WideStringToUtf8(). 5930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 5940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the NUL character L'\0' is encoded correctly. 5950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeNul) { 5960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", 0).c_str()); 5970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("", WideStringToUtf8(L"", -1).c_str()); 5980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 5990c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that ASCII strings are encoded correctly. 6010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeAscii) { 6020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", 1).c_str()); 6030c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", 2).c_str()); 6040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("a", WideStringToUtf8(L"a", -1).c_str()); 6050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ab", WideStringToUtf8(L"ab", -1).c_str()); 6060c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6080c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 8 to 11 bits are encoded 6090c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 110xxxxx 10xxxxxx. 6100c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode8To11Bits) { 6110c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 000 1101 0011 => 110-00011 10-010011 6120c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", 1).c_str()); 6130c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xC3\x93", WideStringToUtf8(L"\xD3", -1).c_str()); 6140c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6150c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 101 0111 0110 => 110-10101 10-110110 616c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0x576, '\0' }; 617c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, 1).c_str()); 618c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xD5\xB6", WideStringToUtf8(s, -1).c_str()); 6190c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6200c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6210c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 12 to 16 bits are encoded 6220c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 1110xxxx 10xxxxxx 10xxxxxx. 6230c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode12To16Bits) { 6240c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0000 1000 1101 0011 => 1110-0000 10-100011 10-010011 625c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s1[] = { 0x8D3, '\0' }; 626c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, 1).c_str()); 627c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xE0\xA3\x93", WideStringToUtf8(s1, -1).c_str()); 6280c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6290c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1100 0111 0100 1101 => 1110-1100 10-011101 10-001101 630c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s2[] = { 0xC74D, '\0' }; 631c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, 1).c_str()); 632c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xEC\x9D\x8D", WideStringToUtf8(s2, -1).c_str()); 633d201456903f3ecae1f7794edfab0d5678e64226shiqian} 634d201456903f3ecae1f7794edfab0d5678e64226shiqian 6350c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function encounters \0 character. 6360c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsOnNulCharacter) { 6370c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABC\0XYZ", 100).c_str()); 6380c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6390c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6400c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that the conversion stops when the function reaches the limit 6410c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// specified by the 'length' parameter. 6420c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, StopsWhenLengthLimitReached) { 6430c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("ABC", WideStringToUtf8(L"ABCDEF", 3).c_str()); 6440c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6450c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6460af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 6470c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that Unicode code-points that have 17 to 21 bits are encoded 6480c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// as 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx. This code may not compile 6490c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// on the systems using UTF-16 encoding. 6500c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncode17To21Bits) { 6510c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 0 0001 0000 1000 1101 0011 => 11110-000 10-010000 10-100011 10-010011 6520c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", 1).c_str()); 6530c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF0\x90\xA3\x93", WideStringToUtf8(L"\x108D3", -1).c_str()); 6540c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6550c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // 1 0000 1000 0110 0011 0100 => 11110-100 10-001000 10-011000 10-110100 6560c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", 1).c_str()); 6570c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("\xF4\x88\x98\xB4", WideStringToUtf8(L"\x108634", -1).c_str()); 6580c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6590c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6600c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid code-point generates the expected result. 6610c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidCodePoint) { 6620c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ("(Invalid Unicode 0xABCDFF)", 6630c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev WideStringToUtf8(L"\xABCDFF", -1).c_str()); 6640c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6650af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#else // !GTEST_WIDE_STRING_USES_UTF16_ 6660c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that surrogate pairs are encoded correctly on the systems using 6670c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// UTF-16 encoding in the wide strings. 6680c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeValidUtf16SUrrogatePairs) { 669c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0xD801, 0xDC00, '\0' }; 670c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xF0\x90\x90\x80", WideStringToUtf8(s, -1).c_str()); 6710c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6720c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6730c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that encoding an invalid UTF-16 surrogate pair 6740c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// generates the expected result. 6750c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, CanEncodeInvalidUtf16SurrogatePair) { 6760c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is at the end of the string. 677c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s1[] = { 0xD800, '\0' }; 678c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xA0\x80", WideStringToUtf8(s1, -1).c_str()); 6790c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Leading surrogate is not followed by the trailing surrogate. 680c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s2[] = { 0xD800, 'M', '\0' }; 681c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xA0\x80M", WideStringToUtf8(s2, -1).c_str()); 6820c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev // Trailing surrogate appearas without a leading surrogate. 683c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s3[] = { 0xDC00, 'P', 'Q', 'R', '\0' }; 684c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_STREQ("\xED\xB0\x80PQR", WideStringToUtf8(s3, -1).c_str()); 6850c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 6860af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 6870c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev 6880c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev// Tests that codepoint concatenation works correctly. 6890af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_WIDE_STRING_USES_UTF16_ 6900c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 691c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0x108634, 0xC74D, '\n', 0x576, 0x8D3, 0x108634, '\0'}; 6920c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 6930c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4" 6940c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" 6950c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\n" 6960c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xD5\xB6" 6970c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xE0\xA3\x93" 6980c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xF4\x88\x98\xB4", 699c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan WideStringToUtf8(s, -1).c_str()); 7000c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 7010c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev#else 7020c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosevTEST(WideStringToUtf8Test, ConcatenatesCodepointsCorrectly) { 703c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t s[] = { 0xC74D, '\n', 0x576, 0x8D3, '\0'}; 7040c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev EXPECT_STREQ( 7050c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev "\xEC\x9D\x8D" "\n" "\xD5\xB6" "\xE0\xA3\x93", 706c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan WideStringToUtf8(s, -1).c_str()); 7070c5a66245b8c5939b36b2aad6f4d5ab89b724b1avladlosev} 7080af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_WIDE_STRING_USES_UTF16_ 709d201456903f3ecae1f7794edfab0d5678e64226shiqian 7102534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan// Tests the Random class. 7112534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7122534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomDeathTest, GeneratesCrashesOnInvalidRange) { 7132534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(42); 7142534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 7152534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Generate(0), 7162534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "Cannot generate a number in the range \\[0, 0\\)"); 7172534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 7182534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Generate(testing::internal::Random::kMaxRange + 1), 7192534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "Generation of a number in \\[0, 2147483649\\) was requested, " 7202534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan "but this can only generate numbers in \\[0, 2147483648\\)"); 7212534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 7222534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7232534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomTest, GeneratesNumbersWithinRange) { 7242534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const UInt32 kRange = 10000; 7252534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(12345); 7262534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < 10; i++) { 7272534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_LT(random.Generate(kRange), kRange) << " for iteration " << i; 7282534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 7292534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7302534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random2(testing::internal::Random::kMaxRange); 7312534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < 10; i++) { 7322534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_LT(random2.Generate(kRange), kRange) << " for iteration " << i; 7332534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 7342534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 7352534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7362534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wanTEST(RandomTest, RepeatsWhenReseeded) { 7372534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const int kSeed = 123; 7382534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const int kArraySize = 10; 7392534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan const UInt32 kRange = 10000; 7402534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan UInt32 values[kArraySize]; 7412534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7422534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan testing::internal::Random random(kSeed); 7432534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < kArraySize; i++) { 7442534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan values[i] = random.Generate(kRange); 7452534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 7462534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7472534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan random.Reseed(kSeed); 7482534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan for (int i = 0; i < kArraySize; i++) { 7492534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan EXPECT_EQ(values[i], random.Generate(kRange)) << " for iteration " << i; 7502534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan } 7512534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan} 7522534ae201e47986d36d5fab0e523a7f046b8ec1ezhanyong.wan 7530d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests STL container utilities. 754600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 7550d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests CountIf(). 756600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 7570d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic bool IsPositive(int n) { return n > 0; } 75889080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 7590d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, CountIf) { 7600d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> v; 7610d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, CountIf(v, IsPositive)); // Works for an empty container. 76289080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 7630d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(-1); 7640d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(0); 7650d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, CountIf(v, IsPositive)); // Works when no value satisfies. 76689080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 7670d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(2); 7680d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(-10); 7690d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(10); 7700d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(2, CountIf(v, IsPositive)); 771e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 772d201456903f3ecae1f7794edfab0d5678e64226shiqian 7730d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests ForEach(). 774bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 7750d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic int g_sum = 0; 7760d27868d0faef474594682f25336229daa89d6d7zhanyong.wanstatic void Accumulate(int n) { g_sum += n; } 777bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 7780d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, ForEach) { 7790d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> v; 7800d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 7810d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 7820d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(0, g_sum); // Works for an empty container; 783bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 7840d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 7850d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(1); 7860d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 7870d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(1, g_sum); // Works for a container with one element. 7880d27868d0faef474594682f25336229daa89d6d7zhanyong.wan 7890d27868d0faef474594682f25336229daa89d6d7zhanyong.wan g_sum = 0; 7900d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(20); 7910d27868d0faef474594682f25336229daa89d6d7zhanyong.wan v.push_back(300); 7920d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ForEach(v, Accumulate); 7930d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(321, g_sum); 794bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 795bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 7960d27868d0faef474594682f25336229daa89d6d7zhanyong.wan// Tests GetElementOr(). 7970d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityTest, GetElementOr) { 7980d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<char> a; 7990d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, 0, 'x')); 800bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 8010d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back('a'); 8020d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back('b'); 8030d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('a', GetElementOr(a, 0, 'x')); 8040d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('b', GetElementOr(a, 1, 'x')); 8050d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, -2, 'x')); 8060d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ('x', GetElementOr(a, 2, 'x')); 807bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 808bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 8090d27868d0faef474594682f25336229daa89d6d7zhanyong.wanTEST(ContainerUtilityDeathTest, ShuffleRange) { 8100d27868d0faef474594682f25336229daa89d6d7zhanyong.wan std::vector<int> a; 8110d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(0); 8120d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(1); 8130d27868d0faef474594682f25336229daa89d6d7zhanyong.wan a.push_back(2); 814bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan testing::internal::Random random(1); 815bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 816bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 8170d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, -1, 1, &a), 818bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range start -1: must be in range \\[0, 3\\]"); 819bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 8200d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 4, 4, &a), 821bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range start 4: must be in range \\[0, 3\\]"); 822bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 8230d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 3, 2, &a), 824bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range finish 2: must be in range \\[3, 3\\]"); 825bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 8260d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random, 3, 4, &a), 827bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan "Invalid shuffle range finish 4: must be in range \\[3, 3\\]"); 828bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 829bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 830bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanclass VectorShuffleTest : public Test { 831bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan protected: 832bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static const int kVectorSize = 20; 833bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 834bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan VectorShuffleTest() : random_(1) { 835bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 8360d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_.push_back(i); 837bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 838bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 839bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 840bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsCorrupt(const TestingVector& vector) { 8410d27868d0faef474594682f25336229daa89d6d7zhanyong.wan if (kVectorSize != static_cast<int>(vector.size())) { 842bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 843bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 844bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 845bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan bool found_in_vector[kVectorSize] = { false }; 8460d27868d0faef474594682f25336229daa89d6d7zhanyong.wan for (size_t i = 0; i < vector.size(); i++) { 8470d27868d0faef474594682f25336229daa89d6d7zhanyong.wan const int e = vector[i]; 848bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan if (e < 0 || e >= kVectorSize || found_in_vector[e]) { 849bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 850bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 851bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan found_in_vector[e] = true; 852bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 853bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 854bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Vector size is correct, elements' range is correct, no 855bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // duplicate elements. Therefore no corruption has occurred. 856bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return false; 857bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 858bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 859bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsNotCorrupt(const TestingVector& vector) { 860bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !VectorIsCorrupt(vector); 861bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 862bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 863bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool RangeIsShuffled(const TestingVector& vector, int begin, int end) { 864bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = begin; i < end; i++) { 8650d27868d0faef474594682f25336229daa89d6d7zhanyong.wan if (i != vector[i]) { 866bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return true; 867bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 868bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 869bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return false; 870bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 871bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 872bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool RangeIsUnshuffled( 873bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const TestingVector& vector, int begin, int end) { 874bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !RangeIsShuffled(vector, begin, end); 875bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 876bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 877bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsShuffled(const TestingVector& vector) { 8786baed3c1173c19f5d43af75798d3685853fbe8bdzhanyong.wan return RangeIsShuffled(vector, 0, static_cast<int>(vector.size())); 879bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 880bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 881bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan static bool VectorIsUnshuffled(const TestingVector& vector) { 882bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan return !VectorIsShuffled(vector); 883bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 884bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 885bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan testing::internal::Random random_; 886bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan TestingVector vector_; 887bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan}; // class VectorShuffleTest 888bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 889bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanconst int VectorShuffleTest::kVectorSize; 890bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 891bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, HandlesEmptyRange) { 892bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests an empty range at the beginning... 8930d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, 0, &vector_); 894bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 895bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 896bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 897bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...in the middle... 8980d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize/2, kVectorSize/2, &vector_); 899bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 900bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 901bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 902bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...at the end... 9030d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize - 1, kVectorSize - 1, &vector_); 904bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 905bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 906bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 907bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...and past the end. 9080d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize, kVectorSize, &vector_); 909bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 910bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 911bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 912bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 913bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, HandlesRangeOfSizeOne) { 914bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests a size one range at the beginning... 9150d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, 1, &vector_); 916bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 917bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 918bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 919bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...in the middle... 9200d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize/2, kVectorSize/2 + 1, &vector_); 921bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 922bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 923bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 924bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // ...and at the end. 9250d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kVectorSize - 1, kVectorSize, &vector_); 926bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 927bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsUnshuffled, vector_); 928bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 929bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 930bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan// Because we use our own random number generator and a fixed seed, 931bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan// we can guarantee that the following "random" tests will succeed. 932bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 933bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesEntireVector) { 9340d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector_); 935bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 936bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_FALSE(VectorIsUnshuffled(vector_)) << vector_; 937bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 938bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // Tests the first and last elements in particular to ensure that 939bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan // there are no off-by-one problems in our shuffle algorithm. 9400d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_NE(0, vector_[0]); 9410d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_NE(kVectorSize - 1, vector_[kVectorSize - 1]); 942bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 943bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 944bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesStartOfVector) { 945bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const int kRangeSize = kVectorSize/2; 946bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 9470d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, 0, kRangeSize, &vector_); 948bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 949bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 950bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, 0, kRangeSize); 951bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, kRangeSize, kVectorSize); 952bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 953bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 954bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesEndOfVector) { 955bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan const int kRangeSize = kVectorSize / 2; 9560d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kRangeSize, kVectorSize, &vector_); 957bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 958bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 959bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 960bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, kVectorSize); 961bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 962bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 963bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesMiddleOfVector) { 964bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan int kRangeSize = kVectorSize/3; 9650d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ShuffleRange(&random_, kRangeSize, 2*kRangeSize, &vector_); 966bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 967bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 968bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 0, kRangeSize); 969bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsShuffled, vector_, kRangeSize, 2*kRangeSize); 970bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan EXPECT_PRED3(RangeIsUnshuffled, vector_, 2*kRangeSize, kVectorSize); 971bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 972bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 973bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wanTEST_F(VectorShuffleTest, ShufflesRepeatably) { 974bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan TestingVector vector2; 975bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 9760d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector2.push_back(i); 977bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 978bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 979bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan random_.Reseed(1234); 9800d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector_); 981bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan random_.Reseed(1234); 9820d27868d0faef474594682f25336229daa89d6d7zhanyong.wan Shuffle(&random_, &vector2); 983bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 984bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector_); 985bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan ASSERT_PRED1(VectorIsNotCorrupt, vector2); 986bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 987bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan for (int i = 0; i < kVectorSize; i++) { 9880d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_EQ(vector_[i], vector2[i]) << " where i is " << i; 989bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan } 990bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan} 991bd851333e89517762c91a3fef67cf25a6f1bd37azhanyong.wan 99216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests the size of the AssertHelper class. 993d201456903f3ecae1f7794edfab0d5678e64226shiqian 99416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(AssertHelperTest, AssertHelperIsSmall) { 99556a2e686e915d483cb22db091140130b23814127zhanyong.wan // To avoid breaking clients that use lots of assertions in one 99616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // function, we cannot grow the size of AssertHelper. 99716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_LE(sizeof(testing::internal::AssertHelper), sizeof(void*)); 99856a2e686e915d483cb22db091140130b23814127zhanyong.wan} 99956a2e686e915d483cb22db091140130b23814127zhanyong.wan 1000d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::EndsWithCaseInsensitive(). 1001d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, EndsWithCaseInsensitive) { 100287fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "BAR")); 100387fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_TRUE(String::EndsWithCaseInsensitive("foobaR", "bar")); 100487fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_TRUE(String::EndsWithCaseInsensitive("foobar", "")); 100587fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_TRUE(String::EndsWithCaseInsensitive("", "")); 1006d201456903f3ecae1f7794edfab0d5678e64226shiqian 100787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(String::EndsWithCaseInsensitive("Foobar", "foo")); 100887fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(String::EndsWithCaseInsensitive("foobar", "Foo")); 100987fdda2cf24d953f3cbec1e0c266b2db9928f406jgm EXPECT_FALSE(String::EndsWithCaseInsensitive("", "foo")); 1010d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1011d201456903f3ecae1f7794edfab0d5678e64226shiqian 1012c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// C++Builder's preprocessor is buggy; it fails to expand macros that 1013c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// appear in macro parameters after wide char literals. Provide an alias 1014c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// for NULL as a workaround. 1015c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic const wchar_t* const kNull = NULL; 1016c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1017a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests String::CaseInsensitiveWideCStringEquals 1018a2b1a8556ea64014606d78b09333d9c522430a25shiqianTEST(StringTest, CaseInsensitiveWideCStringEquals) { 1019a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(NULL, NULL)); 1020c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"")); 1021c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"", kNull)); 1022c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(kNull, L"foobar")); 1023c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(String::CaseInsensitiveWideCStringEquals(L"foobar", kNull)); 1024a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"foobar")); 1025a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"foobar", L"FOOBAR")); 1026a2b1a8556ea64014606d78b09333d9c522430a25shiqian EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); 1027a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 1028a2b1a8556ea64014606d78b09333d9c522430a25shiqian 10290af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 1030d201456903f3ecae1f7794edfab0d5678e64226shiqian 1031d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests String::ShowWideCString(). 1032d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringTest, ShowWideCString) { 1033d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 1034d201456903f3ecae1f7794edfab0d5678e64226shiqian String::ShowWideCString(NULL).c_str()); 1035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", String::ShowWideCString(L"").c_str()); 1036d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); 1037d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1038d201456903f3ecae1f7794edfab0d5678e64226shiqian 1039ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_WINDOWS_MOBILE 1040bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16Null) { 1041bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); 1042bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); 1043bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1044bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1045bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertBasic) { 1046bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L"str"); 1047bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ("str", ansi); 1048bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 1049bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16("str"); 1050ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L"str", utf16, 3)); 1051bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 1052bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1053bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1054bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqianTEST(StringTest, AnsiAndUtf16ConvertPathChars) { 1055bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const char* ansi = String::Utf16ToAnsi(L".:\\ \"*?"); 1056bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian EXPECT_STREQ(".:\\ \"*?", ansi); 1057bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] ansi; 1058bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian const WCHAR* utf16 = String::AnsiToUtf16(".:\\ \"*?"); 1059ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan EXPECT_EQ(0, wcsncmp(L".:\\ \"*?", utf16, 3)); 1060bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian delete [] utf16; 1061bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian} 1062ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_WINDOWS_MOBILE 1063bf9b4b48dc65adc2edd44175f77b4a7363c59234shiqian 1064d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 1065d201456903f3ecae1f7794edfab0d5678e64226shiqian 1066d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty construction. 1067d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, StringValue) { 1068d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 1069d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("key", property.key()); 1070d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 1071d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1072d201456903f3ecae1f7794edfab0d5678e64226shiqian 1073d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestProperty replacing a value. 1074d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestPropertyTest, ReplaceStringValue) { 1075d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key", "1"); 1076d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1", property.value()); 1077d201456903f3ecae1f7794edfab0d5678e64226shiqian property.SetValue("2"); 1078d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("2", property.value()); 1079d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1080d201456903f3ecae1f7794edfab0d5678e64226shiqian 1081c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// AddFatalFailure() and AddNonfatalFailure() must be stand-alone 1082c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// functions (i.e. their definitions cannot be inlined at the call 1083c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// sites), or C++Builder won't compile the code. 1084c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddFatalFailure() { 1085c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FAIL() << "Expected fatal failure."; 1086c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1087c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1088c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wanstatic void AddNonfatalFailure() { 1089c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ADD_FAILURE() << "Expected non-fatal failure."; 1090c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan} 1091c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1092e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterTest : public Test { 10938de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 1094e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian enum FailureMode { 1095e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FATAL_FAILURE, 1096e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian NONFATAL_FAILURE 1097e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }; 1098e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailure(FailureMode failure) { 1099e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian if (failure == FATAL_FAILURE) { 1100c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1101e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } else { 1102c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1103e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1104e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1105d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1106d201456903f3ecae1f7794edfab0d5678e64226shiqian 1107e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests that ScopedFakeTestPartResultReporter intercepts test 1108e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// failures. 1109e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, InterceptsTestFailures) { 1110e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1111e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1112e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1113e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 1114e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian &results); 1115e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1116e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1117e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1118d201456903f3ecae1f7794edfab0d5678e64226shiqian 1119e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(2, results.size()); 1120e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1121e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1122d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1123d201456903f3ecae1f7794edfab0d5678e64226shiqian 1124e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) { 1125e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1127e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Tests, that the deprecated constructor still works. 1128e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter(&results); 1129e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1130e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1131e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(1, results.size()); 1132d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1133d201456903f3ecae1f7794edfab0d5678e64226shiqian 113412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 1135e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1136e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass ScopedFakeTestPartResultReporterWithThreadsTest 1137e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian : public ScopedFakeTestPartResultReporterTest { 1138e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 1139e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian static void AddFailureInOtherThread(FailureMode failure) { 114012a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 114112a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan thread.Join(); 1142e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1143e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 1144e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1145e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ScopedFakeTestPartResultReporterWithThreadsTest, 1146e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian InterceptsTestFailuresInAllThreads) { 1147e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray results; 1148e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 1149e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter reporter( 1150e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, &results); 1151e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(NONFATAL_FAILURE); 1152e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailure(FATAL_FAILURE); 1153e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE); 1154e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(FATAL_FAILURE); 1155e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 1156e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1157e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_EQ(4, results.size()); 1158e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(0).nonfatally_failed()); 1159e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(1).fatally_failed()); 1160e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(2).nonfatally_failed()); 1161e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_TRUE(results.GetTestPartResult(3).fatally_failed()); 1162d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1163d201456903f3ecae1f7794edfab0d5678e64226shiqian 116412a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif // GTEST_IS_THREADSAFE 1165e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1166c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Tests EXPECT_FATAL_FAILURE{,ON_ALL_THREADS}. Makes sure that they 1167c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// work even if the failure is generated in a called function rather than 1168c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// the current context. 1169e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 117037504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectFatalFailureTest; 1171e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 117237504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFaliure) { 1173c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), "Expected fatal failure."); 1174d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1175d201456903f3ecae1f7794edfab0d5678e64226shiqian 1176b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#if GTEST_HAS_GLOBAL_STRING 1177b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsStringObject) { 1178b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), ::string("Expected fatal failure.")); 1179b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1180b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#endif 1181b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 1182b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsStdStringObject) { 1183b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_FATAL_FAILURE(AddFatalFailure(), 1184b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::std::string("Expected fatal failure.")); 1185b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1186b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 118737504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CatchesFatalFailureOnAllThreads) { 118837504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches fatal 118937504994338c114247519331237831f88a9a7c40zhanyong.wan // failures generated on another thread. 1190c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFatalFailure(), 1191e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1192d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1193d201456903f3ecae1f7794edfab0d5678e64226shiqian 1194c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1195c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true" 1196ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option push -w-ccc 1197c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1198c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 119937504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE() can be used in a non-void 120037504994338c114247519331237831f88a9a7c40zhanyong.wan// function even when the statement in it contains ASSERT_*. 120137504994338c114247519331237831f88a9a7c40zhanyong.wan 120237504994338c114247519331237831f88a9a7c40zhanyong.wanint NonVoidFunction() { 120337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 120437504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 120537504994338c114247519331237831f88a9a7c40zhanyong.wan return 0; 120637504994338c114247519331237831f88a9a7c40zhanyong.wan} 120737504994338c114247519331237831f88a9a7c40zhanyong.wan 120837504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, CanBeUsedInNonVoidFunction) { 120937504994338c114247519331237831f88a9a7c40zhanyong.wan NonVoidFunction(); 121037504994338c114247519331237831f88a9a7c40zhanyong.wan} 121137504994338c114247519331237831f88a9a7c40zhanyong.wan 121237504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that EXPECT_FATAL_FAILURE(statement, ...) doesn't abort the 121337504994338c114247519331237831f88a9a7c40zhanyong.wan// current function even though 'statement' generates a fatal failure. 121437504994338c114247519331237831f88a9a7c40zhanyong.wan 121537504994338c114247519331237831f88a9a7c40zhanyong.wanvoid DoesNotAbortHelper(bool* aborted) { 121637504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_TRUE(false), ""); 121737504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FAIL(), ""); 121837504994338c114247519331237831f88a9a7c40zhanyong.wan 121937504994338c114247519331237831f88a9a7c40zhanyong.wan *aborted = false; 122037504994338c114247519331237831f88a9a7c40zhanyong.wan} 122137504994338c114247519331237831f88a9a7c40zhanyong.wan 1222c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 1223d21c142eb89ce42817165368641329072e2ad8fbvladlosev// Restores warnings after previous "#pragma option push" suppressed them. 1224ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option pop 1225c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1226c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 122737504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, DoesNotAbort) { 122837504994338c114247519331237831f88a9a7c40zhanyong.wan bool aborted = true; 122937504994338c114247519331237831f88a9a7c40zhanyong.wan DoesNotAbortHelper(&aborted); 123037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_FALSE(aborted); 1231d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1232d201456903f3ecae1f7794edfab0d5678e64226shiqian 123337504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_FATAL_FAILURE{,_ON_ALL_THREADS} accepts a 123437504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 123537504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 1236d201456903f3ecae1f7794edfab0d5678e64226shiqian 1237e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianstatic int global_var = 0; 1238e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian#define GTEST_USE_UNPROTECTED_COMMA_ global_var++, global_var++ 1239d201456903f3ecae1f7794edfab0d5678e64226shiqian 124037504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectFatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1241603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ 1242603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan // ICE's in C++Builder. 1243e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE({ 1244e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1245c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1246e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1247c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 1248d201456903f3ecae1f7794edfab0d5678e64226shiqian 1249e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS({ 1250e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1251c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddFatalFailure(); 1252e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 125337504994338c114247519331237831f88a9a7c40zhanyong.wan} 125437504994338c114247519331237831f88a9a7c40zhanyong.wan 125537504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests EXPECT_NONFATAL_FAILURE{,ON_ALL_THREADS}. 125637504994338c114247519331237831f88a9a7c40zhanyong.wan 125737504994338c114247519331237831f88a9a7c40zhanyong.wantypedef ScopedFakeTestPartResultReporterTest ExpectNonfatalFailureTest; 125837504994338c114247519331237831f88a9a7c40zhanyong.wan 125937504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailure) { 1260c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 126137504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 126237504994338c114247519331237831f88a9a7c40zhanyong.wan} 1263d201456903f3ecae1f7794edfab0d5678e64226shiqian 1264b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#if GTEST_HAS_GLOBAL_STRING 1265b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsStringObject) { 1266b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 1267b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::string("Expected non-fatal failure.")); 1268b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1269b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan#endif 1270b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 1271b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsStdStringObject) { 1272b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan EXPECT_NONFATAL_FAILURE(AddNonfatalFailure(), 1273b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan ::std::string("Expected non-fatal failure.")); 1274b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan} 1275b5d3a17805fe0ed2ccde463412ae1fd206c4df21zhanyong.wan 127637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, CatchesNonfatalFailureOnAllThreads) { 127737504994338c114247519331237831f88a9a7c40zhanyong.wan // We have another test below to verify that the macro catches 127837504994338c114247519331237831f88a9a7c40zhanyong.wan // non-fatal failures generated on another thread. 1279c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddNonfatalFailure(), 128037504994338c114247519331237831f88a9a7c40zhanyong.wan "Expected non-fatal failure."); 128137504994338c114247519331237831f88a9a7c40zhanyong.wan} 128237504994338c114247519331237831f88a9a7c40zhanyong.wan 128337504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the EXPECT_NONFATAL_FAILURE{,_ON_ALL_THREADS} accepts a 128437504994338c114247519331237831f88a9a7c40zhanyong.wan// statement that contains a macro which expands to code containing an 128537504994338c114247519331237831f88a9a7c40zhanyong.wan// unprotected comma. 128637504994338c114247519331237831f88a9a7c40zhanyong.wanTEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) { 1287e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE({ 1288e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1289c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1290e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1291d201456903f3ecae1f7794edfab0d5678e64226shiqian 1292e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS({ 1293e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian GTEST_USE_UNPROTECTED_COMMA_; 1294c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan AddNonfatalFailure(); 1295e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian }, ""); 1296d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1297d201456903f3ecae1f7794edfab0d5678e64226shiqian 129812a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#if GTEST_IS_THREADSAFE 1299d201456903f3ecae1f7794edfab0d5678e64226shiqian 1300e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqiantypedef ScopedFakeTestPartResultReporterWithThreadsTest 1301e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ExpectFailureWithThreadsTest; 1302d201456903f3ecae1f7794edfab0d5678e64226shiqian 1303e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailureOnAllThreads) { 1304e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailureInOtherThread(FATAL_FAILURE), 1305e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "Expected fatal failure."); 1306e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 1307e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1308e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailureOnAllThreads) { 1309e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS( 1310e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian AddFailureInOtherThread(NONFATAL_FAILURE), "Expected non-fatal failure."); 1311d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1312d201456903f3ecae1f7794edfab0d5678e64226shiqian 131312a92c26fc0e0de81f687dbe739a6aa24f37f9ddzhanyong.wan#endif // GTEST_IS_THREADSAFE 1314e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 1315c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan// Tests the TestProperty class. 1316c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1317c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanTEST(TestPropertyTest, ConstructorWorks) { 1318c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan const TestProperty property("key", "value"); 1319c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1320c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("value", property.value()); 1321c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan} 1322c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1323c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wanTEST(TestPropertyTest, SetValue) { 1324c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan TestProperty property("key", "value_1"); 1325c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1326c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan property.SetValue("value_2"); 1327c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("key", property.key()); 1328c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_STREQ("value_2", property.value()); 1329c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan} 1330c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan 1331d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestResult class 1332d201456903f3ecae1f7794edfab0d5678e64226shiqian 1333d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing TestResult. 13349b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestResultTest : public Test { 1335d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 13360d27868d0faef474594682f25336229daa89d6d7zhanyong.wan typedef std::vector<TestPartResult> TPRVector; 1337d201456903f3ecae1f7794edfab0d5678e64226shiqian 1338d201456903f3ecae1f7794edfab0d5678e64226shiqian // We make use of 2 TestPartResult objects, 1339d201456903f3ecae1f7794edfab0d5678e64226shiqian TestPartResult * pr1, * pr2; 1340d201456903f3ecae1f7794edfab0d5678e64226shiqian 1341d201456903f3ecae1f7794edfab0d5678e64226shiqian // ... and 3 TestResult objects. 1342d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult * r0, * r1, * r2; 1343d201456903f3ecae1f7794edfab0d5678e64226shiqian 1344d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 1345d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr1 is for success. 1346e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan pr1 = new TestPartResult(TestPartResult::kSuccess, 1347e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "foo/bar.cc", 1348e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan 10, 1349e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "Success!"); 1350d201456903f3ecae1f7794edfab0d5678e64226shiqian 1351d201456903f3ecae1f7794edfab0d5678e64226shiqian // pr2 is for fatal failure. 1352e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan pr2 = new TestPartResult(TestPartResult::kFatalFailure, 1353e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan "foo/bar.cc", 13549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian -1, // This line number means "unknown" 13559b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "Failure!"); 1356d201456903f3ecae1f7794edfab0d5678e64226shiqian 1357d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates the TestResult objects. 1358d201456903f3ecae1f7794edfab0d5678e64226shiqian r0 = new TestResult(); 1359d201456903f3ecae1f7794edfab0d5678e64226shiqian r1 = new TestResult(); 1360d201456903f3ecae1f7794edfab0d5678e64226shiqian r2 = new TestResult(); 1361d201456903f3ecae1f7794edfab0d5678e64226shiqian 1362d201456903f3ecae1f7794edfab0d5678e64226shiqian // In order to test TestResult, we need to modify its internal 13630d27868d0faef474594682f25336229daa89d6d7zhanyong.wan // state, in particular the TestPartResult vector it holds. 13640d27868d0faef474594682f25336229daa89d6d7zhanyong.wan // test_part_results() returns a const reference to this vector. 1365d201456903f3ecae1f7794edfab0d5678e64226shiqian // We cast it to a non-const object s.t. it can be modified (yes, 1366d201456903f3ecae1f7794edfab0d5678e64226shiqian // this is a hack). 13670d27868d0faef474594682f25336229daa89d6d7zhanyong.wan TPRVector* results1 = const_cast<TPRVector*>( 1368b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r1)); 13690d27868d0faef474594682f25336229daa89d6d7zhanyong.wan TPRVector* results2 = const_cast<TPRVector*>( 1370b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan &TestResultAccessor::test_part_results(*r2)); 1371d201456903f3ecae1f7794edfab0d5678e64226shiqian 1372d201456903f3ecae1f7794edfab0d5678e64226shiqian // r0 is an empty TestResult. 1373d201456903f3ecae1f7794edfab0d5678e64226shiqian 1374d201456903f3ecae1f7794edfab0d5678e64226shiqian // r1 contains a single SUCCESS TestPartResult. 13750d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results1->push_back(*pr1); 1376d201456903f3ecae1f7794edfab0d5678e64226shiqian 1377d201456903f3ecae1f7794edfab0d5678e64226shiqian // r2 contains a SUCCESS, and a FAILURE. 13780d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results2->push_back(*pr1); 13790d27868d0faef474594682f25336229daa89d6d7zhanyong.wan results2->push_back(*pr2); 1380d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1381d201456903f3ecae1f7794edfab0d5678e64226shiqian 1382d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 1383d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr1; 1384d201456903f3ecae1f7794edfab0d5678e64226shiqian delete pr2; 1385d201456903f3ecae1f7794edfab0d5678e64226shiqian 1386d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r0; 1387d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r1; 1388d201456903f3ecae1f7794edfab0d5678e64226shiqian delete r2; 1389d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1390e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1391e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Helper that compares two two TestPartResults. 1392600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan static void CompareTestPartResult(const TestPartResult& expected, 1393600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestPartResult& actual) { 1394600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.type(), actual.type()); 1395600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.file_name(), actual.file_name()); 1396600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.line_number(), actual.line_number()); 1397600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.summary(), actual.summary()); 1398600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ(expected.message(), actual.message()); 1399600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.passed(), actual.passed()); 1400600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.failed(), actual.failed()); 1401600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.nonfatally_failed(), actual.nonfatally_failed()); 1402600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_EQ(expected.fatally_failed(), actual.fatally_failed()); 1403e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan } 1404d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1405d201456903f3ecae1f7794edfab0d5678e64226shiqian 1406b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::total_part_count(). 1407d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, total_part_count) { 1408b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, r0->total_part_count()); 1409b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, r1->total_part_count()); 1410b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, r2->total_part_count()); 1411d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1412d201456903f3ecae1f7794edfab0d5678e64226shiqian 1413e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Passed(). 1414d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Passed) { 1415d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r0->Passed()); 1416d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r1->Passed()); 1417d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r2->Passed()); 1418d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1419d201456903f3ecae1f7794edfab0d5678e64226shiqian 1420e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::Failed(). 1421d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestResultTest, Failed) { 1422d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r0->Failed()); 1423d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(r1->Failed()); 1424d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(r2->Failed()); 1425d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1426d201456903f3ecae1f7794edfab0d5678e64226shiqian 1427e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestPartResult(). 1428600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1429600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef TestResultTest TestResultDeathTest; 1430600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1431600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(TestResultDeathTest, GetTestPartResult) { 1432600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr1, r2->GetTestPartResult(0)); 1433600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan CompareTestPartResult(*pr2, r2->GetTestPartResult(1)); 14340d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(2), ""); 14350d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(r2->GetTestPartResult(-1), ""); 1436e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1437e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1438b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has no properties when none are added. 1439d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, NoPropertiesFoundWhenNoneAreAdded) { 1440d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1441b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, test_result.test_property_count()); 1442d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1443d201456903f3ecae1f7794edfab0d5678e64226shiqian 1444b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has the expected property when added. 1445d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OnePropertyFoundWhenAdded) { 1446d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1447d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property("key_1", "1"); 1448f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property); 1449b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(1, test_result.test_property_count()); 1450600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property = test_result.GetTestProperty(0); 1451600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property.key()); 1452600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property.value()); 1453d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1454d201456903f3ecae1f7794edfab0d5678e64226shiqian 1455b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult has multiple properties when added. 1456d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, MultiplePropertiesFoundWhenAdded) { 1457d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1458d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1("key_1", "1"); 1459d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2("key_2", "2"); 1460f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_1); 1461f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_2); 1462b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1463600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1464600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1465600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", actual_property_1.value()); 1466d201456903f3ecae1f7794edfab0d5678e64226shiqian 1467600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1468600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1469600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", actual_property_2.value()); 1470d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1471d201456903f3ecae1f7794edfab0d5678e64226shiqian 1472b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan// Tests TestResult::RecordProperty() overrides values for duplicate keys. 1473d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(TestResultPropertyTest, OverridesValuesForDuplicateKeys) { 1474d201456903f3ecae1f7794edfab0d5678e64226shiqian TestResult test_result; 1475d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_1("key_1", "1"); 1476d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_1("key_2", "2"); 1477d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_1_2("key_1", "12"); 1478d201456903f3ecae1f7794edfab0d5678e64226shiqian TestProperty property_2_2("key_2", "22"); 1479f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_1); 1480f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_1); 1481f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_1_2); 1482f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_2_2); 1483e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1484e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan ASSERT_EQ(2, test_result.test_property_count()); 1485600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_1 = test_result.GetTestProperty(0); 1486600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", actual_property_1.key()); 1487600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("12", actual_property_1.value()); 1488b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 1489600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& actual_property_2 = test_result.GetTestProperty(1); 1490600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", actual_property_2.key()); 1491600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("22", actual_property_2.value()); 1492e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1493e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1494e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan// Tests TestResult::GetTestProperty(). 1495f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST(TestResultPropertyTest, GetTestProperty) { 1496e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestResult test_result; 1497e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_1("key_1", "1"); 1498e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_2("key_2", "2"); 1499e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan TestProperty property_3("key_3", "3"); 1500f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_1); 1501f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_2); 1502f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev TestResultAccessor::RecordProperty(&test_result, "testcase", property_3); 1503e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1504600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_1 = test_result.GetTestProperty(0); 1505600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_2 = test_result.GetTestProperty(1); 1506600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan const TestProperty& fetched_property_3 = test_result.GetTestProperty(2); 1507e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1508600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_1", fetched_property_1.key()); 1509600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("1", fetched_property_1.value()); 1510e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1511600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_2", fetched_property_2.key()); 1512600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("2", fetched_property_2.value()); 1513e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 1514600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("key_3", fetched_property_3.key()); 1515600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan EXPECT_STREQ("3", fetched_property_3.value()); 1516e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 15170d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(3), ""); 15180d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(test_result.GetTestProperty(-1), ""); 1519e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan} 1520e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan 15211cc9514de5a9b361e7a000eb34da9175b6de0593kosak// Tests the Test class. 15221cc9514de5a9b361e7a000eb34da9175b6de0593kosak// 15231cc9514de5a9b361e7a000eb34da9175b6de0593kosak// It's difficult to test every public method of this class (we are 15241cc9514de5a9b361e7a000eb34da9175b6de0593kosak// already stretching the limit of Google Test by using it to test itself!). 15251cc9514de5a9b361e7a000eb34da9175b6de0593kosak// Fortunately, we don't have to do that, as we are already testing 15261cc9514de5a9b361e7a000eb34da9175b6de0593kosak// the functionalities of the Test class extensively by using Google Test 15271cc9514de5a9b361e7a000eb34da9175b6de0593kosak// alone. 15281cc9514de5a9b361e7a000eb34da9175b6de0593kosak// 15291cc9514de5a9b361e7a000eb34da9175b6de0593kosak// Therefore, this section only contains one test. 15301cc9514de5a9b361e7a000eb34da9175b6de0593kosak 1531d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that GTestFlagSaver works on Windows and Mac. 1532d201456903f3ecae1f7794edfab0d5678e64226shiqian 15339b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass GTestFlagSaverTest : public Test { 1534d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 1535d201456903f3ecae1f7794edfab0d5678e64226shiqian // Saves the Google Test flags such that we can restore them later, and 1536d201456903f3ecae1f7794edfab0d5678e64226shiqian // then sets them to their default values. This will be called 1537d201456903f3ecae1f7794edfab0d5678e64226shiqian // before the first test in this test case is run. 1538d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 15399b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian saver_ = new GTestFlagSaver; 15409b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1541fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 15429b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = false; 15439b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = false; 154453e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 15459b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "auto"; 15469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = ""; 15479b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = false; 15489b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = ""; 1549f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 15508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 15519b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 1; 15528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 1553bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 1554a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = ""; 155540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 1556d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1557d201456903f3ecae1f7794edfab0d5678e64226shiqian 1558d201456903f3ecae1f7794edfab0d5678e64226shiqian // Restores the Google Test flags that the tests have modified. This will 1559d201456903f3ecae1f7794edfab0d5678e64226shiqian // be called after the last test in this test case is run. 1560d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 1561d201456903f3ecae1f7794edfab0d5678e64226shiqian delete saver_; 1562d201456903f3ecae1f7794edfab0d5678e64226shiqian saver_ = NULL; 1563d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1564d201456903f3ecae1f7794edfab0d5678e64226shiqian 1565d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the Google Test flags have their default values, and then 1566d201456903f3ecae1f7794edfab0d5678e64226shiqian // modifies each of them. 1567d201456903f3ecae1f7794edfab0d5678e64226shiqian void VerifyAndModifyFlags() { 1568fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_FALSE(GTEST_FLAG(also_run_disabled_tests)); 15699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(break_on_failure)); 15709b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(catch_exceptions)); 15719b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("auto", GTEST_FLAG(color).c_str()); 157253e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_FALSE(GTEST_FLAG(death_test_use_fork)); 15739b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(filter).c_str()); 15749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(GTEST_FLAG(list_tests)); 15759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_STREQ("", GTEST_FLAG(output).c_str()); 1576f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan EXPECT_TRUE(GTEST_FLAG(print_time)); 15778bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(0, GTEST_FLAG(random_seed)); 15789b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_EQ(1, GTEST_FLAG(repeat)); 15798bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_FALSE(GTEST_FLAG(shuffle)); 1580bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(kMaxStackTraceDepth, GTEST_FLAG(stack_trace_depth)); 1581a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_STREQ("", GTEST_FLAG(stream_result_to).c_str()); 158240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan EXPECT_FALSE(GTEST_FLAG(throw_on_failure)); 15839b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian 1584fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = true; 15859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(break_on_failure) = true; 15869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(catch_exceptions) = true; 15879b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(color) = "no"; 158853e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = true; 15899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(filter) = "abc"; 15909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(list_tests) = true; 15919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(output) = "xml:foo.xml"; 1592f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = false; 15938bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 1; 15949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian GTEST_FLAG(repeat) = 100; 15958bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = true; 1596bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = 1; 1597a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = "localhost:1234"; 159840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = true; 1599d201456903f3ecae1f7794edfab0d5678e64226shiqian } 16008965a6a0d2165f32e6413594bba6367f271f51e7vladlosev 1601d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 1602d201456903f3ecae1f7794edfab0d5678e64226shiqian // For saving Google Test flags during this test case. 16039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian static GTestFlagSaver* saver_; 1604d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 1605d201456903f3ecae1f7794edfab0d5678e64226shiqian 16069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianGTestFlagSaver* GTestFlagSaverTest::saver_ = NULL; 1607d201456903f3ecae1f7794edfab0d5678e64226shiqian 1608d201456903f3ecae1f7794edfab0d5678e64226shiqian// Google Test doesn't guarantee the order of tests. The following two 1609d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests are designed to work regardless of their order. 1610d201456903f3ecae1f7794edfab0d5678e64226shiqian 1611d201456903f3ecae1f7794edfab0d5678e64226shiqian// Modifies the Google Test flags in the test body. 1612d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, ModifyGTestFlags) { 1613d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1614d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1615d201456903f3ecae1f7794edfab0d5678e64226shiqian 1616d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that the Google Test flags in the body of the previous test were 1617d201456903f3ecae1f7794edfab0d5678e64226shiqian// restored to their original values. 1618d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(GTestFlagSaverTest, VerifyGTestFlags) { 1619d201456903f3ecae1f7794edfab0d5678e64226shiqian VerifyAndModifyFlags(); 1620d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1621d201456903f3ecae1f7794edfab0d5678e64226shiqian 1622d201456903f3ecae1f7794edfab0d5678e64226shiqian// Sets an environment variable with the given name to the given 1623d201456903f3ecae1f7794edfab0d5678e64226shiqian// value. If the value argument is "", unsets the environment 1624d201456903f3ecae1f7794edfab0d5678e64226shiqian// variable. The caller must ensure that both arguments are not NULL. 1625d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic void SetEnv(const char* name, const char* value) { 1626b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if GTEST_OS_WINDOWS_MOBILE 1627d201456903f3ecae1f7794edfab0d5678e64226shiqian // Environment variables are not supported on Windows CE. 1628d201456903f3ecae1f7794edfab0d5678e64226shiqian return; 1629cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 1630c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder's putenv only stores a pointer to its parameter; we have to 1631c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ensure that the string remains valid as long as it might be needed. 1632c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We use an std::map to do so. 163387fdda2cf24d953f3cbec1e0c266b2db9928f406jgm static std::map<std::string, std::string*> added_env; 1634c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 1635c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Because putenv stores a pointer to the string buffer, we can't delete the 1636c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // previous string (if present) until after it's replaced. 163787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::string *prev_env = NULL; 1638c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan if (added_env.find(name) != added_env.end()) { 1639c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan prev_env = added_env[name]; 1640c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 164187fdda2cf24d953f3cbec1e0c266b2db9928f406jgm added_env[name] = new std::string( 164287fdda2cf24d953f3cbec1e0c266b2db9928f406jgm (Message() << name << "=" << value).GetString()); 1643cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev 1644cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // The standard signature of putenv accepts a 'char*' argument. Other 1645cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // implementations, like C++Builder's, accept a 'const char*'. 1646cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We cast away the 'const' since that would work for both variants. 1647cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev putenv(const_cast<char*>(added_env[name]->c_str())); 1648c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan delete prev_env; 16490af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#elif GTEST_OS_WINDOWS // If we are on Windows proper. 16509b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian _putenv((Message() << name << "=" << value).GetString().c_str()); 1651d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 1652d201456903f3ecae1f7794edfab0d5678e64226shiqian if (*value == '\0') { 1653d201456903f3ecae1f7794edfab0d5678e64226shiqian unsetenv(name); 1654d201456903f3ecae1f7794edfab0d5678e64226shiqian } else { 1655d201456903f3ecae1f7794edfab0d5678e64226shiqian setenv(name, value, 1); 1656d201456903f3ecae1f7794edfab0d5678e64226shiqian } 1657b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // GTEST_OS_WINDOWS_MOBILE 1658d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1659d201456903f3ecae1f7794edfab0d5678e64226shiqian 1660b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1661d201456903f3ecae1f7794edfab0d5678e64226shiqian// Environment variables are not supported on Windows CE. 1662d201456903f3ecae1f7794edfab0d5678e64226shiqian 16639b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianusing testing::internal::Int32FromGTestEnv; 1664d201456903f3ecae1f7794edfab0d5678e64226shiqian 1665d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests Int32FromGTestEnv(). 1666d201456903f3ecae1f7794edfab0d5678e64226shiqian 1667d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1668d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable is not set. 1669d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenVariableIsNotSet) { 16700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", ""); 1671d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(10, Int32FromGTestEnv("temp", 10)); 1672d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1673d201456903f3ecae1f7794edfab0d5678e64226shiqian 167441b5b28d4858530a94078a5204c9d393f520159dkosak# if !defined(GTEST_GET_INT32_FROM_ENV_) 167541b5b28d4858530a94078a5204c9d393f520159dkosak 1676d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1677d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable overflows as an Int32. 1678d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueOverflows) { 1679d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1680d201456903f3ecae1f7794edfab0d5678e64226shiqian 16810af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12345678987654321"); 1682d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(20, Int32FromGTestEnv("temp", 20)); 1683d201456903f3ecae1f7794edfab0d5678e64226shiqian 16840af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-12345678987654321"); 1685d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(30, Int32FromGTestEnv("temp", 30)); 1686d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1687d201456903f3ecae1f7794edfab0d5678e64226shiqian 1688d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() returns the default value when the 1689d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable does not represent a valid decimal integer. 1690d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ReturnsDefaultWhenValueIsInvalid) { 1691d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1692d201456903f3ecae1f7794edfab0d5678e64226shiqian 16930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "A1"); 1694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(40, Int32FromGTestEnv("temp", 40)); 1695d201456903f3ecae1f7794edfab0d5678e64226shiqian 16960af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "12X"); 1697d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(50, Int32FromGTestEnv("temp", 50)); 1698d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1699d201456903f3ecae1f7794edfab0d5678e64226shiqian 170041b5b28d4858530a94078a5204c9d393f520159dkosak# endif // !defined(GTEST_GET_INT32_FROM_ENV_) 170141b5b28d4858530a94078a5204c9d393f520159dkosak 1702d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Int32FromGTestEnv() parses and returns the value of the 1703d201456903f3ecae1f7794edfab0d5678e64226shiqian// environment variable when it represents a valid decimal integer in 1704d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1705d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Int32FromGTestEnvTest, ParsesAndReturnsValidValue) { 17060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "123"); 1707d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, Int32FromGTestEnv("temp", 0)); 1708d201456903f3ecae1f7794edfab0d5678e64226shiqian 17090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "TEMP", "-321"); 1710d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-321, Int32FromGTestEnv("temp", 0)); 1711d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1712b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 1713d201456903f3ecae1f7794edfab0d5678e64226shiqian 1714d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ParseInt32Flag(). 1715d201456903f3ecae1f7794edfab0d5678e64226shiqian 1716d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1717d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag has wrong format 1718d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsFalseForInvalidFlag) { 1719d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1720d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--a=100", "b", &value)); 1721d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1722d201456903f3ecae1f7794edfab0d5678e64226shiqian 1723d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("a=100", "a", &value)); 1724d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1725d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1726d201456903f3ecae1f7794edfab0d5678e64226shiqian 1727d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1728d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag overflows as an Int32. 1729d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueOverflows) { 1730d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1731d201456903f3ecae1f7794edfab0d5678e64226shiqian 1732d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1733d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12345678987654321", "abc", &value)); 1734d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1735d201456903f3ecae1f7794edfab0d5678e64226shiqian 1736d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=-12345678987654321", "abc", &value)); 1737d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1738d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1739d201456903f3ecae1f7794edfab0d5678e64226shiqian 1740d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() returns false and doesn't change the 1741d201456903f3ecae1f7794edfab0d5678e64226shiqian// output value when the flag does not represent a valid decimal 1742d201456903f3ecae1f7794edfab0d5678e64226shiqian// integer. 1743d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ReturnsDefaultWhenValueIsInvalid) { 1744d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("(expecting 2 warnings)\n"); 1745d201456903f3ecae1f7794edfab0d5678e64226shiqian 1746d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 1747d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=A1", "abc", &value)); 1748d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1749d201456903f3ecae1f7794edfab0d5678e64226shiqian 1750d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ParseInt32Flag("--abc=12X", "abc", &value)); 1751d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(123, value); 1752d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1753d201456903f3ecae1f7794edfab0d5678e64226shiqian 1754d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that ParseInt32Flag() parses the value of the flag and 1755d201456903f3ecae1f7794edfab0d5678e64226shiqian// returns true when the flag represents a valid decimal integer in 1756d201456903f3ecae1f7794edfab0d5678e64226shiqian// the range of an Int32. 1757d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) { 1758d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 value = 123; 17590af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=456", "abc", &value)); 1760d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(456, value); 1761d201456903f3ecae1f7794edfab0d5678e64226shiqian 1762c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_TRUE(ParseInt32Flag("--" GTEST_FLAG_PREFIX_ "abc=-789", 1763c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "abc", &value)); 1764d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(-789, value); 1765d201456903f3ecae1f7794edfab0d5678e64226shiqian} 1766d201456903f3ecae1f7794edfab0d5678e64226shiqian 1767cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() parses the value of the var or 1768cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// returns the correct default. 17694853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 1770b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1771cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { 17720af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 17730af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); 17740af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 17750af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "-123"); 17760af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan EXPECT_EQ(-123, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); 1777cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1778b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 1779cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1780cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1781cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable is not an Int32. 1782cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnFailure) { 17830af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "xxx"); 1784ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 1785600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1786600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1787cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1788cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1789cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that Int32FromEnvOrDie() aborts with an error message 1790cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// if the variable cannot be represnted by an Int32. 1791cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(Int32FromEnvOrDieDeathTest, AbortsOnInt32Overflow) { 17920af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan SetEnv(GTEST_FLAG_PREFIX_UPPER_ "VAR", "1234567891234567891234"); 1793ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED( 1794600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "VAR", 123), 1795600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan ".*"); 1796cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1797cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1798cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard() selects all tests 1799cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// where there is 1 shard. 1800cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereIsOneShard) { 1801cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 0)); 1802cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 1)); 1803cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 2)); 1804cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 3)); 1805cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldRunTestOnShard(1, 0, 4)); 1806cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1807cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1808cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanclass ShouldShardTest : public testing::Test { 1809cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan protected: 1810cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void SetUp() { 18110af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan index_var_ = GTEST_FLAG_PREFIX_UPPER_ "INDEX"; 18120af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan total_var_ = GTEST_FLAG_PREFIX_UPPER_ "TOTAL"; 1813cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1814cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1815cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan virtual void TearDown() { 1816cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1817cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1818cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1819cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1820cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* index_var_; 1821cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const char* total_var_; 1822cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan}; 1823cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1824cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is disabled if neither of the environment variables 1825cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// are set. 1826cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenNeitherEnvVarIsSet) { 1827cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1828cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1829cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1830cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1831cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1832cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1833cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1834cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is not enabled if total_shards == 1. 1835cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) { 1836cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1837cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "1"); 1838cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, false)); 1839cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1840cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1841cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1842cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that sharding is enabled if total_shards > 1 and 1843cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// we are not in a death test subprocess. 18444853a503371f39aa22e14adcdecea71c09841e34zhanyong.wan// Environment variables are not supported on Windows CE. 1845b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#if !GTEST_OS_WINDOWS_MOBILE 1846cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { 1847cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1848cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "22"); 1849cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1850cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1851cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1852cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "8"); 1853cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1854cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1855cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1856cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1857cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "0"); 1858cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "9"); 1859cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_TRUE(ShouldShard(total_var_, index_var_, false)); 1860cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_FALSE(ShouldShard(total_var_, index_var_, true)); 1861cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1862b50ef44a3527d958270ff1f08cb99e3ac633bd17zhanyong.wan#endif // !GTEST_OS_WINDOWS_MOBILE 1863cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1864cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that we exit in error if the sharding values are not valid. 1865600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1866600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wantypedef ShouldShardTest ShouldShardDeathTest; 1867600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wan 1868600105ee3ac48a01143486e5536a5b8fff5b5b25zhanyong.wanTEST_F(ShouldShardDeathTest, AbortsWhenShardingEnvVarsAreInvalid) { 1869cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1870cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "4"); 1871ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 1872cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1873cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "4"); 1874cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "-2"); 1875ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 1876cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1877cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, "5"); 1878cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, ""); 1879ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 1880cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1881cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(index_var_, ""); 1882cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan SetEnv(total_var_, "5"); 1883ed8500b341c473ecf46acd13951ae5b4e3acc780zhanyong.wan EXPECT_DEATH_IF_SUPPORTED(ShouldShard(total_var_, index_var_, false), ".*"); 1884cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1885cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1886cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// Tests that ShouldRunTestOnShard is a partition when 5 1887cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan// shards are used. 1888cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wanTEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { 1889cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Choose an arbitrary number of tests and shards. 1890cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_tests = 17; 1891cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan const int num_shards = 5; 1892cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1893cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check partitioning: each test should be on exactly 1 shard. 1894cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1895cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int prev_selected_shard_index = -1; 1896cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1897cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (ShouldRunTestOnShard(num_shards, shard_index, test_id)) { 1898cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan if (prev_selected_shard_index < 0) { 1899cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan prev_selected_shard_index = shard_index; 1900cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } else { 1901cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ADD_FAILURE() << "Shard " << prev_selected_shard_index << " and " 1902cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan << shard_index << " are both selected to run test " << test_id; 1903cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1904cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1905cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1906cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1907cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1908cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // Check balance: This is not required by the sharding protocol, but is a 1909cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan // desirable property for performance. 1910cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int shard_index = 0; shard_index < num_shards; shard_index++) { 1911cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan int num_tests_on_shard = 0; 1912cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan for (int test_id = 0; test_id < num_tests; test_id++) { 1913cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan num_tests_on_shard += 1914cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan ShouldRunTestOnShard(num_shards, shard_index, test_id); 1915cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1916cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan EXPECT_GE(num_tests_on_shard, num_tests / num_shards); 1917cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan } 1918cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan} 1919cd3e4016ea451c9ee5cb7925329f2611098cbcf9zhanyong.wan 1920d201456903f3ecae1f7794edfab0d5678e64226shiqian// For the same reason we are not explicitly testing everything in the 1921019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// Test class, there are no separate tests for the following classes 1922019d19af978f05b774407e0d46a3bda2c18c67c6shiqian// (except for some trivial cases): 1923d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1924d201456903f3ecae1f7794edfab0d5678e64226shiqian// TestCase, UnitTest, UnitTestResultPrinter. 1925d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1926d201456903f3ecae1f7794edfab0d5678e64226shiqian// Similarly, there are no separate tests for the following macros: 1927d201456903f3ecae1f7794edfab0d5678e64226shiqian// 1928d201456903f3ecae1f7794edfab0d5678e64226shiqian// TEST, TEST_F, RUN_ALL_TESTS 1929d201456903f3ecae1f7794edfab0d5678e64226shiqian 1930019d19af978f05b774407e0d46a3bda2c18c67c6shiqianTEST(UnitTestTest, CanGetOriginalWorkingDir) { 1931019d19af978f05b774407e0d46a3bda2c18c67c6shiqian ASSERT_TRUE(UnitTest::GetInstance()->original_working_dir() != NULL); 1932019d19af978f05b774407e0d46a3bda2c18c67c6shiqian EXPECT_STRNE(UnitTest::GetInstance()->original_working_dir(), ""); 1933019d19af978f05b774407e0d46a3bda2c18c67c6shiqian} 1934019d19af978f05b774407e0d46a3bda2c18c67c6shiqian 1935431a8be1662a3bc9601240914f412b0436d94703vladlosevTEST(UnitTestTest, ReturnsPlausibleTimestamp) { 1936431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_LT(0, UnitTest::GetInstance()->start_timestamp()); 1937431a8be1662a3bc9601240914f412b0436d94703vladlosev EXPECT_LE(UnitTest::GetInstance()->start_timestamp(), GetTimeInMillis()); 1938431a8be1662a3bc9601240914f412b0436d94703vladlosev} 1939431a8be1662a3bc9601240914f412b0436d94703vladlosev 1940f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// When a property using a reserved key is supplied to this function, it 1941f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// tests that a non-fatal failure is added, a fatal failure is not added, 1942f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// and that the property is not recorded. 1943f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevvoid ExpectNonFatalFailureRecordingPropertyWithReservedKey( 1944f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const TestResult& test_result, const char* key) { 1945f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_NONFATAL_FAILURE(Test::RecordProperty(key, "1"), "Reserved key"); 1946f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_EQ(0, test_result.test_property_count()) << "Property for key '" << key 1947f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev << "' recorded unexpectedly."; 1948f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 1949f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1950f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 1951f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const char* key) { 1952f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); 1953f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_TRUE(test_info != NULL); 1954f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKey(*test_info->result(), 1955f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev key); 1956f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 1957f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1958f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1959f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const char* key) { 1960f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); 1961f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_TRUE(test_case != NULL); 1962f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKey( 1963f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev test_case->ad_hoc_test_result(), key); 1964f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 1965f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1966f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevvoid ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 1967f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const char* key) { 1968f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKey( 1969f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTest::GetInstance()->ad_hoc_test_result(), key); 1970f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 1971f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1972f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// Tests that property recording functions in UnitTest outside of tests 1973f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// functions correcly. Creating a separate instance of UnitTest ensures it 1974f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// is in a state similar to the UnitTest's singleton's between tests. 1975f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevclass UnitTestRecordPropertyTest : 1976f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev public testing::internal::UnitTestRecordPropertyTestHelper { 1977f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev public: 1978f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev static void SetUpTestCase() { 1979f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1980f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "disabled"); 1981f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1982f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "errors"); 1983f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1984f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "failures"); 1985f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1986f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "name"); 1987f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1988f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "tests"); 1989f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( 1990f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "time"); 1991f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1992f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev Test::RecordProperty("test_case_key_1", "1"); 1993f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); 1994f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_TRUE(test_case != NULL); 1995f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 1996f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count()); 1997f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("test_case_key_1", 1998f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev test_case->ad_hoc_test_result().GetTestProperty(0).key()); 1999f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("1", 2000f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev test_case->ad_hoc_test_result().GetTestProperty(0).value()); 2001f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev } 2002f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev}; 2003f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2004f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// Tests TestResult has the expected property when added. 2005f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST_F(UnitTestRecordPropertyTest, OnePropertyFoundWhenAdded) { 2006f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_1", "1"); 2007f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2008f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_EQ(1, unit_test_.ad_hoc_test_result().test_property_count()); 2009f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2010f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("key_1", 2011f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 2012f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("1", 2013f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 2014f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 2015f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2016f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// Tests TestResult has multiple properties when added. 2017f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST_F(UnitTestRecordPropertyTest, MultiplePropertiesFoundWhenAdded) { 2018f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_1", "1"); 2019f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_2", "2"); 2020f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2021f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count()); 2022f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2023f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("key_1", 2024f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 2025f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("1", unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 2026f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2027f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("key_2", 2028f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(1).key()); 2029f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("2", unit_test_.ad_hoc_test_result().GetTestProperty(1).value()); 2030f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 2031f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2032f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// Tests TestResult::RecordProperty() overrides values for duplicate keys. 2033f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) { 2034f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_1", "1"); 2035f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_2", "2"); 2036f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_1", "12"); 2037f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev UnitTestRecordProperty("key_2", "22"); 2038f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2039f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ASSERT_EQ(2, unit_test_.ad_hoc_test_result().test_property_count()); 2040f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2041f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("key_1", 2042f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(0).key()); 2043f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("12", 2044f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(0).value()); 2045f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2046f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("key_2", 2047f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(1).key()); 2048f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_STREQ("22", 2049f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev unit_test_.ad_hoc_test_result().GetTestProperty(1).value()); 2050f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 2051f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2052f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST_F(UnitTestRecordPropertyTest, 2053f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev AddFailureInsideTestsWhenUsingTestCaseReservedKeys) { 2054f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2055f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "name"); 2056f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2057f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "value_param"); 2058f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2059f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "type_param"); 2060f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2061f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "status"); 2062f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2063f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "time"); 2064f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( 2065f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "classname"); 2066f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 2067f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2068f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevTEST_F(UnitTestRecordPropertyTest, 2069f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev AddRecordWithReservedKeysGeneratesCorrectPropertyList) { 2070f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev EXPECT_NONFATAL_FAILURE( 2071f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev Test::RecordProperty("name", "1"), 2072f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "'classname', 'name', 'status', 'time', 'type_param', and 'value_param'" 2073f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev " are reserved"); 2074f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev} 2075f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2076f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevclass UnitTestRecordPropertyTestEnvironment : public Environment { 2077f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev public: 2078f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev virtual void TearDown() { 2079f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2080f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "tests"); 2081f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2082f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "failures"); 2083f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2084f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "disabled"); 2085f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2086f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "errors"); 2087f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2088f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "name"); 2089f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2090f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "timestamp"); 2091f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2092f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "time"); 2093f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( 2094f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev "random_seed"); 2095f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev } 2096f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev}; 2097f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2098f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev// This will test property recording outside of any test or test case. 2099f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosevstatic Environment* record_property_env = 2100f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment); 2101f5fa71f728ce77c5d5c1a940a9bd8bb1d64c9f78vladlosev 2102d201456903f3ecae1f7794edfab0d5678e64226shiqian// This group of tests is for predicate assertions (ASSERT_PRED*, etc) 2103d201456903f3ecae1f7794edfab0d5678e64226shiqian// of various arities. They do not attempt to be exhaustive. Rather, 2104d201456903f3ecae1f7794edfab0d5678e64226shiqian// view them as smoke tests that can be easily reviewed and verified. 2105d201456903f3ecae1f7794edfab0d5678e64226shiqian// A more complete set of tests for predicate assertions can be found 2106d201456903f3ecae1f7794edfab0d5678e64226shiqian// in gtest_pred_impl_unittest.cc. 2107d201456903f3ecae1f7794edfab0d5678e64226shiqian 2108d201456903f3ecae1f7794edfab0d5678e64226shiqian// First, some predicates and predicate-formatters needed by the tests. 2109d201456903f3ecae1f7794edfab0d5678e64226shiqian 2110d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the argument is an even number. 2111d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsEven(int n) { 2112d201456903f3ecae1f7794edfab0d5678e64226shiqian return (n % 2) == 0; 2113d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2114d201456903f3ecae1f7794edfab0d5678e64226shiqian 2115d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the argument is an even number. 2116d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct IsEvenFunctor { 2117d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n) { return IsEven(n); } 2118d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2119d201456903f3ecae1f7794edfab0d5678e64226shiqian 2120d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the argument is an even 2121d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 21229b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertIsEven(const char* expr, int n) { 2123d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(n)) { 21249b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2125d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2126d201456903f3ecae1f7794edfab0d5678e64226shiqian 21279b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2128d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << expr << " evaluates to " << n << ", which is not even."; 21299b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2130d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2131d201456903f3ecae1f7794edfab0d5678e64226shiqian 2132bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// A predicate function that returns AssertionResult for use in 2133bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// EXPECT/ASSERT_TRUE/FALSE. 2134bad778caa39a88b7c11b159e20730aeec4fd711evladlosevAssertionResult ResultIsEven(int n) { 2135bad778caa39a88b7c11b159e20730aeec4fd711evladlosev if (IsEven(n)) 2136bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionSuccess() << n << " is even"; 2137bad778caa39a88b7c11b159e20730aeec4fd711evladlosev else 2138bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionFailure() << n << " is odd"; 2139bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 2140bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 2141bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// A predicate function that returns AssertionResult but gives no 2142bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// explanation why it succeeds. Needed for testing that 2143bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// EXPECT/ASSERT_FALSE handles such functions correctly. 2144bad778caa39a88b7c11b159e20730aeec4fd711evladlosevAssertionResult ResultIsEvenNoExplanation(int n) { 2145bad778caa39a88b7c11b159e20730aeec4fd711evladlosev if (IsEven(n)) 2146bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionSuccess(); 2147bad778caa39a88b7c11b159e20730aeec4fd711evladlosev else 2148bad778caa39a88b7c11b159e20730aeec4fd711evladlosev return AssertionFailure() << n << " is odd"; 2149bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 2150bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 2151d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the argument is an even 2152d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 2153d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertIsEvenFunctor { 21549b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()(const char* expr, int n) { 2155d201456903f3ecae1f7794edfab0d5678e64226shiqian return AssertIsEven(expr, n); 2156d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2157d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2158d201456903f3ecae1f7794edfab0d5678e64226shiqian 2159d201456903f3ecae1f7794edfab0d5678e64226shiqian// Returns true iff the sum of the arguments is an even number. 2160d201456903f3ecae1f7794edfab0d5678e64226shiqianbool SumIsEven2(int n1, int n2) { 2161d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2); 2162d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2163d201456903f3ecae1f7794edfab0d5678e64226shiqian 2164d201456903f3ecae1f7794edfab0d5678e64226shiqian// A functor that returns true iff the sum of the arguments is an even 2165d201456903f3ecae1f7794edfab0d5678e64226shiqian// number. 2166d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct SumIsEven3Functor { 2167d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator()(int n1, int n2, int n3) { 2168d201456903f3ecae1f7794edfab0d5678e64226shiqian return IsEven(n1 + n2 + n3); 2169d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2170d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2171d201456903f3ecae1f7794edfab0d5678e64226shiqian 2172d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter function that asserts the sum of the 2173d201456903f3ecae1f7794edfab0d5678e64226shiqian// arguments is an even number. 21749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianAssertionResult AssertSumIsEven4( 21759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 21769b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian int n1, int n2, int n3, int n4) { 2177d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4; 2178d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 21799b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2180d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2181d201456903f3ecae1f7794edfab0d5678e64226shiqian 21829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2183d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 2184d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" << n1 << " + " << n2 << " + " << n3 << " + " << n4 2185d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 21869b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2187d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2188d201456903f3ecae1f7794edfab0d5678e64226shiqian 2189d201456903f3ecae1f7794edfab0d5678e64226shiqian// A predicate-formatter functor that asserts the sum of the arguments 2190d201456903f3ecae1f7794edfab0d5678e64226shiqian// is an even number. 2191d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct AssertSumIsEven5Functor { 21929b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionResult operator()( 21939b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e1, const char* e2, const char* e3, const char* e4, 21949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const char* e5, int n1, int n2, int n3, int n4, int n5) { 2195d201456903f3ecae1f7794edfab0d5678e64226shiqian const int sum = n1 + n2 + n3 + n4 + n5; 2196d201456903f3ecae1f7794edfab0d5678e64226shiqian if (IsEven(sum)) { 21979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionSuccess(); 2198d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2199d201456903f3ecae1f7794edfab0d5678e64226shiqian 22009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 2201d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << e1 << " + " << e2 << " + " << e3 << " + " << e4 << " + " << e5 2202d201456903f3ecae1f7794edfab0d5678e64226shiqian << " (" 2203d201456903f3ecae1f7794edfab0d5678e64226shiqian << n1 << " + " << n2 << " + " << n3 << " + " << n4 << " + " << n5 2204d201456903f3ecae1f7794edfab0d5678e64226shiqian << ") evaluates to " << sum << ", which is not even."; 22059b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return AssertionFailure(msg); 2206d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2207d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2208d201456903f3ecae1f7794edfab0d5678e64226shiqian 2209d201456903f3ecae1f7794edfab0d5678e64226shiqian 2210d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions. 2211d201456903f3ecae1f7794edfab0d5678e64226shiqian 2212d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that don't use a custom formatter. 2213d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithoutFormat) { 2214d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2215d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEvenFunctor(), 2) << "This failure is UNEXPECTED!"; 2216d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsEven, 4); 2217d201456903f3ecae1f7794edfab0d5678e64226shiqian 2218d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2219d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2220d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, 5) << "This failure is expected."; 2221d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2222d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_PRED1(IsEvenFunctor(), 5), 2223d201456903f3ecae1f7794edfab0d5678e64226shiqian "evaluates to false"); 2224d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2225d201456903f3ecae1f7794edfab0d5678e64226shiqian 2226d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests unary predicate assertions that use a custom formatter. 2227d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, WithFormat) { 2228d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2229d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(AssertIsEven, 2); 2230d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), 4) 2231d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 2232d201456903f3ecae1f7794edfab0d5678e64226shiqian 2233d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2234d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n = 5; 2235d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT1(AssertIsEvenFunctor(), n), 2236d201456903f3ecae1f7794edfab0d5678e64226shiqian "n evaluates to 5, which is not even."); 2237d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2238d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEven, 5) << "This failure is expected."; 2239d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2240d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2241d201456903f3ecae1f7794edfab0d5678e64226shiqian 2242d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that unary predicate assertions evaluates their arguments 2243d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2244d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(Pred1Test, SingleEvaluationOnFailure) { 2245d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2246d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 2247d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsEven, n++); 2248d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n) << "The argument is not evaluated exactly once."; 2249d201456903f3ecae1f7794edfab0d5678e64226shiqian 2250d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2251d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2252d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(AssertIsEvenFunctor(), n++) 2253d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2254d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2255d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, n) << "The argument is not evaluated exactly once."; 2256d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2257d201456903f3ecae1f7794edfab0d5678e64226shiqian 2258d201456903f3ecae1f7794edfab0d5678e64226shiqian 2259d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions whose arity is >= 2. 2260d201456903f3ecae1f7794edfab0d5678e64226shiqian 2261d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that don't use a custom formatter. 2262d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithoutFormat) { 2263d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2264d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2(SumIsEven2, 2, 4) << "This failure is UNEXPECTED!"; 2265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), 4, 6, 8); 2266d201456903f3ecae1f7794edfab0d5678e64226shiqian 2267d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2268d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2269d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2270d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2271d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1, n2) << "This failure is expected."; 2272d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2273d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2274d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED3(SumIsEven3Functor(), 1, 2, 4); 2275d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to false"); 2276d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2277d201456903f3ecae1f7794edfab0d5678e64226shiqian 2278d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests predicate assertions that use a custom formatter. 2279d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, WithFormat) { 2280d201456903f3ecae1f7794edfab0d5678e64226shiqian // Success cases. 2281d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT4(AssertSumIsEven4, 4, 6, 8, 10) << 2282d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is UNEXPECTED!"; 2283d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2, 4, 6, 8, 10); 2284d201456903f3ecae1f7794edfab0d5678e64226shiqian 2285d201456903f3ecae1f7794edfab0d5678e64226shiqian // Failure cases. 2286d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n1 = 1; 2287d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n2 = 2; 2288d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n3 = 4; 2289d201456903f3ecae1f7794edfab0d5678e64226shiqian const int n4 = 6; 2290d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2291d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, n1, n2, n3, n4); 2292d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 13, which is not even."); 2293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2294d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 1, 2, 4, 6, 8) 2295d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2296d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2297d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2298d201456903f3ecae1f7794edfab0d5678e64226shiqian 2299d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that predicate assertions evaluates their arguments 2300d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 2301d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredTest, SingleEvaluationOnFailure) { 2302d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success case. 2303d201456903f3ecae1f7794edfab0d5678e64226shiqian int n1 = 0; 2304d201456903f3ecae1f7794edfab0d5678e64226shiqian int n2 = 0; 2305d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED2(SumIsEven2, n1++, n2++); 2306d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2307d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2308d201456903f3ecae1f7794edfab0d5678e64226shiqian 2309d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another success case. 2310d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = 0; 2311d201456903f3ecae1f7794edfab0d5678e64226shiqian int n3 = 0; 2312d201456903f3ecae1f7794edfab0d5678e64226shiqian int n4 = 0; 2313d201456903f3ecae1f7794edfab0d5678e64226shiqian int n5 = 0; 2314d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT5(AssertSumIsEven5Functor(), 2315d201456903f3ecae1f7794edfab0d5678e64226shiqian n1++, n2++, n3++, n4++, n5++) 2316d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is UNEXPECTED!"; 2317d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2318d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2319d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2320d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2321d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n5) << "Argument 5 is not evaluated exactly once."; 2322d201456903f3ecae1f7794edfab0d5678e64226shiqian 2323d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure case. 2324d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = 0; 2325d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2326d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED3(SumIsEven3Functor(), ++n1, n2++, n3++) 2327d201456903f3ecae1f7794edfab0d5678e64226shiqian << "This failure is expected."; 2328d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "This failure is expected."); 2329d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2330d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2331d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2332d201456903f3ecae1f7794edfab0d5678e64226shiqian 2333d201456903f3ecae1f7794edfab0d5678e64226shiqian // Another failure case. 2334d201456903f3ecae1f7794edfab0d5678e64226shiqian n1 = n2 = n3 = n4 = 0; 2335d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2336d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT4(AssertSumIsEven4, ++n1, n2++, n3++, n4++); 2337d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "evaluates to 1, which is not even."); 2338d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n1) << "Argument 1 is not evaluated exactly once."; 2339d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n2) << "Argument 2 is not evaluated exactly once."; 2340d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n3) << "Argument 3 is not evaluated exactly once."; 2341d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, n4) << "Argument 4 is not evaluated exactly once."; 2342d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2343d201456903f3ecae1f7794edfab0d5678e64226shiqian 2344d201456903f3ecae1f7794edfab0d5678e64226shiqian 2345d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2346d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PREDn and EXPECT_PREDn. 2347d201456903f3ecae1f7794edfab0d5678e64226shiqian 2348d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositive(double x) { 2349d201456903f3ecae1f7794edfab0d5678e64226shiqian return x > 0; 2350d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2351d201456903f3ecae1f7794edfab0d5678e64226shiqian 2352d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 2353d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsNegative(T x) { 2354d201456903f3ecae1f7794edfab0d5678e64226shiqian return x < 0; 2355d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2356d201456903f3ecae1f7794edfab0d5678e64226shiqian 2357d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 2358d201456903f3ecae1f7794edfab0d5678e64226shiqianbool GreaterThan(T1 x1, T2 x2) { 2359d201456903f3ecae1f7794edfab0d5678e64226shiqian return x1 > x2; 2360d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2361d201456903f3ecae1f7794edfab0d5678e64226shiqian 2362d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED* as long as 2363d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2364d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsOverloadedFunction) { 2365c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder requires C-style casts rather than static_cast. 2366c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED1((bool (*)(int))(IsPositive), 5); // NOLINT 2367c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED1((bool (*)(double))(IsPositive), 6.0); // NOLINT 2368d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2369d201456903f3ecae1f7794edfab0d5678e64226shiqian 2370d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED* as long as 2371d201456903f3ecae1f7794edfab0d5678e64226shiqian// their types are explicitly specified. 2372d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateAssertionTest, AcceptsTemplateFunction) { 2373d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsNegative<int>, -5); 2374d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes sure that we can handle templates with more than one 2375d201456903f3ecae1f7794edfab0d5678e64226shiqian // parameter. 2376d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED2((GreaterThan<int, int>), 5, 0); 2377d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2378d201456903f3ecae1f7794edfab0d5678e64226shiqian 2379d201456903f3ecae1f7794edfab0d5678e64226shiqian 2380d201456903f3ecae1f7794edfab0d5678e64226shiqian// Some helper functions for testing using overloaded/template 2381d201456903f3ecae1f7794edfab0d5678e64226shiqian// functions with ASSERT_PRED_FORMATn and EXPECT_PRED_FORMATn. 2382d201456903f3ecae1f7794edfab0d5678e64226shiqian 23834b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, int n) { 23849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return n > 0 ? AssertionSuccess() : 23859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2386d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2387d201456903f3ecae1f7794edfab0d5678e64226shiqian 23884b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsPositiveFormat(const char* /* expr */, double x) { 23899b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x > 0 ? AssertionSuccess() : 23909b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2391d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2392d201456903f3ecae1f7794edfab0d5678e64226shiqian 2393d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T> 23944b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult IsNegativeFormat(const char* /* expr */, T x) { 23959b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x < 0 ? AssertionSuccess() : 23969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2397d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2398d201456903f3ecae1f7794edfab0d5678e64226shiqian 2399d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename T1, typename T2> 24004b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wanAssertionResult EqualsFormat(const char* /* expr1 */, const char* /* expr2 */, 24019b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const T1& x1, const T2& x2) { 24029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian return x1 == x2 ? AssertionSuccess() : 24039b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian AssertionFailure(Message() << "Failure"); 2404d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2405d201456903f3ecae1f7794edfab0d5678e64226shiqian 2406d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that overloaded functions can be used in *_PRED_FORMAT* 24074b83461e9772cce62e84310060fe84172e9bf4bazhanyong.wan// without explicitly specifying their types. 2408d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsOverloadedFunction) { 2409d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsPositiveFormat, 5); 2410d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT1(IsPositiveFormat, 6.0); 2411d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2412d201456903f3ecae1f7794edfab0d5678e64226shiqian 2413d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that template functions can be used in *_PRED_FORMAT* without 2414d201456903f3ecae1f7794edfab0d5678e64226shiqian// explicitly specifying their types. 2415d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(PredicateFormatAssertionTest, AcceptsTemplateFunction) { 2416d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED_FORMAT1(IsNegativeFormat, -5); 2417d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED_FORMAT2(EqualsFormat, 3, 3); 2418d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2419d201456903f3ecae1f7794edfab0d5678e64226shiqian 2420d201456903f3ecae1f7794edfab0d5678e64226shiqian 2421d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests string assertions. 2422d201456903f3ecae1f7794edfab0d5678e64226shiqian 2423d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with non-NULL arguments. 2424d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ) { 2425d201456903f3ecae1f7794edfab0d5678e64226shiqian const char * const p1 = "good"; 2426d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p1); 2427d201456903f3ecae1f7794edfab0d5678e64226shiqian 2428d201456903f3ecae1f7794edfab0d5678e64226shiqian // Let p2 have the same content as p1, but be at a different address. 2429d201456903f3ecae1f7794edfab0d5678e64226shiqian const char p2[] = "good"; 2430d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1, p2); 2431d201456903f3ecae1f7794edfab0d5678e64226shiqian 2432d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"), 2433d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: \"bad\""); 2434d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2435d201456903f3ecae1f7794edfab0d5678e64226shiqian 2436d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2437d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null) { 2438d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const char *>(NULL), NULL); 2439d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ(NULL, "non-null"), 2440d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2441d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2442d201456903f3ecae1f7794edfab0d5678e64226shiqian 2443d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STREQ with NULL arguments. 2444d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STREQ_Null2) { 2445d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("non-null", NULL), 2446d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2447d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2448d201456903f3ecae1f7794edfab0d5678e64226shiqian 2449d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRNE. 2450d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRNE) { 2451d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("hi", "Hi"); 2452d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", NULL); 2453d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, "Hi"); 2454d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", NULL); 2455d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(NULL, ""); 2456d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("", "Hi"); 2457d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("Hi", ""); 2458d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("Hi", "Hi"), 2459d201456903f3ecae1f7794edfab0d5678e64226shiqian "\"Hi\" vs \"Hi\""); 2460d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2461d201456903f3ecae1f7794edfab0d5678e64226shiqian 2462d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASEEQ. 2463d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASEEQ) { 2464d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("hi", "Hi"); 2465d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ(static_cast<const char *>(NULL), NULL); 2466d201456903f3ecae1f7794edfab0d5678e64226shiqian 2467d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("", ""); 2468d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("Hi", "hi2"), 2469d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2470d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2471d201456903f3ecae1f7794edfab0d5678e64226shiqian 2472d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_STRCASENE. 2473d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, ASSERT_STRCASENE) { 2474d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("hi1", "Hi2"); 2475d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", NULL); 2476d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, "Hi"); 2477d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", NULL); 2478d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE(NULL, ""); 2479d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("", "Hi"); 2480d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("Hi", ""); 2481d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("Hi", "hi"), 2482d201456903f3ecae1f7794edfab0d5678e64226shiqian "(ignoring case)"); 2483d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2484d201456903f3ecae1f7794edfab0d5678e64226shiqian 2485d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STREQ on wide strings. 2486d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STREQ_Wide) { 2487d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2488d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(static_cast<const wchar_t *>(NULL), NULL); 2489d201456903f3ecae1f7794edfab0d5678e64226shiqian 2490d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2491d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(L"", L""); 2492d201456903f3ecae1f7794edfab0d5678e64226shiqian 2493d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2494d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"non-null", NULL), 2495d201456903f3ecae1f7794edfab0d5678e64226shiqian "non-null"); 2496d201456903f3ecae1f7794edfab0d5678e64226shiqian 2497d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2498d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(L"Hi", L"Hi"); 2499d201456903f3ecae1f7794edfab0d5678e64226shiqian 2500d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2501d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc", L"Abc"), 2502d201456903f3ecae1f7794edfab0d5678e64226shiqian "Abc"); 2503d201456903f3ecae1f7794edfab0d5678e64226shiqian 2504d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2505d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ(L"abc\x8119", L"abc\x8120"), 2506d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2507f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 2508f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm // The streaming variation. 2509f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE({ // NOLINT 2510f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_STREQ(L"abc\x8119", L"abc\x8121") << "Expected failure"; 2511f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm }, "Expected failure"); 2512d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2513d201456903f3ecae1f7794edfab0d5678e64226shiqian 2514d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests *_STRNE on wide strings. 2515d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StringAssertionTest, STRNE_Wide) { 2516d201456903f3ecae1f7794edfab0d5678e64226shiqian // NULL strings. 2517d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2518d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(static_cast<const wchar_t *>(NULL), NULL); 2519d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 2520d201456903f3ecae1f7794edfab0d5678e64226shiqian 2521d201456903f3ecae1f7794edfab0d5678e64226shiqian // Empty strings. 2522d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"", L""), 2523d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"\""); 2524d201456903f3ecae1f7794edfab0d5678e64226shiqian 2525d201456903f3ecae1f7794edfab0d5678e64226shiqian // Non-null vs NULL. 2526d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE(L"non-null", NULL); 2527d201456903f3ecae1f7794edfab0d5678e64226shiqian 2528d201456903f3ecae1f7794edfab0d5678e64226shiqian // Equal strings. 2529d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"Hi", L"Hi"), 2530d201456903f3ecae1f7794edfab0d5678e64226shiqian "L\"Hi\""); 2531d201456903f3ecae1f7794edfab0d5678e64226shiqian 2532d201456903f3ecae1f7794edfab0d5678e64226shiqian // Unequal strings. 2533d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(L"abc", L"Abc"); 2534d201456903f3ecae1f7794edfab0d5678e64226shiqian 2535d201456903f3ecae1f7794edfab0d5678e64226shiqian // Strings containing wide characters. 2536d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE(L"abc\x8119", L"abc\x8119"), 2537d201456903f3ecae1f7794edfab0d5678e64226shiqian "abc"); 2538f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 2539f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm // The streaming variation. 2540f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_STRNE(L"abc\x8119", L"abc\x8120") << "This shouldn't happen"; 2541d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2542d201456903f3ecae1f7794edfab0d5678e64226shiqian 2543d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsSubstring(). 2544d201456903f3ecae1f7794edfab0d5678e64226shiqian 2545d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2546d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2547d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForCString) { 2548d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", NULL, "a")); 2549d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "b", NULL)); 2550d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", "needle", "haystack")); 2551d201456903f3ecae1f7794edfab0d5678e64226shiqian 2552d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const char*>(NULL), NULL)); 2553d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", "needle", "two needles")); 2554d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2555d201456903f3ecae1f7794edfab0d5678e64226shiqian 2556d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() returns the correct result when the input 2557d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2558d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForWideCString) { 2559c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", kNull, L"a")); 2560c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FALSE(IsSubstring("", "", L"b", kNull)); 2561d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", L"haystack")); 2562d201456903f3ecae1f7794edfab0d5678e64226shiqian 2563d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", static_cast<const wchar_t*>(NULL), NULL)); 2564d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", L"needle", L"two needles")); 2565d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2566d201456903f3ecae1f7794edfab0d5678e64226shiqian 2567d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2568d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2569d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForCString) { 2570d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2571d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2572d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2573d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"haystack\"", 25749b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring("needle_expr", "haystack_expr", 25759b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian "needle", "haystack").failure_message()); 2576d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2577d201456903f3ecae1f7794edfab0d5678e64226shiqian 2578d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2579d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2580d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultsForStdString) { 25819b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_TRUE(IsSubstring("", "", std::string("hello"), "ahellob")); 25829b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_FALSE(IsSubstring("", "", "hello", std::string("world"))); 2583d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2584d201456903f3ecae1f7794edfab0d5678e64226shiqian 2585d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2586d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring returns the correct result when the input 2587d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2588d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, ReturnsCorrectResultForStdWstring) { 2589d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2590d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2591d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2592d201456903f3ecae1f7794edfab0d5678e64226shiqian 2593d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsSubstring() generates the correct message when the input 2594d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2595d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsSubstringTest, GeneratesCorrectMessageForWstring) { 2596d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2597d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2598d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: a substring of haystack_expr\n" 2599d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"haystack\"", 26009b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsSubstring( 2601d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2602d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring(L"needle"), L"haystack").failure_message()); 2603d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2604d201456903f3ecae1f7794edfab0d5678e64226shiqian 2605d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2606d201456903f3ecae1f7794edfab0d5678e64226shiqian 2607d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for ::testing::IsNotSubstring(). 2608d201456903f3ecae1f7794edfab0d5678e64226shiqian 2609d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2610d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const char*. 2611d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForCString) { 2612d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "needle", "haystack")); 2613d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", "needle", "two needles")); 2614d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2615d201456903f3ecae1f7794edfab0d5678e64226shiqian 2616d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() returns the correct result when the input 2617d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2618d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForWideCString) { 2619d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", L"haystack")); 2620d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", L"needle", L"two needles")); 2621d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2622d201456903f3ecae1f7794edfab0d5678e64226shiqian 2623d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2624d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is const wchar_t*. 2625d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForWideCString) { 2626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2627d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L\"needle\"\n" 2628d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2629d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L\"two needles\"", 26309b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2631d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2632d201456903f3ecae1f7794edfab0d5678e64226shiqian L"needle", L"two needles").failure_message()); 2633d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2634d201456903f3ecae1f7794edfab0d5678e64226shiqian 2635d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2636d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2637d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultsForStdString) { 2638d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(IsNotSubstring("", "", std::string("hello"), "ahellob")); 2639d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", "hello", std::string("world"))); 2640d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2641d201456903f3ecae1f7794edfab0d5678e64226shiqian 2642d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring() generates the correct message when the input 2643d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::string. 2644d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, GeneratesCorrectMessageForStdString) { 2645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Value of: needle_expr\n" 2646d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"needle\"\n" 2647d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: not a substring of haystack_expr\n" 2648d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"two needles\"", 26499b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian IsNotSubstring( 2650d201456903f3ecae1f7794edfab0d5678e64226shiqian "needle_expr", "haystack_expr", 2651d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::string("needle"), "two needles").failure_message()); 2652d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2653d201456903f3ecae1f7794edfab0d5678e64226shiqian 2654d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 2655d201456903f3ecae1f7794edfab0d5678e64226shiqian 2656d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that IsNotSubstring returns the correct result when the input 2657d201456903f3ecae1f7794edfab0d5678e64226shiqian// argument type is ::std::wstring. 2658d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(IsNotSubstringTest, ReturnsCorrectResultForStdWstring) { 2659d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE( 2660d201456903f3ecae1f7794edfab0d5678e64226shiqian IsNotSubstring("", "", ::std::wstring(L"needle"), L"two needles")); 2661d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(IsNotSubstring("", "", L"needle", ::std::wstring(L"haystack"))); 2662d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2663d201456903f3ecae1f7794edfab0d5678e64226shiqian 2664d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 2665d201456903f3ecae1f7794edfab0d5678e64226shiqian 2666d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests floating-point assertions. 2667d201456903f3ecae1f7794edfab0d5678e64226shiqian 2668d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 26699b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FloatingPointTest : public Test { 2670d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 2671c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Pre-calculated numbers to be used by the tests. 2672c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan struct TestValues { 2673c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_positive_zero; 2674c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_negative_zero; 2675c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_negative_zero; 2676c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2677c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_one; 2678c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_one; 2679c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2680c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType infinity; 2681c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType close_to_infinity; 2682c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType further_from_infinity; 2683c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2684c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan1; 2685c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan RawType nan2; 2686c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }; 2687c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2688d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename testing::internal::FloatingPoint<RawType> Floating; 2689d201456903f3ecae1f7794edfab0d5678e64226shiqian typedef typename Floating::Bits Bits; 2690d201456903f3ecae1f7794edfab0d5678e64226shiqian 2691d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 2692d201456903f3ecae1f7794edfab0d5678e64226shiqian const size_t max_ulps = Floating::kMaxUlps; 2693d201456903f3ecae1f7794edfab0d5678e64226shiqian 2694d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 0.0. 2695d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits zero_bits = Floating(0).bits(); 2696d201456903f3ecae1f7794edfab0d5678e64226shiqian 2697d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 0.0. 2698c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_positive_zero = Floating::ReinterpretBits( 2699c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan zero_bits + max_ulps/2); 2700c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_negative_zero = -Floating::ReinterpretBits( 2701d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps - max_ulps/2); 2702c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_negative_zero = -Floating::ReinterpretBits( 2703d201456903f3ecae1f7794edfab0d5678e64226shiqian zero_bits + max_ulps + 1 - max_ulps/2); 2704d201456903f3ecae1f7794edfab0d5678e64226shiqian 2705d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent 1.0. 2706d201456903f3ecae1f7794edfab0d5678e64226shiqian const Bits one_bits = Floating(1).bits(); 2707d201456903f3ecae1f7794edfab0d5678e64226shiqian 2708d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to 1.0. 2709c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_one = Floating::ReinterpretBits(one_bits + max_ulps); 2710c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_one = Floating::ReinterpretBits( 2711c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan one_bits + max_ulps + 1); 2712d201456903f3ecae1f7794edfab0d5678e64226shiqian 2713d201456903f3ecae1f7794edfab0d5678e64226shiqian // +infinity. 2714c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.infinity = Floating::Infinity(); 2715d201456903f3ecae1f7794edfab0d5678e64226shiqian 2716d201456903f3ecae1f7794edfab0d5678e64226shiqian // The bits that represent +infinity. 2717c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan const Bits infinity_bits = Floating(values_.infinity).bits(); 2718d201456903f3ecae1f7794edfab0d5678e64226shiqian 2719d201456903f3ecae1f7794edfab0d5678e64226shiqian // Makes some numbers close to infinity. 2720c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.close_to_infinity = Floating::ReinterpretBits( 2721c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan infinity_bits - max_ulps); 2722c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.further_from_infinity = Floating::ReinterpretBits( 2723d201456903f3ecae1f7794edfab0d5678e64226shiqian infinity_bits - max_ulps - 1); 2724d201456903f3ecae1f7794edfab0d5678e64226shiqian 2725c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // Makes some NAN's. Sets the most significant bit of the fraction so that 2726c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // our NaN's are quiet; trying to process a signaling NaN would raise an 2727c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // exception if our environment enables floating point exceptions. 2728c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan1 = Floating::ReinterpretBits(Floating::kExponentBitMask 2729c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 1); 2730c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan values_.nan2 = Floating::ReinterpretBits(Floating::kExponentBitMask 2731c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan | (static_cast<Bits>(1) << (Floating::kFractionBitCount - 1)) | 200); 2732d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2733d201456903f3ecae1f7794edfab0d5678e64226shiqian 2734d201456903f3ecae1f7794edfab0d5678e64226shiqian void TestSize() { 2735d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(sizeof(RawType), sizeof(Bits)); 2736d201456903f3ecae1f7794edfab0d5678e64226shiqian } 2737d201456903f3ecae1f7794edfab0d5678e64226shiqian 2738c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan static TestValues values_; 2739d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 2740d201456903f3ecae1f7794edfab0d5678e64226shiqian 2741d201456903f3ecae1f7794edfab0d5678e64226shiqiantemplate <typename RawType> 2742c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wantypename FloatingPointTest<RawType>::TestValues 2743c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan FloatingPointTest<RawType>::values_; 2744d201456903f3ecae1f7794edfab0d5678e64226shiqian 2745d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_FLOAT_EQ. 2746d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<float> FloatTest; 2747d201456903f3ecae1f7794edfab0d5678e64226shiqian 2748d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Float::Bits matches the size of float. 2749d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Size) { 2750d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2751d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2752d201456903f3ecae1f7794edfab0d5678e64226shiqian 2753d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2754d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Zeros) { 2755d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, -0.0); 2756d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(-0.0, 1.0), 2757d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2758d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.5), 2759d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.5"); 2760d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2761d201456903f3ecae1f7794edfab0d5678e64226shiqian 2762d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2763d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2764d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_FLOAT_EQ handles the sign correctly and no 2765d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2766d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2767d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, AlmostZeros) { 2768c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2769c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2770c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2771cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2772cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2773cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2774cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const FloatTest::TestValues& v = this->values_; 2775c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2776c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(0.0, v.close_to_positive_zero); 2777c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-0.0, v.close_to_negative_zero); 2778c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2779d201456903f3ecae1f7794edfab0d5678e64226shiqian 2780d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2781c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(v.close_to_positive_zero, 2782c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2783c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2784d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2785d201456903f3ecae1f7794edfab0d5678e64226shiqian 2786d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2787d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, SmallDiff) { 2788c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(1.0, values_.close_to_one); 2789c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, values_.further_from_one), 2790c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2791d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2792d201456903f3ecae1f7794edfab0d5678e64226shiqian 2793d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2794d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, LargeDiff) { 2795d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(2.5, 3.0), 2796d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2797d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2798d201456903f3ecae1f7794edfab0d5678e64226shiqian 2799d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2800d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2801d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2802d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2803d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Infinity) { 2804c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity); 2805c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity); 28060af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2807e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2808c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity), 2809c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2810d201456903f3ecae1f7794edfab0d5678e64226shiqian 2811c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This is interesting as the representations of infinity and nan1 2812d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2813c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, values_.nan1), 2814c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 28150af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2816d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2817d201456903f3ecae1f7794edfab0d5678e64226shiqian 2818d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2819d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, NaN) { 28200af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2821e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Nokia's STLport crashes if we try to output infinity or NaN. 2822c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2823c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2824c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2825c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2826cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2827cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2828cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2829cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const FloatTest::TestValues& v = this->values_; 2830c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2831c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), 2832c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2833c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), 2834c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan2"); 2835c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), 2836c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 2837c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2838c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), 2839c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 28400af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2841d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2842d201456903f3ecae1f7794edfab0d5678e64226shiqian 2843d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are reflexive. 2844d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Reflexive) { 2845d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(0.0, 0.0); 2846d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0); 2847c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_FLOAT_EQ(values_.infinity, values_.infinity); 2848d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2849d201456903f3ecae1f7794edfab0d5678e64226shiqian 2850d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_FLOAT_EQ are commutative. 2851d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, Commutative) { 2852c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.close_to_one). 2853c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FLOAT_EQ(values_.close_to_one, 1.0); 2854d201456903f3ecae1f7794edfab0d5678e64226shiqian 2855c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_FLOAT_EQ(1.0, values_.further_from_one). 2856c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.further_from_one, 1.0), 2857d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2858d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2859d201456903f3ecae1f7794edfab0d5678e64226shiqian 2860d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 2861d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, EXPECT_NEAR) { 2862d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0f, -1.1f, 0.2f); 2863d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0f, 3.0f, 1.0f); 2864e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 2865e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0f and 1.5f is 0.5, " 2866e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25f"); 2867d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2868d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2869d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2870d201456903f3ecae1f7794edfab0d5678e64226shiqian 2871d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 2872d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, ASSERT_NEAR) { 2873d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0f, -1.1f, 0.2f); 2874d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0f, 3.0f, 1.0f); 2875e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0f,1.5f, 0.25f), // NOLINT 2876e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0f and 1.5f is 0.5, " 2877e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25f"); 2878d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 2879d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous line. 2880d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2881d201456903f3ecae1f7794edfab0d5678e64226shiqian 2882d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should succeed. 2883d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLESucceeds) { 28849b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(FloatLE, 1.0f, 2.0f); // When val1 < val2, 28859b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(FloatLE, 1.0f, 1.0f); // val1 == val2, 2886d201456903f3ecae1f7794edfab0d5678e64226shiqian 2887d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 2888c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.close_to_positive_zero, 0.0f); 2889d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2890d201456903f3ecae1f7794edfab0d5678e64226shiqian 2891d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where FloatLE() should fail. 2892d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FloatTest, FloatLEFails) { 2893d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 28949b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(FloatLE, 2.0f, 1.0f), 2895d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0f) <= (1.0f)"); 2896d201456903f3ecae1f7794edfab0d5678e64226shiqian 2897d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 2898d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2899c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.further_from_one, 1.0f); 2900c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0f)"); 2901d201456903f3ecae1f7794edfab0d5678e64226shiqian 2902c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2903e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2904c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 2905c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 2906d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2907c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, values_.nan1, values_.infinity); 2908c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 2909d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 2910c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(FloatLE, -values_.infinity, values_.nan1); 2911c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(-values_.infinity) <= (values_.nan1)"); 2912d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2913c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(FloatLE, values_.nan1, values_.nan1); 2914c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 2915c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 2916d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2917d201456903f3ecae1f7794edfab0d5678e64226shiqian 2918d201456903f3ecae1f7794edfab0d5678e64226shiqian// Instantiates FloatingPointTest for testing *_DOUBLE_EQ. 2919d201456903f3ecae1f7794edfab0d5678e64226shiqiantypedef FloatingPointTest<double> DoubleTest; 2920d201456903f3ecae1f7794edfab0d5678e64226shiqian 2921d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the size of Double::Bits matches the size of double. 2922d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Size) { 2923d201456903f3ecae1f7794edfab0d5678e64226shiqian TestSize(); 2924d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2925d201456903f3ecae1f7794edfab0d5678e64226shiqian 2926d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with +0 and -0. 2927d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Zeros) { 2928d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, -0.0); 2929d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(-0.0, 1.0), 2930d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2931d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(0.0, 1.0), 2932d201456903f3ecae1f7794edfab0d5678e64226shiqian "1.0"); 2933d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2934d201456903f3ecae1f7794edfab0d5678e64226shiqian 2935d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to 0. 2936d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2937d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that *_DOUBLE_EQ handles the sign correctly and no 2938d201456903f3ecae1f7794edfab0d5678e64226shiqian// overflow occurs when comparing numbers whose absolute value is very 2939d201456903f3ecae1f7794edfab0d5678e64226shiqian// small. 2940d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, AlmostZeros) { 2941c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2942c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2943c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2944cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2945cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2946cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 2947cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const DoubleTest::TestValues& v = this->values_; 2948c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 2949c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(0.0, v.close_to_positive_zero); 2950c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-0.0, v.close_to_negative_zero); 2951c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(v.close_to_positive_zero, v.close_to_negative_zero); 2952d201456903f3ecae1f7794edfab0d5678e64226shiqian 2953d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 2954c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(v.close_to_positive_zero, 2955c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan v.further_from_negative_zero); 2956c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "v.further_from_negative_zero"); 2957d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2958d201456903f3ecae1f7794edfab0d5678e64226shiqian 2959d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers close to each other. 2960d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, SmallDiff) { 2961c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(1.0, values_.close_to_one); 2962c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, values_.further_from_one), 2963c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.further_from_one"); 2964d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2965d201456903f3ecae1f7794edfab0d5678e64226shiqian 2966d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing numbers far apart. 2967d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, LargeDiff) { 2968d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(2.0, 3.0), 2969d201456903f3ecae1f7794edfab0d5678e64226shiqian "3.0"); 2970d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2971d201456903f3ecae1f7794edfab0d5678e64226shiqian 2972d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests comparing with infinity. 2973d201456903f3ecae1f7794edfab0d5678e64226shiqian// 2974d201456903f3ecae1f7794edfab0d5678e64226shiqian// This ensures that no overflow occurs when comparing numbers whose 2975d201456903f3ecae1f7794edfab0d5678e64226shiqian// absolute value is very large. 2976d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Infinity) { 2977c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity); 2978c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity); 29790af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2980e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 2981c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity), 2982c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "-values_.infinity"); 2983d201456903f3ecae1f7794edfab0d5678e64226shiqian 2984d201456903f3ecae1f7794edfab0d5678e64226shiqian // This is interesting as the representations of infinity_ and nan1_ 2985d201456903f3ecae1f7794edfab0d5678e64226shiqian // are only 1 DLP apart. 2986c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, values_.nan1), 2987c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "values_.nan1"); 29880af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 2989d201456903f3ecae1f7794edfab0d5678e64226shiqian} 2990d201456903f3ecae1f7794edfab0d5678e64226shiqian 2991d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that comparing with NAN always returns false. 2992d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, NaN) { 29930af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 2994c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // In C++Builder, names within local classes (such as used by 2995c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // EXPECT_FATAL_FAILURE) cannot be resolved against static members of the 2996c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // scoping class. Use a static local alias as a workaround. 2997cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // We use the assignment syntax since some compilers, like Sun Studio, 2998cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // don't allow initializing references using construction syntax 2999cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev // (parentheses). 3000cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev static const DoubleTest::TestValues& v = this->values_; 3001c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3002e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3003c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), 3004c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.nan1"); 3005c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2"); 3006c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1"); 3007c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), 3008c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "v.infinity"); 30090af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3010d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3011d201456903f3ecae1f7794edfab0d5678e64226shiqian 3012d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are reflexive. 3013d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Reflexive) { 3014d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(0.0, 0.0); 3015d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_DOUBLE_EQ(1.0, 1.0); 30160af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if !GTEST_OS_SYMBIAN 3017e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3018c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_DOUBLE_EQ(values_.infinity, values_.infinity); 30190af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // !GTEST_OS_SYMBIAN 3020d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3021d201456903f3ecae1f7794edfab0d5678e64226shiqian 3022d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that *_DOUBLE_EQ are commutative. 3023d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, Commutative) { 3024c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.close_to_one). 3025c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_DOUBLE_EQ(values_.close_to_one, 1.0); 3026d201456903f3ecae1f7794edfab0d5678e64226shiqian 3027c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // We already tested EXPECT_DOUBLE_EQ(1.0, values_.further_from_one). 3028c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.further_from_one, 1.0), 3029c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "1.0"); 3030d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3031d201456903f3ecae1f7794edfab0d5678e64226shiqian 3032d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NEAR. 3033d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, EXPECT_NEAR) { 3034d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(-1.0, -1.1, 0.2); 3035d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NEAR(2.0, 3.0, 1.0); 3036e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25), // NOLINT 3037e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0 and 1.5 is 0.5, " 3038e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25"); 3039d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 3040d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 3041d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3042d201456903f3ecae1f7794edfab0d5678e64226shiqian 3043d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NEAR. 3044d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, ASSERT_NEAR) { 3045d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(-1.0, -1.1, 0.2); 3046d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NEAR(2.0, 3.0, 1.0); 3047e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NEAR(1.0, 1.5, 0.25), // NOLINT 3048e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "The difference between 1.0 and 1.5 is 0.5, " 3049e92ccedad996eeb4f0d9244a1acd8882b5f54fd0zhanyong.wan "which exceeds 0.25"); 3050d201456903f3ecae1f7794edfab0d5678e64226shiqian // To work around a bug in gcc 2.95.0, there is intentionally no 3051d201456903f3ecae1f7794edfab0d5678e64226shiqian // space after the first comma in the previous statement. 3052d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3053d201456903f3ecae1f7794edfab0d5678e64226shiqian 3054d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should succeed. 3055d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLESucceeds) { 30569b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_PRED_FORMAT2(DoubleLE, 1.0, 2.0); // When val1 < val2, 30579b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian ASSERT_PRED_FORMAT2(DoubleLE, 1.0, 1.0); // val1 == val2, 3058d201456903f3ecae1f7794edfab0d5678e64226shiqian 3059d201456903f3ecae1f7794edfab0d5678e64226shiqian // or when val1 is greater than, but almost equals to, val2. 3060c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.close_to_positive_zero, 0.0); 3061d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3062d201456903f3ecae1f7794edfab0d5678e64226shiqian 3063d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the cases where DoubleLE() should fail. 3064d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DoubleTest, DoubleLEFails) { 3065d201456903f3ecae1f7794edfab0d5678e64226shiqian // When val1 is greater than val2 by a large margin, 30669b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED_FORMAT2(DoubleLE, 2.0, 1.0), 3067d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2.0) <= (1.0)"); 3068d201456903f3ecae1f7794edfab0d5678e64226shiqian 3069d201456903f3ecae1f7794edfab0d5678e64226shiqian // or by a small yet non-negligible margin, 3070d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3071c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.further_from_one, 1.0); 3072c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.further_from_one) <= (1.0)"); 3073d201456903f3ecae1f7794edfab0d5678e64226shiqian 3074c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#if !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 3075e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian // Nokia's STLport crashes if we try to output infinity or NaN. 3076c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // C++Builder gives bad results for ordered comparisons involving NaNs 3077c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // due to compiler bugs. 3078d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3079c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.infinity); 3080c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.infinity)"); 3081d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 3082c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_PRED_FORMAT2(DoubleLE, -values_.infinity, values_.nan1); 3083c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, " (-values_.infinity) <= (values_.nan1)"); 3084d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 3085c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan ASSERT_PRED_FORMAT2(DoubleLE, values_.nan1, values_.nan1); 3086c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan }, "(values_.nan1) <= (values_.nan1)"); 3087c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif // !GTEST_OS_SYMBIAN && !defined(__BORLANDC__) 3088d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3089d201456903f3ecae1f7794edfab0d5678e64226shiqian 3090d201456903f3ecae1f7794edfab0d5678e64226shiqian 3091d201456903f3ecae1f7794edfab0d5678e64226shiqian// Verifies that a test or test case whose name starts with DISABLED_ is 3092d201456903f3ecae1f7794edfab0d5678e64226shiqian// not run. 3093d201456903f3ecae1f7794edfab0d5678e64226shiqian 3094d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name starts with DISABLED_. 3095d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3096d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, DISABLED_TestShouldNotRun) { 3097d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3098d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3099d201456903f3ecae1f7794edfab0d5678e64226shiqian 3100d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test whose name does not start with DISABLED_. 3101d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should run. 3102d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DisabledTest, NotDISABLED_TestShouldRun) { 3103d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1); 3104d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3105d201456903f3ecae1f7794edfab0d5678e64226shiqian 3106d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case whose name starts with DISABLED_. 3107d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3108d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, TestShouldNotRun) { 3109d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 3110d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3111d201456903f3ecae1f7794edfab0d5678e64226shiqian 3112d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test case and test whose names start with DISABLED_. 3113d201456903f3ecae1f7794edfab0d5678e64226shiqian// Should not run. 3114d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { 3115d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Test in disabled test case should not be run."; 3116d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3117d201456903f3ecae1f7794edfab0d5678e64226shiqian 3118d201456903f3ecae1f7794edfab0d5678e64226shiqian// Check that when all tests in a test case are disabled, SetupTestCase() and 3119d201456903f3ecae1f7794edfab0d5678e64226shiqian// TearDownTestCase() are not called. 31209b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass DisabledTestsTest : public Test { 3121d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 3122d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 3123d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 3124d201456903f3ecae1f7794edfab0d5678e64226shiqian "SetupTestCase() should not be called."; 3125d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3126d201456903f3ecae1f7794edfab0d5678e64226shiqian 3127d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 3128d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: All tests disabled in test case. " 3129d201456903f3ecae1f7794edfab0d5678e64226shiqian "TearDownTestCase() should not be called."; 3130d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3131d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3132d201456903f3ecae1f7794edfab0d5678e64226shiqian 3133d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_1) { 3134d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3135d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3136d201456903f3ecae1f7794edfab0d5678e64226shiqian 3137d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(DisabledTestsTest, DISABLED_TestShouldNotRun_2) { 3138d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Unexpected failure: Disabled test should not be run."; 3139d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3140d201456903f3ecae1f7794edfab0d5678e64226shiqian 3141a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled typed tests aren't run. 3142a2b1a8556ea64014606d78b09333d9c522430a25shiqian 31430af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST 3144a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3145a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3146a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTest : public Test { 3147a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3148a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3149a2b1a8556ea64014606d78b09333d9c522430a25shiqiantypedef testing::Types<int, double> NumericTypes; 3150a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(TypedTest, NumericTypes); 3151a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3152a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { 3153a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 3154a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3155a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3156a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3157a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTest : public Test { 3158a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3159a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3160a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); 3161a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3162a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { 3163a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: Disabled typed test should not run."; 3164a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3165a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3166a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST 3167a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3168a2b1a8556ea64014606d78b09333d9c522430a25shiqian// Tests that disabled type-parameterized tests aren't run. 3169a2b1a8556ea64014606d78b09333d9c522430a25shiqian 31700af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_HAS_TYPED_TEST_P 3171a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3172a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3173a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass TypedTestP : public Test { 3174a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3175a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3176a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(TypedTestP); 3177a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3178a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { 3179a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 3180a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 3181a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3182a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3183a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); 3184a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3185a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); 3186a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3187a2b1a8556ea64014606d78b09333d9c522430a25shiqiantemplate <typename T> 3188a2b1a8556ea64014606d78b09333d9c522430a25shiqianclass DISABLED_TypedTestP : public Test { 3189a2b1a8556ea64014606d78b09333d9c522430a25shiqian}; 3190a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3191a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_CASE_P(DISABLED_TypedTestP); 3192a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3193a2b1a8556ea64014606d78b09333d9c522430a25shiqianTYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { 3194a2b1a8556ea64014606d78b09333d9c522430a25shiqian FAIL() << "Unexpected failure: " 3195a2b1a8556ea64014606d78b09333d9c522430a25shiqian << "Disabled type-parameterized test should not run."; 3196a2b1a8556ea64014606d78b09333d9c522430a25shiqian} 3197a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3198a2b1a8556ea64014606d78b09333d9c522430a25shiqianREGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); 3199a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3200a2b1a8556ea64014606d78b09333d9c522430a25shiqianINSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); 3201a2b1a8556ea64014606d78b09333d9c522430a25shiqian 3202a2b1a8556ea64014606d78b09333d9c522430a25shiqian#endif // GTEST_HAS_TYPED_TEST_P 3203d201456903f3ecae1f7794edfab0d5678e64226shiqian 3204d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion macros evaluate their arguments exactly once. 3205d201456903f3ecae1f7794edfab0d5678e64226shiqian 32069b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SingleEvaluationTest : public Test { 32078de91f8f8374f49240b379e2328de9121837bae8tsunanet public: // Must be public and not protected due to a bug in g++ 3.4.2. 3208d201456903f3ecae1f7794edfab0d5678e64226shiqian // This helper function is needed by the FailedASSERT_STREQ test 3209c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // below. It's public to work around C++Builder's bug with scoping local 3210c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // classes. 3211d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementCharPtrs() { 3212d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(p1_++, p2_++); 3213d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3214d201456903f3ecae1f7794edfab0d5678e64226shiqian 3215c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // This helper function is needed by the FailedASSERT_NE test below. It's 3216c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // public to work around C++Builder's bug with scoping local classes. 3217d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CompareAndIncrementInts() { 3218d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(a_++, b_++); 3219d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3220d201456903f3ecae1f7794edfab0d5678e64226shiqian 3221c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan protected: 3222c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan SingleEvaluationTest() { 3223c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p1_ = s1_; 3224c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan p2_ = s2_; 3225c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan a_ = 0; 3226c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan b_ = 0; 3227c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan } 3228c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3229d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s1_; 3230d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* const s2_; 3231d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p1_; 3232d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* p2_; 3233d201456903f3ecae1f7794edfab0d5678e64226shiqian 3234d201456903f3ecae1f7794edfab0d5678e64226shiqian static int a_; 3235d201456903f3ecae1f7794edfab0d5678e64226shiqian static int b_; 3236d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3237d201456903f3ecae1f7794edfab0d5678e64226shiqian 3238d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s1_ = "01234"; 3239d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* const SingleEvaluationTest::s2_ = "abcde"; 3240d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p1_; 3241d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SingleEvaluationTest::p2_; 3242d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::a_; 3243d201456903f3ecae1f7794edfab0d5678e64226shiqianint SingleEvaluationTest::b_; 3244d201456903f3ecae1f7794edfab0d5678e64226shiqian 3245d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_STREQ fails, it evaluates its arguments 3246d201456903f3ecae1f7794edfab0d5678e64226shiqian// exactly once. 3247d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_STREQ) { 3248c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementCharPtrs(), 3249d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2_++"); 3250d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3251d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3252d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3253d201456903f3ecae1f7794edfab0d5678e64226shiqian 3254d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that string assertion arguments are evaluated exactly once. 3255d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, ASSERT_STR) { 3256d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_STRNE 3257d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(p1_++, p2_++); 3258d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 1, p1_); 3259d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 1, p2_); 3260d201456903f3ecae1f7794edfab0d5678e64226shiqian 3261d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_STRCASEEQ 3262d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ(p1_++, p2_++), 3263d201456903f3ecae1f7794edfab0d5678e64226shiqian "ignoring case"); 3264d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s1_ + 2, p1_); 3265d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(s2_ + 2, p2_); 3266d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3267d201456903f3ecae1f7794edfab0d5678e64226shiqian 3268d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that when ASSERT_NE fails, it evaluates its arguments exactly 3269d201456903f3ecae1f7794edfab0d5678e64226shiqian// once. 3270d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, FailedASSERT_NE) { 3271c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan EXPECT_FATAL_FAILURE(SingleEvaluationTest::CompareAndIncrementInts(), 3272c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan "(a_++) != (b_++)"); 3273d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3274d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3275d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3276d201456903f3ecae1f7794edfab0d5678e64226shiqian 3277d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that assertion arguments are evaluated exactly once. 3278d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SingleEvaluationTest, OtherCases) { 3279d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_TRUE 3280d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(0 == a_++); // NOLINT 3281d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, a_); 3282d201456903f3ecae1f7794edfab0d5678e64226shiqian 3283d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_TRUE 3284d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(-1 == a_++), "-1 == a_++"); 3285d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, a_); 3286d201456903f3ecae1f7794edfab0d5678e64226shiqian 3287d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful EXPECT_GT 3288d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(a_++, b_++); 3289d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, a_); 3290d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, b_); 3291d201456903f3ecae1f7794edfab0d5678e64226shiqian 3292d201456903f3ecae1f7794edfab0d5678e64226shiqian // failed EXPECT_LT 3293d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(a_++, b_++), "(a_++) < (b_++)"); 3294d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(4, a_); 3295d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(2, b_); 3296d201456903f3ecae1f7794edfab0d5678e64226shiqian 3297d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_TRUE 3298d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(0 < a_++); // NOLINT 3299d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, a_); 3300d201456903f3ecae1f7794edfab0d5678e64226shiqian 3301d201456903f3ecae1f7794edfab0d5678e64226shiqian // successful ASSERT_GT 3302d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(a_++, b_++); 3303d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(6, a_); 3304d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(3, b_); 3305d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3306d201456903f3ecae1f7794edfab0d5678e64226shiqian 330736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 330836865d8d354465e3461eedf2949a4b7799985d5dshiqian 330936865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAnInteger() { 331036865d8d354465e3461eedf2949a4b7799985d5dshiqian throw 1; 331136865d8d354465e3461eedf2949a4b7799985d5dshiqian} 331236865d8d354465e3461eedf2949a4b7799985d5dshiqian 331336865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests that assertion arguments are evaluated exactly once. 331436865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST_F(SingleEvaluationTest, ExceptionTests) { 331536865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_THROW 331636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW({ // NOLINT 331736865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 331836865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 331936865d8d354465e3461eedf2949a4b7799985d5dshiqian }, int); 332036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(1, a_); 332136865d8d354465e3461eedf2949a4b7799985d5dshiqian 332236865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws different 332336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW({ // NOLINT 332436865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 332536865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 332636865d8d354465e3461eedf2949a4b7799985d5dshiqian }, bool), "throws a different type"); 332736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(2, a_); 332836865d8d354465e3461eedf2949a4b7799985d5dshiqian 332936865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_THROW, throws nothing 333036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(a_++, bool), "throws nothing"); 333136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(3, a_); 333236865d8d354465e3461eedf2949a4b7799985d5dshiqian 333336865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_NO_THROW 333436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(a_++); 333536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(4, a_); 333636865d8d354465e3461eedf2949a4b7799985d5dshiqian 333736865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_NO_THROW 333836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW({ // NOLINT 333936865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 334036865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 334136865d8d354465e3461eedf2949a4b7799985d5dshiqian }), "it throws"); 334236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(5, a_); 334336865d8d354465e3461eedf2949a4b7799985d5dshiqian 334436865d8d354465e3461eedf2949a4b7799985d5dshiqian // successful EXPECT_ANY_THROW 334536865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW({ // NOLINT 334636865d8d354465e3461eedf2949a4b7799985d5dshiqian a_++; 334736865d8d354465e3461eedf2949a4b7799985d5dshiqian ThrowAnInteger(); 334836865d8d354465e3461eedf2949a4b7799985d5dshiqian }); 334936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(6, a_); 335036865d8d354465e3461eedf2949a4b7799985d5dshiqian 335136865d8d354465e3461eedf2949a4b7799985d5dshiqian // failed EXPECT_ANY_THROW 335236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(a_++), "it doesn't"); 335336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_EQ(7, a_); 335436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 335536865d8d354465e3461eedf2949a4b7799985d5dshiqian 335636865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 3357d201456903f3ecae1f7794edfab0d5678e64226shiqian 3358e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian// Tests {ASSERT|EXPECT}_NO_FATAL_FAILURE. 3359e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianclass NoFatalFailureTest : public Test { 3360e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian protected: 3361e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Succeeds() {} 3362e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void FailsNonFatal() { 3363e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "some non-fatal failure"; 3364e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3365e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void Fails() { 3366e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian FAIL() << "some fatal failure"; 3367e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3368e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3369e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoAssertNoFatalFailureOnFails() { 3370e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Fails()); 3371e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "shold not reach here."; 3372e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3373e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3374e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian void DoExpectNoFatalFailureOnFails() { 3375e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Fails()); 3376e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ADD_FAILURE() << "other failure"; 3377e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3378e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian}; 3379e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3380e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NoFailure) { 3381e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(Succeeds()); 3382e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(Succeeds()); 3383e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3384e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3385e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, NonFatalIsNoFailure) { 3386e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3387e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FailsNonFatal()), 3388e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3389e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NONFATAL_FAILURE( 3390e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FailsNonFatal()), 3391e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian "some non-fatal failure"); 3392e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3393e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3394e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, AssertNoFatalFailureOnFatalFailure) { 3395e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3396e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3397e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3398e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoAssertNoFatalFailureOnFails(); 3399e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3400e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3401e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3402e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3403e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3404e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3405e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3406e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3407e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3408e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3409e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3410e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3411e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, ExpectNoFatalFailureOnFatalFailure) { 3412e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3413e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3414e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3415e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian DoExpectNoFatalFailureOnFails(); 3416e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3417e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(3, gtest_failures.size()); 3418e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kFatalFailure, 3419e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3420e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3421e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3422e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3423e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).type()); 3424e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "some fatal failure", 3425e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3426e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "it does", 3427e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3428e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "other failure", 3429e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(2).message()); 3430e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3431e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3432e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST_F(NoFatalFailureTest, MessageIsStreamable) { 3433e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian TestPartResultArray gtest_failures; 3434e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian { 3435e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ScopedFakeTestPartResultReporter gtest_reporter(>est_failures); 3436e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL() << "foo") << "my message"; 3437e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian } 3438e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_EQ(2, gtest_failures.size()); 3439e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3440e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).type()); 3441e5373af0cb9cae249e7bc618cae3483397332895zhanyong.wan EXPECT_EQ(TestPartResult::kNonFatalFailure, 3442e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).type()); 3443e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "foo", 3444e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(0).message()); 3445e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_PRED_FORMAT2(testing::IsSubstring, "my message", 3446e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian gtest_failures.GetTestPartResult(1).message()); 3447e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 3448e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 3449d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests non-string assertions. 3450d201456903f3ecae1f7794edfab0d5678e64226shiqian 3451b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakstd::string EditsToString(const std::vector<EditType>& edits) { 3452b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak std::string out; 3453b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak for (size_t i = 0; i < edits.size(); ++i) { 3454b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak static const char kEdits[] = " +-/"; 3455b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak out.append(1, kEdits[edits[i]]); 3456b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak } 3457b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak return out; 3458b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak} 3459b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak 3460b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakstd::vector<size_t> CharsToIndices(const std::string& str) { 3461b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak std::vector<size_t> out; 3462b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak for (size_t i = 0; i < str.size(); ++i) { 3463b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak out.push_back(str[i]); 3464b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak } 3465b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak return out; 3466b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak} 3467b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak 3468b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakstd::vector<std::string> CharsToLines(const std::string& str) { 3469b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak std::vector<std::string> out; 3470b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak for (size_t i = 0; i < str.size(); ++i) { 3471b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak out.push_back(str.substr(i, 1)); 3472b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak } 3473b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak return out; 3474b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak} 3475b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak 3476b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakTEST(EditDistance, TestCases) { 3477b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak struct Case { 3478b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak int line; 3479b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const char* left; 3480b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const char* right; 3481b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const char* expected_edits; 3482b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const char* expected_diff; 3483b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak }; 3484b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak static const Case kCases[] = { 3485b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak // No change. 3486b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "A", "A", " ", ""}, 3487b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "ABCDE", "ABCDE", " ", ""}, 3488b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak // Simple adds. 3489b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "X", "XA", " +", "@@ +1,2 @@\n X\n+A\n"}, 3490b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "X", "XABCD", " ++++", "@@ +1,5 @@\n X\n+A\n+B\n+C\n+D\n"}, 3491b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak // Simple removes. 3492b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "XA", "X", " -", "@@ -1,2 @@\n X\n-A\n"}, 3493b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "XABCD", "X", " ----", "@@ -1,5 @@\n X\n-A\n-B\n-C\n-D\n"}, 3494b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak // Simple replaces. 3495b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "A", "a", "/", "@@ -1,1 +1,1 @@\n-A\n+a\n"}, 3496b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "ABCD", "abcd", "////", 3497b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -1,4 +1,4 @@\n-A\n-B\n-C\n-D\n+a\n+b\n+c\n+d\n"}, 3498b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak // Path finding. 3499b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "ABCDEFGH", "ABXEGH1", " -/ - +", 3500b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -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"}, 3501b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "AAAABCCCC", "ABABCDCDC", "- / + / ", 3502b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -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"}, 3503b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "ABCDE", "BCDCD", "- +/", 3504b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -1,5 +1,5 @@\n-A\n B\n C\n D\n-E\n+C\n+D\n"}, 3505b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {__LINE__, "ABCDEFGHIJKL", "BCDCDEFGJKLJK", "- ++ -- ++", 3506b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -1,4 +1,5 @@\n-A\n B\n+C\n+D\n C\n D\n" 3507b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -6,7 +7,7 @@\n F\n G\n-H\n-I\n J\n K\n L\n+J\n+K\n"}, 3508b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak {}}; 3509b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak for (const Case* c = kCases; c->left; ++c) { 3510b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak EXPECT_TRUE(c->expected_edits == 3511b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak EditsToString(CalculateOptimalEdits(CharsToIndices(c->left), 3512b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak CharsToIndices(c->right)))) 3513b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak << "Left <" << c->left << "> Right <" << c->right << "> Edits <" 3514b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak << EditsToString(CalculateOptimalEdits( 3515b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak CharsToIndices(c->left), CharsToIndices(c->right))) << ">"; 3516b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak EXPECT_TRUE(c->expected_diff == CreateUnifiedDiff(CharsToLines(c->left), 3517b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak CharsToLines(c->right))) 3518b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak << "Left <" << c->left << "> Right <" << c->right << "> Diff <" 3519b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak << CreateUnifiedDiff(CharsToLines(c->left), CharsToLines(c->right)) 3520b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak << ">"; 3521b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak } 3522b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak} 3523b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak 3524d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EqFailure(), used for implementing *EQ* assertions. 3525d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, EqFailure) { 352687fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string foo_val("5"), bar_val("6"); 352787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string msg1( 3528d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", foo_val, bar_val, false) 3529d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3530d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3531d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3532d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3533d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3534d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3535d201456903f3ecae1f7794edfab0d5678e64226shiqian msg1.c_str()); 3536d201456903f3ecae1f7794edfab0d5678e64226shiqian 353787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string msg2( 3538d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "6", foo_val, bar_val, false) 3539d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3541d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3542d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo\n" 3543d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: 5", 3544d201456903f3ecae1f7794edfab0d5678e64226shiqian msg2.c_str()); 3545d201456903f3ecae1f7794edfab0d5678e64226shiqian 354687fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string msg3( 3547d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "bar", foo_val, bar_val, false) 3548d201456903f3ecae1f7794edfab0d5678e64226shiqian .failure_message()); 3549d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3550d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3551d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3552d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3553d201456903f3ecae1f7794edfab0d5678e64226shiqian msg3.c_str()); 3554d201456903f3ecae1f7794edfab0d5678e64226shiqian 355587fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string msg4( 3556d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("5", "6", foo_val, bar_val, false).failure_message()); 3557d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3558d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 6\n" 3559d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5", 3560d201456903f3ecae1f7794edfab0d5678e64226shiqian msg4.c_str()); 3561d201456903f3ecae1f7794edfab0d5678e64226shiqian 356287fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string msg5( 3563d201456903f3ecae1f7794edfab0d5678e64226shiqian EqFailure("foo", "bar", 356487fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::string("\"x\""), std::string("\"y\""), 3565d201456903f3ecae1f7794edfab0d5678e64226shiqian true).failure_message()); 3566d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ( 3567d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: bar\n" 3568d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"y\"\n" 3569d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: foo (ignoring case)\n" 3570d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: \"x\"", 3571d201456903f3ecae1f7794edfab0d5678e64226shiqian msg5.c_str()); 3572d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3573d201456903f3ecae1f7794edfab0d5678e64226shiqian 3574b54098a9abade957ab3c4e94ae5e5225ef0015a4kosakTEST(AssertionTest, EqFailureWithDiff) { 3575b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const std::string left( 3576b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15"); 3577b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const std::string right( 3578b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14"); 3579b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak const std::string msg1( 3580b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak EqFailure("left", "right", left, right, false).failure_message()); 3581b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak EXPECT_STREQ( 3582b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "Value of: right\n" 3583b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak " Actual: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n" 3584b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "Expected: left\n" 3585b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "Which is: " 3586b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n" 3587b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n" 3588b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak "@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n", 3589b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak msg1.c_str()); 3590b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak} 3591b54098a9abade957ab3c4e94ae5e5225ef0015a4kosak 3592d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests AppendUserMessage(), used for implementing the *EQ* macros. 3593d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AppendUserMessage) { 359487fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string foo("foo"); 3595d201456903f3ecae1f7794edfab0d5678e64226shiqian 35969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 3597d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", 3598d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3599d201456903f3ecae1f7794edfab0d5678e64226shiqian 3600d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << "bar"; 3601d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo\nbar", 3602d201456903f3ecae1f7794edfab0d5678e64226shiqian AppendUserMessage(foo, msg).c_str()); 3603d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3604d201456903f3ecae1f7794edfab0d5678e64226shiqian 3605c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3606c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 3607ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option push -w-ccc -w-rch 3608c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3609c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3610d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_TRUE. 3611d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_TRUE) { 3612d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(2 > 1); // NOLINT 3613d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(2 < 1), 3614d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 1"); 3615d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3616d201456903f3ecae1f7794edfab0d5678e64226shiqian 3617bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests ASSERT_TRUE(predicate) for predicates returning AssertionResult. 3618bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionTest, AssertTrueWithAssertionResult) { 3619bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_TRUE(ResultIsEven(2)); 3620603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ 3621603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan // ICE's in C++Builder. 3622bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEven(3)), 3623bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(3)\n" 3624bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 3625bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 3626d21c142eb89ce42817165368641329072e2ad8fbvladlosev#endif 3627bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_TRUE(ResultIsEvenNoExplanation(2)); 3628bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_TRUE(ResultIsEvenNoExplanation(3)), 3629bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(3)\n" 3630bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 3631bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 3632bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 3633bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 3634d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_FALSE. 3635d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_FALSE) { 3636d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(2 < 1); // NOLINT 3637d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(2 > 1), 3638d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 3639d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 3640d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 3641d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3642d201456903f3ecae1f7794edfab0d5678e64226shiqian 3643bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests ASSERT_FALSE(predicate) for predicates returning AssertionResult. 3644bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionTest, AssertFalseWithAssertionResult) { 3645bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_FALSE(ResultIsEven(3)); 3646603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ 3647603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan // ICE's in C++Builder. 3648bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEven(2)), 3649bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(2)\n" 3650bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true (2 is even)\n" 3651bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 3652d21c142eb89ce42817165368641329072e2ad8fbvladlosev#endif 3653bad778caa39a88b7c11b159e20730aeec4fd711evladlosev ASSERT_FALSE(ResultIsEvenNoExplanation(3)); 3654bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FATAL_FAILURE(ASSERT_FALSE(ResultIsEvenNoExplanation(2)), 3655bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(2)\n" 3656bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true\n" 3657bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 3658bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 3659bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 3660c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 3661c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 3662ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option pop 3663c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 3664c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 3665d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ASSERT_EQ on double values. The purpose is to make 3666d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 3667d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 3668d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_Double) { 3669d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3670d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5.6, 5.6); 3671d201456903f3ecae1f7794edfab0d5678e64226shiqian 3672d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3673d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5.1, 5.2), 3674d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 3675d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3676d201456903f3ecae1f7794edfab0d5678e64226shiqian 3677d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ. 3678d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ) { 3679d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(5, 2 + 3); 3680d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3), 3681d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 3682d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 3683d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 3684d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3685d201456903f3ecae1f7794edfab0d5678e64226shiqian 3686d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(NULL, pointer). 368706d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 3688d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_EQ_NULL) { 3689d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3690d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 3691e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // Some older GCC versions may issue a spurious waring in this or the next 3692e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 3693e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 3694e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 3695d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(NULL, p); 3696d201456903f3ecae1f7794edfab0d5678e64226shiqian 3697d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3698d201456903f3ecae1f7794edfab0d5678e64226shiqian static int n = 0; 3699d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n), 3700d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 3701d201456903f3ecae1f7794edfab0d5678e64226shiqian} 370206d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 3703d201456903f3ecae1f7794edfab0d5678e64226shiqian 3704d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_EQ(0, non_pointer). Since the literal 0 can be 3705d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 3706d201456903f3ecae1f7794edfab0d5678e64226shiqian// that ASSERT_EQ(0, non_pointer) isn't interpreted by Google Test as 3707d201456903f3ecae1f7794edfab0d5678e64226shiqian// ASSERT_EQ(static_cast<void*>(NULL), non_pointer). 3708d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ASSERT_EQ_0) { 3709d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 3710d201456903f3ecae1f7794edfab0d5678e64226shiqian 3711d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 3712d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(0, n); 3713d201456903f3ecae1f7794edfab0d5678e64226shiqian 3714d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 3715d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6), 3716d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 3717d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3718d201456903f3ecae1f7794edfab0d5678e64226shiqian 3719d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_NE. 3720d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_NE) { 3721d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_NE(6, 7); 3722d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_NE('a', 'a'), 3723d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 3724d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 3725d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3726d201456903f3ecae1f7794edfab0d5678e64226shiqian 3727d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LE. 3728d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LE) { 3729d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 3); 3730d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LE(2, 2); 3731d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LE(2, 0), 3732d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 3733d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3734d201456903f3ecae1f7794edfab0d5678e64226shiqian 3735d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_LT. 3736d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_LT) { 3737d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(2, 3); 3738d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 2), 3739d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 3740d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3741d201456903f3ecae1f7794edfab0d5678e64226shiqian 3742d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GE. 3743d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GE) { 3744d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 1); 3745d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GE(2, 2); 3746d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GE(2, 3), 3747d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 3748d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3749d201456903f3ecae1f7794edfab0d5678e64226shiqian 3750d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ASSERT_GT. 3751d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ASSERT_GT) { 3752d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_GT(2, 1); 3753d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_GT(2, 2), 3754d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 3755d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3756d201456903f3ecae1f7794edfab0d5678e64226shiqian 375736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 375836865d8d354465e3461eedf2949a4b7799985d5dshiqian 3759886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wanvoid ThrowNothing() {} 3760886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan 376136865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_THROW. 376236865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_THROW) { 376336865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int); 3764d21c142eb89ce42817165368641329072e2ad8fbvladlosev 3765ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifndef __BORLANDC__ 3766ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3767d21c142eb89ce42817165368641329072e2ad8fbvladlosev // ICE's in C++Builder 2007 and 2009. 3768886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3769886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowAnInteger(), bool), 3770886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of type bool.\n" 3771886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws a different type."); 3772ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 3773d21c142eb89ce42817165368641329072e2ad8fbvladlosev 3774886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3775886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_THROW(ThrowNothing(), bool), 3776886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 3777886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 377836865d8d354465e3461eedf2949a4b7799985d5dshiqian} 377936865d8d354465e3461eedf2949a4b7799985d5dshiqian 378036865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_NO_THROW. 378136865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_NO_THROW) { 3782886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()); 378336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()), 3784886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an exception." 378536865d8d354465e3461eedf2949a4b7799985d5dshiqian "\n Actual: it throws."); 378636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 378736865d8d354465e3461eedf2949a4b7799985d5dshiqian 378836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests ASSERT_ANY_THROW. 378936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionTest, ASSERT_ANY_THROW) { 379036865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()); 3791886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE( 3792886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_ANY_THROW(ThrowNothing()), 3793886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 3794886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 379536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 379636865d8d354465e3461eedf2949a4b7799985d5dshiqian 379736865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 379836865d8d354465e3461eedf2949a4b7799985d5dshiqian 3799d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure we deal with the precedence of <<. This test should 3800d201456903f3ecae1f7794edfab0d5678e64226shiqian// compile. 3801d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertPrecedence) { 3802d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1 < 2, true); 380348b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan bool false_value = false; 380448b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan ASSERT_EQ(true && false_value, false); 3805d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3806d201456903f3ecae1f7794edfab0d5678e64226shiqian 3807d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3808d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestEq1(int x) { 3809d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, x); 3810d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3811d201456903f3ecae1f7794edfab0d5678e64226shiqian 3812d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests calling a test subroutine that's not part of a fixture. 3813d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, NonFixtureSubroutine) { 3814d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestEq1(2), 3815d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: x"); 3816d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3817d201456903f3ecae1f7794edfab0d5678e64226shiqian 3818d201456903f3ecae1f7794edfab0d5678e64226shiqian// An uncopyable class. 3819d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Uncopyable { 3820d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 3821d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit Uncopyable(int a_value) : value_(a_value) {} 3822d201456903f3ecae1f7794edfab0d5678e64226shiqian 3823d201456903f3ecae1f7794edfab0d5678e64226shiqian int value() const { return value_; } 3824d201456903f3ecae1f7794edfab0d5678e64226shiqian bool operator==(const Uncopyable& rhs) const { 3825d201456903f3ecae1f7794edfab0d5678e64226shiqian return value() == rhs.value(); 3826d201456903f3ecae1f7794edfab0d5678e64226shiqian } 3827d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 3828d201456903f3ecae1f7794edfab0d5678e64226shiqian // This constructor deliberately has no implementation, as we don't 3829d201456903f3ecae1f7794edfab0d5678e64226shiqian // want this class to be copyable. 3830d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable(const Uncopyable&); // NOLINT 3831d201456903f3ecae1f7794edfab0d5678e64226shiqian 3832d201456903f3ecae1f7794edfab0d5678e64226shiqian int value_; 3833d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3834d201456903f3ecae1f7794edfab0d5678e64226shiqian 3835d201456903f3ecae1f7794edfab0d5678e64226shiqian::std::ostream& operator<<(::std::ostream& os, const Uncopyable& value) { 3836d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << value.value(); 3837d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3838d201456903f3ecae1f7794edfab0d5678e64226shiqian 3839d201456903f3ecae1f7794edfab0d5678e64226shiqian 3840d201456903f3ecae1f7794edfab0d5678e64226shiqianbool IsPositiveUncopyable(const Uncopyable& x) { 3841d201456903f3ecae1f7794edfab0d5678e64226shiqian return x.value() > 0; 3842d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3843d201456903f3ecae1f7794edfab0d5678e64226shiqian 3844d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3845d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertNonPositive() { 3846d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3847d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, y); 3848d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3849d201456903f3ecae1f7794edfab0d5678e64226shiqian// A subroutine used by the following test. 3850d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid TestAssertEqualsUncopyable() { 3851d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3852d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3853d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, y); 3854d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3855d201456903f3ecae1f7794edfab0d5678e64226shiqian 3856d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in assertions. 3857d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AssertWorksWithUncopyableObject) { 3858d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3859d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_PRED1(IsPositiveUncopyable, x); 3860d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(x, x); 3861d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertNonPositive(), 3862d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3863d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(), 3864d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3865d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3866d201456903f3ecae1f7794edfab0d5678e64226shiqian 3867d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that uncopyable objects can be used in expects. 3868d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, ExpectWorksWithUncopyableObject) { 3869d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable x(5); 3870d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_PRED1(IsPositiveUncopyable, x); 3871d201456903f3ecae1f7794edfab0d5678e64226shiqian Uncopyable y(-1); 3872d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_PRED1(IsPositiveUncopyable, y), 3873d201456903f3ecae1f7794edfab0d5678e64226shiqian "IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1"); 3874d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(x, x); 3875d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), 3876d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: y\n Actual: -1\nExpected: x\nWhich is: 5"); 3877d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3878d201456903f3ecae1f7794edfab0d5678e64226shiqian 38795c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wanenum NamedEnum { 38805c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kE1 = 0, 388166ac4909aea5c4dc9c43e6f11518c34049c6bd5ezhanyong.wan kE2 = 1 38825c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan}; 38835c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan 38845c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wanTEST(AssertionTest, NamedEnum) { 38855c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(kE1, kE1); 38865c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LT(kE1, kE2); 38875c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Which is: 0"); 38885c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(kE1, kE2), "Actual: 1"); 38895c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan} 3890d201456903f3ecae1f7794edfab0d5678e64226shiqian 3891d201456903f3ecae1f7794edfab0d5678e64226shiqian// The version of gcc used in XCode 2.2 has a bug and doesn't allow 38926a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// anonymous enums in assertions. Therefore the following test is not 38936a26383e31cf79dd0acf89bf3a53c7a805decf1dzhanyong.wan// done on Mac. 3894741d6c0d475664fc48790917cefed455a4307227zhanyong.wan// Sun Studio and HP aCC also reject this code. 3895741d6c0d475664fc48790917cefed455a4307227zhanyong.wan#if !GTEST_OS_MAC && !defined(__SUNPRO_CC) && !defined(__HP_aCC) 3896d201456903f3ecae1f7794edfab0d5678e64226shiqian 3897d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using assertions with anonymous enums. 3898d201456903f3ecae1f7794edfab0d5678e64226shiqianenum { 38995c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseA = -1, 3900ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3901ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_LINUX 3902ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3903d201456903f3ecae1f7794edfab0d5678e64226shiqian // We want to test the case where the size of the anonymous enum is 3904d201456903f3ecae1f7794edfab0d5678e64226shiqian // larger than sizeof(int), to make sure our implementation of the 3905d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions doesn't truncate the enums. However, MSVC 3906d201456903f3ecae1f7794edfab0d5678e64226shiqian // (incorrectly) doesn't allow an enum value to exceed the range of 3907d201456903f3ecae1f7794edfab0d5678e64226shiqian // an int, so this has to be conditionally compiled. 3908d201456903f3ecae1f7794edfab0d5678e64226shiqian // 39095c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan // On Linux, kCaseB and kCaseA have the same value when truncated to 3910d201456903f3ecae1f7794edfab0d5678e64226shiqian // int size. We want to test whether this will confuse the 3911d201456903f3ecae1f7794edfab0d5678e64226shiqian // assertions. 39125c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseB = testing::internal::kMaxBiggestInt, 3913ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3914ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# else 3915ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 39165c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan kCaseB = INT_MAX, 3917ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3918ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_LINUX 3919ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3920962b6554f44c3d3e4a8b4c949c89cf77b744d210vladlosev kCaseC = 42 3921d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 3922d201456903f3ecae1f7794edfab0d5678e64226shiqian 3923d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionTest, AnonymousEnum) { 3924ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# if GTEST_OS_LINUX 3925ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 39265c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB)); 3927ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 3928ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif // GTEST_OS_LINUX 3929d201456903f3ecae1f7794edfab0d5678e64226shiqian 39305c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_EQ(kCaseA, kCaseA); 39315c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NE(kCaseA, kCaseB); 39325c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LT(kCaseA, kCaseB); 39335c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_LE(kCaseA, kCaseB); 39345c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_GT(kCaseB, kCaseA); 39355c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_GE(kCaseA, kCaseA); 39365c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseB), 39375c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "(kCaseA) >= (kCaseB)"); 39385c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GE(kCaseA, kCaseC), 39395c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "-1 vs 42"); 39405c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan 39415c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_EQ(kCaseA, kCaseA); 39425c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_NE(kCaseA, kCaseB); 39435c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_LT(kCaseA, kCaseB); 39445c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_LE(kCaseA, kCaseB); 39455c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_GT(kCaseB, kCaseA); 39465c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan ASSERT_GE(kCaseA, kCaseA); 3947603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan 3948603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan# ifndef __BORLANDC__ 3949603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan 3950603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan // ICE's in C++Builder. 39515c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB), 39525c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Value of: kCaseB"); 39535c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 39545c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Actual: 42"); 3955603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan# endif 3956603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan 39575c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC), 39585c4b472bbf8c81fc3d52fc69a92f174821a96280zhanyong.wan "Which is: -1"); 3959d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3960d201456903f3ecae1f7794edfab0d5678e64226shiqian 3961cfcbc298cd91806e0e3417e03fce42bc4f1fa150vladlosev#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC) 3962d201456903f3ecae1f7794edfab0d5678e64226shiqian 39630af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 3964d201456903f3ecae1f7794edfab0d5678e64226shiqian 3965d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT UnexpectedHRESULTFailure() { 3966d201456903f3ecae1f7794edfab0d5678e64226shiqian return E_UNEXPECTED; 3967d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3968d201456903f3ecae1f7794edfab0d5678e64226shiqian 3969d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT OkHRESULTSuccess() { 3970d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_OK; 3971d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3972d201456903f3ecae1f7794edfab0d5678e64226shiqian 3973d201456903f3ecae1f7794edfab0d5678e64226shiqianstatic HRESULT FalseHRESULTSuccess() { 3974d201456903f3ecae1f7794edfab0d5678e64226shiqian return S_FALSE; 3975d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3976d201456903f3ecae1f7794edfab0d5678e64226shiqian 3977d201456903f3ecae1f7794edfab0d5678e64226shiqian// HRESULT assertion tests test both zero and non-zero 3978d201456903f3ecae1f7794edfab0d5678e64226shiqian// success codes as well as failure message for each. 3979d201456903f3ecae1f7794edfab0d5678e64226shiqian// 3980d201456903f3ecae1f7794edfab0d5678e64226shiqian// Windows CE doesn't support message texts. 3981d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_SUCCEEDED) { 3982d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK); 3983d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_FALSE); 3984d201456903f3ecae1f7794edfab0d5678e64226shiqian 3985d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3986ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3987ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3988d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3989d201456903f3ecae1f7794edfab0d5678e64226shiqian 3990d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_SUCCEEDED) { 3991d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK); 3992d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_FALSE); 3993d201456903f3ecae1f7794edfab0d5678e64226shiqian 3994d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_SUCCEEDED(UnexpectedHRESULTFailure()), 3995ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (UnexpectedHRESULTFailure()) succeeds.\n" 3996ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian " Actual: 0x8000FFFF"); 3997d201456903f3ecae1f7794edfab0d5678e64226shiqian} 3998d201456903f3ecae1f7794edfab0d5678e64226shiqian 3999d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, EXPECT_HRESULT_FAILED) { 4000d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED); 4001d201456903f3ecae1f7794edfab0d5678e64226shiqian 4002d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(OkHRESULTSuccess()), 4003ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 4004cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak " Actual: 0x0"); 4005d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_HRESULT_FAILED(FalseHRESULTSuccess()), 4006ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 4007cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak " Actual: 0x1"); 4008d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4009d201456903f3ecae1f7794edfab0d5678e64226shiqian 4010d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, ASSERT_HRESULT_FAILED) { 4011d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED); 4012d201456903f3ecae1f7794edfab0d5678e64226shiqian 4013ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifndef __BORLANDC__ 4014ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 4015c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 4016d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(OkHRESULTSuccess()), 4017ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (OkHRESULTSuccess()) fails.\n" 4018cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak " Actual: 0x0"); 4019ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 4020ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 4021d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_HRESULT_FAILED(FalseHRESULTSuccess()), 4022ee39a89debba2b2e00dec3fa2df03e1d3dcb4027shiqian "Expected: (FalseHRESULTSuccess()) fails.\n" 4023cc1fdb58caf8d5ac9b858f615d3c42267fc5e258kosak " Actual: 0x1"); 4024d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4025d201456903f3ecae1f7794edfab0d5678e64226shiqian 4026d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that streaming to the HRESULT macros works. 4027d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(HRESULTAssertionTest, Streaming) { 4028d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 4029d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(S_OK) << "unexpected failure"; 4030d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 4031d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(E_UNEXPECTED) << "unexpected failure"; 4032d201456903f3ecae1f7794edfab0d5678e64226shiqian 4033d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 4034d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 4035d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4036d201456903f3ecae1f7794edfab0d5678e64226shiqian 4037ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# ifndef __BORLANDC__ 4038ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 4039c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan // ICE's in C++Builder 2007 and 2009. 4040d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 4041d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_SUCCEEDED(E_UNEXPECTED) << "expected failure", 4042d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4043ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# endif 4044d201456903f3ecae1f7794edfab0d5678e64226shiqian 4045d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE( 4046d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_HRESULT_FAILED(S_OK) << "expected failure", 4047d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4048d201456903f3ecae1f7794edfab0d5678e64226shiqian 4049d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE( 4050d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_HRESULT_FAILED(S_OK) << "expected failure", 4051d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 4052d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4053d201456903f3ecae1f7794edfab0d5678e64226shiqian 40540af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#endif // GTEST_OS_WINDOWS 4055d201456903f3ecae1f7794edfab0d5678e64226shiqian 4056c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 4057c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 4058ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option push -w-ccc -w-rch 4059c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 4060c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 4061d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros behave like single statements. 4062e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, BasicAssertionsBehavesLikeSingleStatement) { 4063f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4064d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(false) << "This should never be executed; " 4065d201456903f3ecae1f7794edfab0d5678e64226shiqian "It's a compilation test only."; 4066d201456903f3ecae1f7794edfab0d5678e64226shiqian 4067f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 4068d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false); 4069d201456903f3ecae1f7794edfab0d5678e64226shiqian else 4070ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4071d201456903f3ecae1f7794edfab0d5678e64226shiqian 4072f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4073d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 3); 4074d201456903f3ecae1f7794edfab0d5678e64226shiqian 4075f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4076ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4077d201456903f3ecae1f7794edfab0d5678e64226shiqian else 4078d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(3, 2) << ""; 4079e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 408036865d8d354465e3461eedf2949a4b7799985d5dshiqian 408136865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 408237504994338c114247519331237831f88a9a7c40zhanyong.wan// Tests that the compiler will not complain about unreachable code in the 408337504994338c114247519331237831f88a9a7c40zhanyong.wan// EXPECT_THROW/EXPECT_ANY_THROW/EXPECT_NO_THROW macros. 408437504994338c114247519331237831f88a9a7c40zhanyong.wanTEST(ExpectThrowTest, DoesNotGenerateUnreachableCodeWarning) { 408537504994338c114247519331237831f88a9a7c40zhanyong.wan int n = 0; 408637504994338c114247519331237831f88a9a7c40zhanyong.wan 408737504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_THROW(throw 1, int); 408837504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(n++, int), ""); 408937504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_THROW(throw 1, const char*), ""); 409037504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NO_THROW(n++); 409137504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(throw 1), ""); 409237504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_ANY_THROW(throw 1); 409337504994338c114247519331237831f88a9a7c40zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(n++), ""); 409437504994338c114247519331237831f88a9a7c40zhanyong.wan} 409537504994338c114247519331237831f88a9a7c40zhanyong.wan 4096e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, ExceptionAssertionsBehavesLikeSingleStatement) { 4097f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4098886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool); 409936865d8d354465e3461eedf2949a4b7799985d5dshiqian 4100f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 410136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 410236865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4103ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 410436865d8d354465e3461eedf2949a4b7799985d5dshiqian 4105f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 410636865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NO_THROW(ThrowAnInteger()); 410736865d8d354465e3461eedf2949a4b7799985d5dshiqian 4108f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 4109886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 411036865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4111ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 411236865d8d354465e3461eedf2949a4b7799985d5dshiqian 4113f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4114886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()); 411536865d8d354465e3461eedf2949a4b7799985d5dshiqian 4116f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 411736865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 411836865d8d354465e3461eedf2949a4b7799985d5dshiqian else 4119ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4120e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian} 412136865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 4122e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4123e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqianTEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) { 4124f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4125e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. " 4126e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian << "It's a compilation test only."; 4127e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4128ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4129e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4130f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4131e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(FAIL()) << ""; 4132e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4133ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4134e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4135f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysTrue()) 4136e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian EXPECT_NO_FATAL_FAILURE(SUCCEED()); 4137e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4138ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4139e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian 4140f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan if (AlwaysFalse()) 4141ae3247986bbbafcc913b5fe6132090ad6f1c3f36zhanyong.wan ; // NOLINT 4142e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian else 4143e0865dd9199e8fffd5c2f95a68de6c1851f77c15shiqian ASSERT_NO_FATAL_FAILURE(SUCCEED()); 4144d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4145d201456903f3ecae1f7794edfab0d5678e64226shiqian 4146d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the assertion macros work well with switch statements. 4147d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(AssertionSyntaxTest, WorksWithSwitch) { 4148d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 4149d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 4150d201456903f3ecae1f7794edfab0d5678e64226shiqian break; 4151d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 4152d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 4153d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4154d201456903f3ecae1f7794edfab0d5678e64226shiqian 4155d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 4156d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 4157d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "EXPECT_FALSE failed in switch case"; 4158d201456903f3ecae1f7794edfab0d5678e64226shiqian 4159d201456903f3ecae1f7794edfab0d5678e64226shiqian // Binary assertions are implemented using a different code path 4160d201456903f3ecae1f7794edfab0d5678e64226shiqian // than the Boolean assertions. Hence we test them separately. 4161d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) { 4162d201456903f3ecae1f7794edfab0d5678e64226shiqian case 1: 4163d201456903f3ecae1f7794edfab0d5678e64226shiqian default: 4164d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "ASSERT_EQ failed in default switch handler"; 4165d201456903f3ecae1f7794edfab0d5678e64226shiqian } 4166d201456903f3ecae1f7794edfab0d5678e64226shiqian 4167d201456903f3ecae1f7794edfab0d5678e64226shiqian switch (0) 4168d201456903f3ecae1f7794edfab0d5678e64226shiqian case 0: 4169d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(1, 2); 4170d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4171d201456903f3ecae1f7794edfab0d5678e64226shiqian 417236865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 417336865d8d354465e3461eedf2949a4b7799985d5dshiqian 417436865d8d354465e3461eedf2949a4b7799985d5dshiqianvoid ThrowAString() { 417587fdda2cf24d953f3cbec1e0c266b2db9928f406jgm throw "std::string"; 417636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 417736865d8d354465e3461eedf2949a4b7799985d5dshiqian 417836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Test that the exception assertion macros compile and work with const 417936865d8d354465e3461eedf2949a4b7799985d5dshiqian// type qualifier. 418036865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(AssertionSyntaxTest, WorksWithConst) { 418136865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAString(), const char*); 418236865d8d354465e3461eedf2949a4b7799985d5dshiqian 418336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAString(), const char*); 418436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 418536865d8d354465e3461eedf2949a4b7799985d5dshiqian 418636865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 418736865d8d354465e3461eedf2949a4b7799985d5dshiqian 4188d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 4189d201456903f3ecae1f7794edfab0d5678e64226shiqian 4190d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 4191d201456903f3ecae1f7794edfab0d5678e64226shiqian 4192d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test tracks SUCCEED*. 4193d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, SUCCEED) { 4194d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 4195d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "OK"; 4196c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(2, GetUnitTestImpl()->current_test_result()->total_part_count()); 4197d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4198d201456903f3ecae1f7794edfab0d5678e64226shiqian 4199d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_*. 4200d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT) { 4201d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true); 4202c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4203d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4204d201456903f3ecae1f7794edfab0d5678e64226shiqian 4205d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful EXPECT_STR*. 4206d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, EXPECT_STR) { 4207d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("", ""); 4208c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4209d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4210d201456903f3ecae1f7794edfab0d5678e64226shiqian 4211d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_*. 4212d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT) { 4213d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true); 4214c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4215d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4216d201456903f3ecae1f7794edfab0d5678e64226shiqian 4217d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test doesn't track successful ASSERT_STR*. 4218d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(SuccessfulAssertionTest, ASSERT_STR) { 4219d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("", ""); 4220c214ebc830aa918d54e535c6caa2da6317877e12zhanyong.wan EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count()); 4221d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4222d201456903f3ecae1f7794edfab0d5678e64226shiqian 4223d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 4224d201456903f3ecae1f7794edfab0d5678e64226shiqian 4225d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 4226d201456903f3ecae1f7794edfab0d5678e64226shiqian 4227f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests the message streaming variation of assertions. 4228f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4229f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, EXPECT) { 4230f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_EQ(1, 1) << "This should succeed."; 4231f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_NE(1, 1) << "Expected failure #1.", 4232f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #1"); 4233f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_LE(1, 2) << "This should succeed."; 4234f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_LT(1, 0) << "Expected failure #2.", 4235f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #2."); 4236f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_GE(1, 0) << "This should succeed."; 4237f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_GT(1, 2) << "Expected failure #3.", 4238f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #3."); 4239f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4240f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_STREQ("1", "1") << "This should succeed."; 4241f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("1", "1") << "Expected failure #4.", 4242f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #4."); 4243f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_STRCASEEQ("a", "A") << "This should succeed."; 4244f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("a", "A") << "Expected failure #5.", 4245f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #5."); 4246f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4247f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FLOAT_EQ(1, 1) << "This should succeed."; 4248f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1, 1.2) << "Expected failure #6.", 4249f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure #6."); 4250f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NEAR(1, 1.1, 0.2) << "This should succeed."; 4251f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4252f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4253f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, ASSERT) { 4254f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_EQ(1, 1) << "This should succeed."; 4255f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_NE(1, 2) << "This should succeed."; 4256f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_LE(1, 2) << "This should succeed."; 4257f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_LT(1, 2) << "This should succeed."; 4258f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_GE(1, 0) << "This should succeed."; 4259f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE(ASSERT_GT(1, 2) << "Expected failure.", 4260f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure."); 4261f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4262f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4263f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, ASSERT_STR) { 4264f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_STREQ("1", "1") << "This should succeed."; 4265f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_STRNE("1", "2") << "This should succeed."; 4266f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_STRCASEEQ("a", "A") << "This should succeed."; 4267f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("a", "A") << "Expected failure.", 4268f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expected failure."); 4269f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4270f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4271f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, ASSERT_FLOATING) { 4272f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_FLOAT_EQ(1, 1) << "This should succeed."; 4273f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_DOUBLE_EQ(1, 1) << "This should succeed."; 4274f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE(ASSERT_NEAR(1,1.2, 0.1) << "Expect failure.", // NOLINT 4275f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Expect failure."); 4276f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm // To work around a bug in gcc 2.95.0, there is intentionally no 4277f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm // space after the first comma in the previous statement. 4278f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4279f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4280f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests using ASSERT_FALSE with a streamed message. 4281f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, ASSERT_FALSE) { 4282f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_FALSE(false) << "This shouldn't fail."; 4283f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE({ // NOLINT 4284f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_FALSE(true) << "Expected failure: " << 2 << " > " << 1 4285f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << " evaluates to " << true; 4286f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm }, "Expected failure"); 4287f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4288f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4289f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests using FAIL with a streamed message. 4290f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, FAIL) { 4291f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE(FAIL() << 0, 4292f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "0"); 4293f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4294f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4295f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests using SUCCEED with a streamed message. 4296f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, SUCCEED) { 4297f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm SUCCEED() << "Success == " << 1; 4298f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4299f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4300f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests using ASSERT_TRUE with a streamed message. 4301f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, ASSERT_TRUE) { 4302f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_TRUE(true) << "This should succeed."; 4303f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_TRUE(true) << true; 4304f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE({ // NOLINT 4305f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_TRUE(false) << static_cast<const char *>(NULL) 4306f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << static_cast<char *>(NULL); 4307f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm }, "(null)(null)"); 4308f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4309f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4310f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm#if GTEST_OS_WINDOWS 4311f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests using wide strings in assertion messages. 4312f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgmTEST(AssertionWithMessageTest, WideStringMessage) { 4313f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE({ // NOLINT 4314f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_TRUE(false) << L"This failure is expected.\x8119"; 4315f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm }, "This failure is expected."); 4316f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FATAL_FAILURE({ // NOLINT 4317f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ASSERT_EQ(1, 2) << "This failure is " 4318f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm << L"expected too.\x8120"; 4319f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm }, "This failure is expected too."); 4320f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm} 4321f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm#endif // GTEST_OS_WINDOWS 4322f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm 4323d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_TRUE. 4324d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_TRUE) { 4325f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_TRUE(true) << "Intentional success"; 4326f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #1.", 4327f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Intentional failure #1."); 4328f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "Intentional failure #2.", 4329f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Intentional failure #2."); 4330d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(2 > 1); // NOLINT 4331d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 < 1), 4332d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 < 1\n" 4333d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: false\n" 4334d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: true"); 4335d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(2 > 3), 4336d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 > 3"); 4337d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4338d201456903f3ecae1f7794edfab0d5678e64226shiqian 4339bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests EXPECT_TRUE(predicate) for predicates returning AssertionResult. 4340bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(ExpectTest, ExpectTrueWithAssertionResult) { 4341bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(ResultIsEven(2)); 4342bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEven(3)), 4343bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(3)\n" 4344bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 4345bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 4346bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(ResultIsEvenNoExplanation(2)); 4347bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(ResultIsEvenNoExplanation(3)), 4348bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(3)\n" 4349bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: false (3 is odd)\n" 4350bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: true"); 4351bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4352bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4353f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm// Tests EXPECT_FALSE with a streamed message. 4354d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_FALSE) { 4355d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(2 < 1); // NOLINT 4356f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_FALSE(false) << "Intentional success"; 4357f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #1.", 4358f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Intentional failure #1."); 4359f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "Intentional failure #2.", 4360f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Intentional failure #2."); 4361d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 > 1), 4362d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2 > 1\n" 4363d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: true\n" 4364d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: false"); 4365d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(2 < 3), 4366d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 < 3"); 4367d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4368d201456903f3ecae1f7794edfab0d5678e64226shiqian 4369bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests EXPECT_FALSE(predicate) for predicates returning AssertionResult. 4370bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(ExpectTest, ExpectFalseWithAssertionResult) { 4371bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(ResultIsEven(3)); 4372bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEven(2)), 4373bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEven(2)\n" 4374bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true (2 is even)\n" 4375bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 4376bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(ResultIsEvenNoExplanation(3)); 4377bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(ResultIsEvenNoExplanation(2)), 4378bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Value of: ResultIsEvenNoExplanation(2)\n" 4379bad778caa39a88b7c11b159e20730aeec4fd711evladlosev " Actual: true\n" 4380bad778caa39a88b7c11b159e20730aeec4fd711evladlosev "Expected: false"); 4381bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 4382bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 4383c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 4384c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 4385ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option pop 4386c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 4387c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 4388d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ. 4389d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ) { 4390d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5, 2 + 3); 4391d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3), 4392d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: 2*3\n" 4393d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: 6\n" 4394d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 5"); 4395d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3), 4396d201456903f3ecae1f7794edfab0d5678e64226shiqian "2 - 3"); 4397d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4398d201456903f3ecae1f7794edfab0d5678e64226shiqian 4399d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using EXPECT_EQ on double values. The purpose is to make 4400d201456903f3ecae1f7794edfab0d5678e64226shiqian// sure that the specialization we did for integer and anonymous enums 4401d201456903f3ecae1f7794edfab0d5678e64226shiqian// isn't used for double arguments. 4402d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_Double) { 4403d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4404d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(5.6, 5.6); 4405d201456903f3ecae1f7794edfab0d5678e64226shiqian 4406d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5.1, 5.2), 4408d201456903f3ecae1f7794edfab0d5678e64226shiqian "5.1"); 4409d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4410d201456903f3ecae1f7794edfab0d5678e64226shiqian 441106d04c0945bf47bae90532552e6e8294802fc9aavladlosev#if GTEST_CAN_COMPARE_NULL 4412d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(NULL, pointer). 4413d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_NULL) { 4414d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4415d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* p = NULL; 441648b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan // Some older GCC versions may issue a spurious warning in this or the next 4417e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // assertion statement. This warning should not be suppressed with 4418e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // static_cast since the test verifies the ability to use bare NULL as the 4419e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan // expected parameter to the macro. 4420d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(NULL, p); 4421d201456903f3ecae1f7794edfab0d5678e64226shiqian 4422d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4423d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4424d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n), 4425d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: &n\n"); 4426d201456903f3ecae1f7794edfab0d5678e64226shiqian} 442706d04c0945bf47bae90532552e6e8294802fc9aavladlosev#endif // GTEST_CAN_COMPARE_NULL 4428d201456903f3ecae1f7794edfab0d5678e64226shiqian 4429d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_EQ(0, non_pointer). Since the literal 0 can be 4430d201456903f3ecae1f7794edfab0d5678e64226shiqian// treated as a null pointer by the compiler, we need to make sure 4431d201456903f3ecae1f7794edfab0d5678e64226shiqian// that EXPECT_EQ(0, non_pointer) isn't interpreted by Google Test as 4432d201456903f3ecae1f7794edfab0d5678e64226shiqian// EXPECT_EQ(static_cast<void*>(NULL), non_pointer). 4433d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_EQ_0) { 4434d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4435d201456903f3ecae1f7794edfab0d5678e64226shiqian 4436d201456903f3ecae1f7794edfab0d5678e64226shiqian // A success. 4437d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, n); 4438d201456903f3ecae1f7794edfab0d5678e64226shiqian 4439d201456903f3ecae1f7794edfab0d5678e64226shiqian // A failure. 4440d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6), 4441d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: 0"); 4442d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4443d201456903f3ecae1f7794edfab0d5678e64226shiqian 4444d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_NE. 4445d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_NE) { 4446d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NE(6, 7); 4447d201456903f3ecae1f7794edfab0d5678e64226shiqian 4448d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE('a', 'a'), 4449d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: ('a') != ('a'), " 4450d201456903f3ecae1f7794edfab0d5678e64226shiqian "actual: 'a' (97, 0x61) vs 'a' (97, 0x61)"); 4451d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(2, 2), 4452d201456903f3ecae1f7794edfab0d5678e64226shiqian "2"); 4453d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4454d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p0, p0), 4455d201456903f3ecae1f7794edfab0d5678e64226shiqian "p0"); 4456d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4457d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4458d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4459d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4460d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4461d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4462d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_NE(p1, p1), 4463d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 4464d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4465d201456903f3ecae1f7794edfab0d5678e64226shiqian 4466d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LE. 4467d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LE) { 4468d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 3); 4469d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LE(2, 2); 4470d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(2, 0), 4471d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) <= (0), actual: 2 vs 0"); 4472d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LE(1.1, 0.9), 4473d201456903f3ecae1f7794edfab0d5678e64226shiqian "(1.1) <= (0.9)"); 4474d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4475d201456903f3ecae1f7794edfab0d5678e64226shiqian 4476d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_LT. 4477d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_LT) { 4478d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(2, 3); 4479d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 2), 4480d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) < (2), actual: 2 vs 2"); 4481d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1), 4482d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) < (1)"); 4483d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4484d201456903f3ecae1f7794edfab0d5678e64226shiqian 4485d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GE. 4486d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GE) { 4487d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 1); 4488d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GE(2, 2); 4489d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(2, 3), 4490d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) >= (3), actual: 2 vs 3"); 4491d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GE(0.9, 1.1), 4492d201456903f3ecae1f7794edfab0d5678e64226shiqian "(0.9) >= (1.1)"); 4493d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4494d201456903f3ecae1f7794edfab0d5678e64226shiqian 4495d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests EXPECT_GT. 4496d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, EXPECT_GT) { 4497d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_GT(2, 1); 4498d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 2), 4499d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: (2) > (2), actual: 2 vs 2"); 4500d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_GT(2, 3), 4501d201456903f3ecae1f7794edfab0d5678e64226shiqian "(2) > (3)"); 4502d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4503d201456903f3ecae1f7794edfab0d5678e64226shiqian 450436865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 450536865d8d354465e3461eedf2949a4b7799985d5dshiqian 450636865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_THROW. 450736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_THROW) { 450836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int); 450936865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool), 4510886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() throws an exception of " 451136865d8d354465e3461eedf2949a4b7799985d5dshiqian "type bool.\n Actual: it throws a different type."); 4512886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 4513886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_THROW(ThrowNothing(), bool), 4514886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception of type bool.\n" 4515886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it throws nothing."); 451636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 451736865d8d354465e3461eedf2949a4b7799985d5dshiqian 451836865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_NO_THROW. 451936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_NO_THROW) { 4520886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()); 452136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()), 4522886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowAnInteger() doesn't throw an " 452336865d8d354465e3461eedf2949a4b7799985d5dshiqian "exception.\n Actual: it throws."); 452436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 452536865d8d354465e3461eedf2949a4b7799985d5dshiqian 452636865d8d354465e3461eedf2949a4b7799985d5dshiqian// Tests EXPECT_ANY_THROW. 452736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(ExpectTest, EXPECT_ANY_THROW) { 452836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()); 4529886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE( 4530886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_ANY_THROW(ThrowNothing()), 4531886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan "Expected: ThrowNothing() throws an exception.\n" 4532886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan " Actual: it doesn't."); 453336865d8d354465e3461eedf2949a4b7799985d5dshiqian} 453436865d8d354465e3461eedf2949a4b7799985d5dshiqian 453536865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 453636865d8d354465e3461eedf2949a4b7799985d5dshiqian 4537d201456903f3ecae1f7794edfab0d5678e64226shiqian// Make sure we deal with the precedence of <<. 4538d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ExpectTest, ExpectPrecedence) { 4539d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1 < 2, true); 4540d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false), 4541d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: true && false"); 4542d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4543d201456903f3ecae1f7794edfab0d5678e64226shiqian 4544d201456903f3ecae1f7794edfab0d5678e64226shiqian 4545d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the StreamableToString() function. 4546d201456903f3ecae1f7794edfab0d5678e64226shiqian 4547d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a scalar. 4548d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Scalar) { 4549d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("5", StreamableToString(5).c_str()); 4550d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4551d201456903f3ecae1f7794edfab0d5678e64226shiqian 4552d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a non-char pointer. 4553d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, Pointer) { 4554d201456903f3ecae1f7794edfab0d5678e64226shiqian int n = 0; 4555d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = &n; 4556d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("(null)", StreamableToString(p).c_str()); 4557d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4558d201456903f3ecae1f7794edfab0d5678e64226shiqian 4559d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL non-char pointer. 4560d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullPointer) { 4561d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p = NULL; 4562d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4563d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4564d201456903f3ecae1f7794edfab0d5678e64226shiqian 4565d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a C string. 4566d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, CString) { 4567d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("Foo", StreamableToString("Foo").c_str()); 4568d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4569d201456903f3ecae1f7794edfab0d5678e64226shiqian 4570d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using StreamableToString() on a NULL C string. 4571d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableToStringTest, NullCString) { 4572d201456903f3ecae1f7794edfab0d5678e64226shiqian char* p = NULL; 4573d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", StreamableToString(p).c_str()); 4574d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4575d201456903f3ecae1f7794edfab0d5678e64226shiqian 4576d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using streamable values as assertion messages. 4577d201456903f3ecae1f7794edfab0d5678e64226shiqian 4578d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using std::string as an assertion message. 4579d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, string) { 4580d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string str( 4581d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure message is a std::string, and is expected."); 4582d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << str, 4583d201456903f3ecae1f7794edfab0d5678e64226shiqian str.c_str()); 4584d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4585d201456903f3ecae1f7794edfab0d5678e64226shiqian 4586d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output strings containing embedded NULs. 4587d201456903f3ecae1f7794edfab0d5678e64226shiqian// Limited to Linux because we can only do this with std::string's. 4588d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, stringWithEmbeddedNUL) { 4589d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char char_array_with_nul[] = 4590d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\0 and some more string"; 4591d201456903f3ecae1f7794edfab0d5678e64226shiqian static const std::string string_with_nul(char_array_with_nul, 4592d201456903f3ecae1f7794edfab0d5678e64226shiqian sizeof(char_array_with_nul) 4593d201456903f3ecae1f7794edfab0d5678e64226shiqian - 1); // drops the trailing NUL 4594d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << string_with_nul, 4595d201456903f3ecae1f7794edfab0d5678e64226shiqian "Here's a NUL\\0 and some more string"); 4596d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4597d201456903f3ecae1f7794edfab0d5678e64226shiqian 4598d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that we can output a NUL char. 4599d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NULChar) { 4600d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4601d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "A NUL" << '\0' << " and some more string"; 4602d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "A NUL\\0 and some more string"); 4603d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4604d201456903f3ecae1f7794edfab0d5678e64226shiqian 4605d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int as an assertion message. 4606d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, int) { 4607d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << 900913, 4608d201456903f3ecae1f7794edfab0d5678e64226shiqian "900913"); 4609d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4610d201456903f3ecae1f7794edfab0d5678e64226shiqian 4611d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using NULL char pointer as an assertion message. 4612d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4613d201456903f3ecae1f7794edfab0d5678e64226shiqian// In MSVC, streaming a NULL char * causes access violation. Google Test 4614d201456903f3ecae1f7794edfab0d5678e64226shiqian// implemented a workaround (substituting "(null)" for NULL). This 4615d201456903f3ecae1f7794edfab0d5678e64226shiqian// tests whether the workaround works. 4616d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, NullCharPtr) { 4617d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << static_cast<const char*>(NULL), 4618d201456903f3ecae1f7794edfab0d5678e64226shiqian "(null)"); 4619d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4620d201456903f3ecae1f7794edfab0d5678e64226shiqian 4621d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that basic IO manipulators (endl, ends, and flush) can be 4622d201456903f3ecae1f7794edfab0d5678e64226shiqian// streamed to testing::Message. 4623d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamableTest, BasicIoManip) { 4624d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4625d201456903f3ecae1f7794edfab0d5678e64226shiqian FAIL() << "Line 1." << std::endl 4626d201456903f3ecae1f7794edfab0d5678e64226shiqian << "A NUL char " << std::ends << std::flush << " in line 2."; 4627d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Line 1.\nA NUL char \\0 in line 2."); 4628d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4629d201456903f3ecae1f7794edfab0d5678e64226shiqian 4630d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the macros that haven't been covered so far. 4631d201456903f3ecae1f7794edfab0d5678e64226shiqian 4632d201456903f3ecae1f7794edfab0d5678e64226shiqianvoid AddFailureHelper(bool* aborted) { 4633d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = true; 4634f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm ADD_FAILURE() << "Intentional failure."; 4635d201456903f3ecae1f7794edfab0d5678e64226shiqian *aborted = false; 4636d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4637d201456903f3ecae1f7794edfab0d5678e64226shiqian 4638d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests ADD_FAILURE. 4639d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, ADD_FAILURE) { 4640d201456903f3ecae1f7794edfab0d5678e64226shiqian bool aborted = true; 4641d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(AddFailureHelper(&aborted), 4642f0b86fc3b0f625e1db84f3632cb37bd9eae6ae19jgm "Intentional failure."); 4643d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(aborted); 4644d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4645d201456903f3ecae1f7794edfab0d5678e64226shiqian 46467c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan// Tests ADD_FAILURE_AT. 46477c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wanTEST(MacroTest, ADD_FAILURE_AT) { 46487c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Verifies that ADD_FAILURE_AT does generate a nonfatal failure and 46497c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // the failure message contains the user-streamed part. 46507c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42) << "Wrong!", "Wrong!"); 46517c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 46527c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Verifies that the user-streamed part is optional. 46537c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan EXPECT_NONFATAL_FAILURE(ADD_FAILURE_AT("foo.cc", 42), "Failed"); 46547c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 46557c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // Unfortunately, we cannot verify that the failure message contains 46567c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // the right file path and line number the same way, as 46577c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // EXPECT_NONFATAL_FAILURE() doesn't get to see the file path and 46587c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan // line number. Instead, we do that in gtest_output_test_.cc. 46597c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan} 46607c598c4f1a44fdda5f97587484c85bef9e93fa98zhanyong.wan 4661d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests FAIL. 4662d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, FAIL) { 4663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL(), 4664d201456903f3ecae1f7794edfab0d5678e64226shiqian "Failed"); 4665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "Intentional failure.", 4666d201456903f3ecae1f7794edfab0d5678e64226shiqian "Intentional failure."); 4667d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4668d201456903f3ecae1f7794edfab0d5678e64226shiqian 4669d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests SUCCEED 4670d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MacroTest, SUCCEED) { 4671d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED(); 4672d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "Explicit success."; 4673d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4674d201456903f3ecae1f7794edfab0d5678e64226shiqian 4675d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests for EXPECT_EQ() and ASSERT_EQ(). 4676d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4677d201456903f3ecae1f7794edfab0d5678e64226shiqian// These tests fail *intentionally*, s.t. the failure messages can be 4678d201456903f3ecae1f7794edfab0d5678e64226shiqian// generated and tested. 4679d201456903f3ecae1f7794edfab0d5678e64226shiqian// 4680d201456903f3ecae1f7794edfab0d5678e64226shiqian// We have different tests for different argument types. 4681d201456903f3ecae1f7794edfab0d5678e64226shiqian 4682d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using bool values in {EXPECT|ASSERT}_EQ. 4683d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Bool) { 4684d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(true, true); 468548b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan EXPECT_FATAL_FAILURE({ 468648b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan bool false_value = false; 468748b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan ASSERT_EQ(false_value, true); 468848b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan }, "Value of: true"); 4689d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4690d201456903f3ecae1f7794edfab0d5678e64226shiqian 4691d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using int values in {EXPECT|ASSERT}_EQ. 4692d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Int) { 4693d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(32, 32); 4694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(32, 33), 4695d201456903f3ecae1f7794edfab0d5678e64226shiqian "33"); 4696d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4697d201456903f3ecae1f7794edfab0d5678e64226shiqian 4698d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using time_t values in {EXPECT|ASSERT}_EQ. 4699d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Time_T) { 4700d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(static_cast<time_t>(0), 4701d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(0)); 4702d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<time_t>(0), 4703d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<time_t>(1234)), 4704d201456903f3ecae1f7794edfab0d5678e64226shiqian "1234"); 4705d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4706d201456903f3ecae1f7794edfab0d5678e64226shiqian 4707d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char values in {EXPECT|ASSERT}_EQ. 4708d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, Char) { 4709d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ('z', 'z'); 4710d201456903f3ecae1f7794edfab0d5678e64226shiqian const char ch = 'b'; 4711d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('\0', ch), 4712d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4713d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ('a', ch), 4714d201456903f3ecae1f7794edfab0d5678e64226shiqian "ch"); 4715d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4716d201456903f3ecae1f7794edfab0d5678e64226shiqian 4717d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t values in {EXPECT|ASSERT}_EQ. 4718d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideChar) { 4719d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(L'b', L'b'); 4720d201456903f3ecae1f7794edfab0d5678e64226shiqian 4721d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'), 4722d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: L'x'\n" 4723d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: L'x' (120, 0x78)\n" 4724d201456903f3ecae1f7794edfab0d5678e64226shiqian "Expected: L'\0'\n" 4725d201456903f3ecae1f7794edfab0d5678e64226shiqian "Which is: L'\0' (0, 0x0)"); 4726d201456903f3ecae1f7794edfab0d5678e64226shiqian 4727d201456903f3ecae1f7794edfab0d5678e64226shiqian static wchar_t wchar; 4728d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar = L'b'; 4729d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'a', wchar), 4730d201456903f3ecae1f7794edfab0d5678e64226shiqian "wchar"); 4731c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan wchar = 0x8119; 4732c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar), 4733d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: wchar"); 4734d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4735d201456903f3ecae1f7794edfab0d5678e64226shiqian 4736d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::string values in {EXPECT|ASSERT}_EQ. 4737d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdString) { 4738d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has identical 4739d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4740d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ("Test", ::std::string("Test")); 4741d201456903f3ecae1f7794edfab0d5678e64226shiqian 4742d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::strings. 4743d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str1("A * in the middle"); 4744d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::std::string str2(str1); 4745d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(str1, str2); 4746d201456903f3ecae1f7794edfab0d5678e64226shiqian 4747d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to an std::string that has different 4748d201456903f3ecae1f7794edfab0d5678e64226shiqian // content 4749d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ("Test", ::std::string("test")), 47505f18b68bfc96e69f8b1e5b7b5449f4890c1a2016zhanyong.wan "\"test\""); 4751d201456903f3ecae1f7794edfab0d5678e64226shiqian 4752d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::string to a char* that has different content. 4753d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = const_cast<char*>("foo"); 4754d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::std::string("bar"), p1), 4755d201456903f3ecae1f7794edfab0d5678e64226shiqian "p1"); 4756d201456903f3ecae1f7794edfab0d5678e64226shiqian 4757d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::strings that have different contents, one of 4758d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. This should fail. 4759d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::std::string str3(str1); 4760d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4761d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3), 4762d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: str3\n" 4763d201456903f3ecae1f7794edfab0d5678e64226shiqian " Actual: \"A \\0 in the middle\""); 4764d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4765d201456903f3ecae1f7794edfab0d5678e64226shiqian 4766d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_STD_WSTRING 4767d201456903f3ecae1f7794edfab0d5678e64226shiqian 4768d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::std::wstring values in {EXPECT|ASSERT}_EQ. 4769d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, StdWideString) { 4770d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical std::wstrings. 4771d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr1(L"A * in the middle"); 4772d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::std::wstring wstr2(wstr1); 4773d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(wstr1, wstr2); 4774d201456903f3ecae1f7794edfab0d5678e64226shiqian 4775c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Compares an std::wstring to a const wchar_t* that has identical 4776c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // content. 4777c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 4778c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(::std::wstring(kTestX8119), kTestX8119); 4779c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan 4780d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares an std::wstring to a const wchar_t* that has different 4781d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4782c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 4783d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4784c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(::std::wstring(kTestX8119), kTestX8120); 4785c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan }, "kTestX8120"); 4786d201456903f3ecae1f7794edfab0d5678e64226shiqian 4787d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two std::wstrings that have different contents, one of 4788d201456903f3ecae1f7794edfab0d5678e64226shiqian // which having a NUL character in the middle. 4789d201456903f3ecae1f7794edfab0d5678e64226shiqian ::std::wstring wstr3(wstr1); 4790d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4791d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(wstr1, wstr3), 4792d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4793d201456903f3ecae1f7794edfab0d5678e64226shiqian 4794d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to an std::wstring that has different 4795d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4796d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4797d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(const_cast<wchar_t*>(L"foo"), ::std::wstring(L"bar")); 4798d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4799d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4800d201456903f3ecae1f7794edfab0d5678e64226shiqian 4801d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_STD_WSTRING 4802d201456903f3ecae1f7794edfab0d5678e64226shiqian 4803d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_STRING 4804d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::string values in {EXPECT|ASSERT}_EQ. 4805d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalString) { 4806d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const char* to a ::string that has identical content. 4807d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ("Test", ::string("Test")); 4808d201456903f3ecae1f7794edfab0d5678e64226shiqian 4809d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::strings. 4810d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str1("A * in the middle"); 4811d201456903f3ecae1f7794edfab0d5678e64226shiqian const ::string str2(str1); 4812d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(str1, str2); 4813d201456903f3ecae1f7794edfab0d5678e64226shiqian 4814d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a const char* that has different content. 4815d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(::string("Test"), "test"), 4816d201456903f3ecae1f7794edfab0d5678e64226shiqian "test"); 4817d201456903f3ecae1f7794edfab0d5678e64226shiqian 4818d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::strings that have different contents, one of which 4819d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4820d201456903f3ecae1f7794edfab0d5678e64226shiqian ::string str3(str1); 4821d201456903f3ecae1f7794edfab0d5678e64226shiqian str3.at(2) = '\0'; 4822d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(str1, str3), 4823d201456903f3ecae1f7794edfab0d5678e64226shiqian "str3"); 4824d201456903f3ecae1f7794edfab0d5678e64226shiqian 4825d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a ::string to a char* that has different content. 4826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE({ // NOLINT 4827d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(::string("bar"), const_cast<char*>("foo")); 4828d201456903f3ecae1f7794edfab0d5678e64226shiqian }, ""); 4829d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4830d201456903f3ecae1f7794edfab0d5678e64226shiqian 4831d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_STRING 4832d201456903f3ecae1f7794edfab0d5678e64226shiqian 4833d201456903f3ecae1f7794edfab0d5678e64226shiqian#if GTEST_HAS_GLOBAL_WSTRING 4834d201456903f3ecae1f7794edfab0d5678e64226shiqian 4835d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using ::wstring values in {EXPECT|ASSERT}_EQ. 4836d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, GlobalWideString) { 4837d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two identical ::wstrings. 4838d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr1(L"A * in the middle"); 4839d201456903f3ecae1f7794edfab0d5678e64226shiqian static const ::wstring wstr2(wstr1); 4840d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(wstr1, wstr2); 4841d201456903f3ecae1f7794edfab0d5678e64226shiqian 4842c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan // Compares a const wchar_t* to a ::wstring that has identical content. 4843c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8119[] = { 'T', 'e', 's', 't', 0x8119, '\0' }; 4844c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan ASSERT_EQ(kTestX8119, ::wstring(kTestX8119)); 4845c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan 4846d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a const wchar_t* to a ::wstring that has different 4847d201456903f3ecae1f7794edfab0d5678e64226shiqian // content. 4848c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan const wchar_t kTestX8120[] = { 'T', 'e', 's', 't', 0x8120, '\0' }; 4849d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE({ // NOLINT 4850c18438ca2983d4f334cfdbd4453e15c41111fa17zhanyong.wan EXPECT_EQ(kTestX8120, ::wstring(kTestX8119)); 4851d201456903f3ecae1f7794edfab0d5678e64226shiqian }, "Test\\x8119"); 4852d201456903f3ecae1f7794edfab0d5678e64226shiqian 4853d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares a wchar_t* to a ::wstring that has different content. 4854d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = const_cast<wchar_t*>(L"foo"); 4855d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, ::wstring(L"bar")), 4856d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar"); 4857d201456903f3ecae1f7794edfab0d5678e64226shiqian 4858d201456903f3ecae1f7794edfab0d5678e64226shiqian // Compares two ::wstrings that have different contents, one of which 4859d201456903f3ecae1f7794edfab0d5678e64226shiqian // having a NUL character in the middle. 4860d201456903f3ecae1f7794edfab0d5678e64226shiqian static ::wstring wstr3; 4861d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3 = wstr1; 4862d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr3.at(2) = L'\0'; 4863d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(wstr1, wstr3), 4864d201456903f3ecae1f7794edfab0d5678e64226shiqian "wstr3"); 4865d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4866d201456903f3ecae1f7794edfab0d5678e64226shiqian 4867d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_HAS_GLOBAL_WSTRING 4868d201456903f3ecae1f7794edfab0d5678e64226shiqian 4869d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using char pointers in {EXPECT|ASSERT}_EQ. 4870d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, CharPointer) { 4871d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p0 = NULL; 4872d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4873d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4874d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4875d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4876d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4877d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4878d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = reinterpret_cast<char*>(pv1); 4879d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p2 = reinterpret_cast<char*>(pv2); 4880d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(p1, p1); 4881d201456903f3ecae1f7794edfab0d5678e64226shiqian 4882d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4883d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4884d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4885d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4886d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234), 4887d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<char*>(0xABC0)), 4888d201456903f3ecae1f7794edfab0d5678e64226shiqian "ABC0"); 4889d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4890d201456903f3ecae1f7794edfab0d5678e64226shiqian 4891d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using wchar_t pointers in {EXPECT|ASSERT}_EQ. 4892d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, WideCharPointer) { 4893d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p0 = NULL; 4894d201456903f3ecae1f7794edfab0d5678e64226shiqian // Only way to get the Nokia compiler to compile the cast 4895d201456903f3ecae1f7794edfab0d5678e64226shiqian // is to have a separate void* variable first. Putting 4896d201456903f3ecae1f7794edfab0d5678e64226shiqian // the two casts on the same line doesn't work, neither does 4897d201456903f3ecae1f7794edfab0d5678e64226shiqian // a direct C-style to char*. 4898d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv1 = (void*)0x1234; // NOLINT 4899d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv2 = (void*)0xABC0; // NOLINT 4900d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p1 = reinterpret_cast<wchar_t*>(pv1); 4901d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* const p2 = reinterpret_cast<wchar_t*>(pv2); 4902d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(p0, p0); 4903d201456903f3ecae1f7794edfab0d5678e64226shiqian 4904d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2), 4905d201456903f3ecae1f7794edfab0d5678e64226shiqian "Value of: p2"); 4906d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2), 4907d201456903f3ecae1f7794edfab0d5678e64226shiqian "p2"); 4908d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv3 = (void*)0x1234; // NOLINT 4909d201456903f3ecae1f7794edfab0d5678e64226shiqian void* pv4 = (void*)0xABC0; // NOLINT 4910d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p3 = reinterpret_cast<const wchar_t*>(pv3); 4911d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* p4 = reinterpret_cast<const wchar_t*>(pv4); 4912d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p3, p4), 4913d201456903f3ecae1f7794edfab0d5678e64226shiqian "p4"); 4914d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4915d201456903f3ecae1f7794edfab0d5678e64226shiqian 4916d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests using other types of pointers in {EXPECT|ASSERT}_EQ. 4917d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(EqAssertionTest, OtherPointer) { 4918d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(static_cast<const int*>(NULL), 4919d201456903f3ecae1f7794edfab0d5678e64226shiqian static_cast<const int*>(NULL)); 4920d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<const int*>(NULL), 4921d201456903f3ecae1f7794edfab0d5678e64226shiqian reinterpret_cast<const int*>(0x1234)), 4922d201456903f3ecae1f7794edfab0d5678e64226shiqian "0x1234"); 4923d201456903f3ecae1f7794edfab0d5678e64226shiqian} 4924d201456903f3ecae1f7794edfab0d5678e64226shiqian 4925e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// A class that supports binary comparison operators but not streaming. 4926e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wanclass UnprintableChar { 4927e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan public: 4928e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan explicit UnprintableChar(char ch) : char_(ch) {} 4929e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4930e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator==(const UnprintableChar& rhs) const { 4931e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ == rhs.char_; 4932e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4933e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator!=(const UnprintableChar& rhs) const { 4934e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ != rhs.char_; 4935e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4936e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator<(const UnprintableChar& rhs) const { 4937e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ < rhs.char_; 4938e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4939e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator<=(const UnprintableChar& rhs) const { 4940e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ <= rhs.char_; 4941e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4942e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator>(const UnprintableChar& rhs) const { 4943e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ > rhs.char_; 4944e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4945e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan bool operator>=(const UnprintableChar& rhs) const { 4946e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan return char_ >= rhs.char_; 4947e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan } 4948e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4949e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan private: 4950e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan char char_; 4951e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan}; 4952e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4953e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// Tests that ASSERT_EQ() and friends don't require the arguments to 4954e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan// be printable. 4955e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wanTEST(ComparisonAssertionTest, AcceptsUnprintableArgs) { 4956e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan const UnprintableChar x('x'), y('y'); 4957e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_EQ(x, x); 4958e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NE(x, y); 4959e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_LT(x, y); 4960e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_LE(x, y); 4961e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan ASSERT_GT(y, x); 4962e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_GE(x, x); 4963e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4964e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <78>"); 4965e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y), "1-byte object <79>"); 4966e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_LT(y, y), "1-byte object <79>"); 4967e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <78>"); 4968e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_GT(x, y), "1-byte object <79>"); 4969e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4970e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan // Code tested by EXPECT_FATAL_FAILURE cannot reference local 4971e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan // variables, so we have to write UnprintableChar('x') instead of x. 4972603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ 4973603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan // ICE's in C++Builder. 4974e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_NE(UnprintableChar('x'), UnprintableChar('x')), 4975e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4976e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 4977e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4978603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#endif 4979e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_LE(UnprintableChar('y'), UnprintableChar('x')), 4980e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <79>"); 4981e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 4982e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <78>"); 4983e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_GE(UnprintableChar('x'), UnprintableChar('y')), 4984e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan "1-byte object <79>"); 4985e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan} 4986e2a7f03b80fc0e9e6a6f36acb43776509486a6d4zhanyong.wan 4987d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the FRIEND_TEST macro. 4988d201456903f3ecae1f7794edfab0d5678e64226shiqian 4989d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class has a private member we want to test. We will test it 4990d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a TEST and in a TEST_F. 4991d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Foo { 4992d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 4993d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo() {} 4994d201456903f3ecae1f7794edfab0d5678e64226shiqian 4995d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 4996d201456903f3ecae1f7794edfab0d5678e64226shiqian int Bar() const { return 1; } 4997d201456903f3ecae1f7794edfab0d5678e64226shiqian 4998d201456903f3ecae1f7794edfab0d5678e64226shiqian // Declares the friend tests that can access the private member 4999d201456903f3ecae1f7794edfab0d5678e64226shiqian // Bar(). 5000d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test, TEST); 5001d201456903f3ecae1f7794edfab0d5678e64226shiqian FRIEND_TEST(FRIEND_TEST_Test2, TEST_F); 5002d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5003d201456903f3ecae1f7794edfab0d5678e64226shiqian 5004d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST to access a 5005d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 5006d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(FRIEND_TEST_Test, TEST) { 5007d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, Foo().Bar()); 5008d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5009d201456903f3ecae1f7794edfab0d5678e64226shiqian 5010d201456903f3ecae1f7794edfab0d5678e64226shiqian// The fixture needed to test using FRIEND_TEST with TEST_F. 50119b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass FRIEND_TEST_Test2 : public Test { 5012d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5013d201456903f3ecae1f7794edfab0d5678e64226shiqian Foo foo; 5014d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5015d201456903f3ecae1f7794edfab0d5678e64226shiqian 5016d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that the FRIEND_TEST declaration allows a TEST_F to access a 5017d201456903f3ecae1f7794edfab0d5678e64226shiqian// class's private members. This should compile. 5018d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(FRIEND_TEST_Test2, TEST_F) { 5019d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, foo.Bar()); 5020d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5021d201456903f3ecae1f7794edfab0d5678e64226shiqian 5022d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of Test objects. 5023d201456903f3ecae1f7794edfab0d5678e64226shiqian 5024d201456903f3ecae1f7794edfab0d5678e64226shiqian// The test fixture for testing the life cycle of Test objects. 5025d201456903f3ecae1f7794edfab0d5678e64226shiqian// 5026d201456903f3ecae1f7794edfab0d5678e64226shiqian// This class counts the number of live test objects that uses this 5027d201456903f3ecae1f7794edfab0d5678e64226shiqian// fixture. 50289b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestLifeCycleTest : public Test { 5029d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5030d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructor. Increments the number of test objects that uses 5031d201456903f3ecae1f7794edfab0d5678e64226shiqian // this fixture. 5032d201456903f3ecae1f7794edfab0d5678e64226shiqian TestLifeCycleTest() { count_++; } 5033d201456903f3ecae1f7794edfab0d5678e64226shiqian 5034d201456903f3ecae1f7794edfab0d5678e64226shiqian // Destructor. Decrements the number of test objects that uses this 5035d201456903f3ecae1f7794edfab0d5678e64226shiqian // fixture. 5036d201456903f3ecae1f7794edfab0d5678e64226shiqian ~TestLifeCycleTest() { count_--; } 5037d201456903f3ecae1f7794edfab0d5678e64226shiqian 5038d201456903f3ecae1f7794edfab0d5678e64226shiqian // Returns the number of live test objects that uses this fixture. 5039d201456903f3ecae1f7794edfab0d5678e64226shiqian int count() const { return count_; } 5040d201456903f3ecae1f7794edfab0d5678e64226shiqian 5041d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 5042d201456903f3ecae1f7794edfab0d5678e64226shiqian static int count_; 5043d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5044d201456903f3ecae1f7794edfab0d5678e64226shiqian 5045d201456903f3ecae1f7794edfab0d5678e64226shiqianint TestLifeCycleTest::count_ = 0; 5046d201456903f3ecae1f7794edfab0d5678e64226shiqian 5047d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 5048d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test1) { 5049d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be only one test object in this test case that's 5050d201456903f3ecae1f7794edfab0d5678e64226shiqian // currently alive. 5051d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 5052d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5053d201456903f3ecae1f7794edfab0d5678e64226shiqian 5054d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the life cycle of test objects. 5055d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestLifeCycleTest, Test2) { 5056d201456903f3ecae1f7794edfab0d5678e64226shiqian // After Test1 is done and Test2 is started, there should still be 5057d201456903f3ecae1f7794edfab0d5678e64226shiqian // only one live test object, as the object for Test1 should've been 5058d201456903f3ecae1f7794edfab0d5678e64226shiqian // deleted. 5059d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, count()); 5060d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5061d201456903f3ecae1f7794edfab0d5678e64226shiqian 5062d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 5063d201456903f3ecae1f7794edfab0d5678e64226shiqian 5064bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests that the copy constructor works when it is NOT optimized away by 5065bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// the compiler. 5066bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, CopyConstructorWorksWhenNotOptimied) { 5067bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // Checks that the copy constructor doesn't try to dereference NULL pointers 5068bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // in the source object. 5069bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess(); 5070bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = r1; 5071bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // The following line is added to prevent the compiler from optimizing 5072bad778caa39a88b7c11b159e20730aeec4fd711evladlosev // away the constructor call. 5073bad778caa39a88b7c11b159e20730aeec4fd711evladlosev r1 << "abc"; 5074bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5075bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r3 = r1; 5076bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_EQ(static_cast<bool>(r3), static_cast<bool>(r1)); 5077bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", r1.message()); 5078bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 5079bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5080bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// Tests that AssertionSuccess and AssertionFailure construct 5081bad778caa39a88b7c11b159e20730aeec4fd711evladlosev// AssertionResult objects as expected. 5082bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, ConstructionWorks) { 5083bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess(); 5084bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(r1); 5085bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("", r1.message()); 5086bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5087bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = AssertionSuccess() << "abc"; 5088bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(r2); 5089bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", r2.message()); 5090bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5091bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r3 = AssertionFailure(); 5092bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r3); 5093bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("", r3.message()); 5094bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5095bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r4 = AssertionFailure() << "def"; 5096bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r4); 5097bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("def", r4.message()); 5098bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5099bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r5 = AssertionFailure(Message() << "ghi"); 5100bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(r5); 5101bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("ghi", r5.message()); 5102bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 5103bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 510425958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev// Tests that the negation flips the predicate result but keeps the message. 5105bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, NegationWorks) { 5106bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r1 = AssertionSuccess() << "abc"; 5107bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_FALSE(!r1); 5108bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abc", (!r1).message()); 5109bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5110bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r2 = AssertionFailure() << "def"; 5111bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_TRUE(!r2); 5112bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("def", (!r2).message()); 5113bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 5114bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 5115bad778caa39a88b7c11b159e20730aeec4fd711evladlosevTEST(AssertionResultTest, StreamingWorks) { 5116bad778caa39a88b7c11b159e20730aeec4fd711evladlosev AssertionResult r = AssertionSuccess(); 5117bad778caa39a88b7c11b159e20730aeec4fd711evladlosev r << "abc" << 'd' << 0 << true; 5118bad778caa39a88b7c11b159e20730aeec4fd711evladlosev EXPECT_STREQ("abcd0true", r.message()); 511925958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev} 512025958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev 512125958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosevTEST(AssertionResultTest, CanStreamOstreamManipulators) { 512225958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev AssertionResult r = AssertionSuccess(); 512325958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev r << "Data" << std::endl << std::flush << std::ends << "Will be visible"; 512425958f3e4c4097caca8347b7937f5f6fb26d6c56vladlosev EXPECT_STREQ("Data\n\\0Will be visible", r.message()); 5125bad778caa39a88b7c11b159e20730aeec4fd711evladlosev} 5126bad778caa39a88b7c11b159e20730aeec4fd711evladlosev 51278120f66c3249e253f03fdb48bee7e528bc038d31billydonahue// The next test uses explicit conversion operators -- a C++11 feature. 51288120f66c3249e253f03fdb48bee7e528bc038d31billydonahue#if GTEST_LANG_CXX11 51298120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 51308120f66c3249e253f03fdb48bee7e528bc038d31billydonahueTEST(AssertionResultTest, ConstructibleFromContextuallyConvertibleToBool) { 51318120f66c3249e253f03fdb48bee7e528bc038d31billydonahue struct ExplicitlyConvertibleToBool { 51328120f66c3249e253f03fdb48bee7e528bc038d31billydonahue explicit operator bool() const { return value; } 51338120f66c3249e253f03fdb48bee7e528bc038d31billydonahue bool value; 51348120f66c3249e253f03fdb48bee7e528bc038d31billydonahue }; 51358120f66c3249e253f03fdb48bee7e528bc038d31billydonahue ExplicitlyConvertibleToBool v1 = {false}; 51368120f66c3249e253f03fdb48bee7e528bc038d31billydonahue ExplicitlyConvertibleToBool v2 = {true}; 51378120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_FALSE(v1); 51388120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_TRUE(v2); 51398120f66c3249e253f03fdb48bee7e528bc038d31billydonahue} 51408120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 51418120f66c3249e253f03fdb48bee7e528bc038d31billydonahue#endif // GTEST_LANG_CXX11 51428120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 51438120f66c3249e253f03fdb48bee7e528bc038d31billydonahuestruct ConvertibleToAssertionResult { 51448120f66c3249e253f03fdb48bee7e528bc038d31billydonahue operator AssertionResult() const { return AssertionResult(true); } 51458120f66c3249e253f03fdb48bee7e528bc038d31billydonahue}; 51468120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 51478120f66c3249e253f03fdb48bee7e528bc038d31billydonahueTEST(AssertionResultTest, ConstructibleFromImplicitlyConvertible) { 51488120f66c3249e253f03fdb48bee7e528bc038d31billydonahue ConvertibleToAssertionResult obj; 51498120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_TRUE(obj); 51508120f66c3249e253f03fdb48bee7e528bc038d31billydonahue} 51518120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 5152d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator << are 5153d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in the global namespace. 5154d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Base { 5155d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 5156d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit Base(int an_x) : x_(an_x) {} 5157d201456903f3ecae1f7794edfab0d5678e64226shiqian int x() const { return x_; } 5158d201456903f3ecae1f7794edfab0d5678e64226shiqian private: 5159d201456903f3ecae1f7794edfab0d5678e64226shiqian int x_; 5160d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5161d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5162d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base& val) { 5163d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 5164d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5165d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5166d201456903f3ecae1f7794edfab0d5678e64226shiqian const Base* pointer) { 5167d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 5168d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5169d201456903f3ecae1f7794edfab0d5678e64226shiqian 5170d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInGlobalNameSpace) { 51719b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5172d201456903f3ecae1f7794edfab0d5678e64226shiqian Base a(1); 5173d201456903f3ecae1f7794edfab0d5678e64226shiqian 5174d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 5175d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5176d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5177d201456903f3ecae1f7794edfab0d5678e64226shiqian 5178d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 5179d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in an unnamed namespace. 5180d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace { 5181d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInUnnamedNameSpace : public Base { 5182d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 5183d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInUnnamedNameSpace(int an_x): Base(an_x) {} 5184d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5185d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5186d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace& val) { 5187d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 5188d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5189d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5190d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInUnnamedNameSpace* pointer) { 5191d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 5192d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5193d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace 5194d201456903f3ecae1f7794edfab0d5678e64226shiqian 5195d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUnnamedNameSpace) { 51969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5197d201456903f3ecae1f7794edfab0d5678e64226shiqian MyTypeInUnnamedNameSpace a(1); 5198d201456903f3ecae1f7794edfab0d5678e64226shiqian 5199d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses <unnamed_namespace>::operator<<. 5200d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5201d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5202d201456903f3ecae1f7794edfab0d5678e64226shiqian 5203d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition and operator<< are 5204d201456903f3ecae1f7794edfab0d5678e64226shiqian// both in a user namespace. 5205d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace1 { 5206d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace1 : public Base { 5207d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 5208d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInNameSpace1(int an_x): Base(an_x) {} 5209d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5210d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5211d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1& val) { 5212d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 5213d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5214d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5215d201456903f3ecae1f7794edfab0d5678e64226shiqian const MyTypeInNameSpace1* pointer) { 5216d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 5217d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5218d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace1 5219d201456903f3ecae1f7794edfab0d5678e64226shiqian 5220d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpace) { 52219b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5222d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace1::MyTypeInNameSpace1 a(1); 5223d201456903f3ecae1f7794edfab0d5678e64226shiqian 5224d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses namespace1::operator<<. 5225d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5226d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5227d201456903f3ecae1f7794edfab0d5678e64226shiqian 5228d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming a user type whose definition is in a user namespace 5229d201456903f3ecae1f7794edfab0d5678e64226shiqian// but whose operator<< is in the global namespace. 5230d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace namespace2 { 5231d201456903f3ecae1f7794edfab0d5678e64226shiqianclass MyTypeInNameSpace2 : public ::Base { 5232d201456903f3ecae1f7794edfab0d5678e64226shiqian public: 5233d56773b492b7b675d5c547baab815289a7815bddzhanyong.wan explicit MyTypeInNameSpace2(int an_x): Base(an_x) {} 5234d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5235d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace namespace2 5236d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5237d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2& val) { 5238d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << val.x(); 5239d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5240d201456903f3ecae1f7794edfab0d5678e64226shiqianstd::ostream& operator<<(std::ostream& os, 5241d201456903f3ecae1f7794edfab0d5678e64226shiqian const namespace2::MyTypeInNameSpace2* pointer) { 5242d201456903f3ecae1f7794edfab0d5678e64226shiqian return os << "(" << pointer->x() << ")"; 5243d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5244d201456903f3ecae1f7794edfab0d5678e64226shiqian 5245d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, CanStreamUserTypeInUserNameSpaceWithStreamOperatorInGlobal) { 52469b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5247d201456903f3ecae1f7794edfab0d5678e64226shiqian namespace2::MyTypeInNameSpace2 a(1); 5248d201456903f3ecae1f7794edfab0d5678e64226shiqian 5249d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << a << &a; // Uses ::operator<<. 5250d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("1(1)", msg.GetString().c_str()); 5251d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5252d201456903f3ecae1f7794edfab0d5678e64226shiqian 5253d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming NULL pointers to testing::Message. 5254d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, NullPointers) { 52559b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message msg; 5256d201456903f3ecae1f7794edfab0d5678e64226shiqian char* const p1 = NULL; 5257d201456903f3ecae1f7794edfab0d5678e64226shiqian unsigned char* const p2 = NULL; 5258d201456903f3ecae1f7794edfab0d5678e64226shiqian int* p3 = NULL; 5259d201456903f3ecae1f7794edfab0d5678e64226shiqian double* p4 = NULL; 5260d201456903f3ecae1f7794edfab0d5678e64226shiqian bool* p5 = NULL; 52619b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Message* p6 = NULL; 5262d201456903f3ecae1f7794edfab0d5678e64226shiqian 5263d201456903f3ecae1f7794edfab0d5678e64226shiqian msg << p1 << p2 << p3 << p4 << p5 << p6; 5264d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("(null)(null)(null)(null)(null)(null)", 5265d201456903f3ecae1f7794edfab0d5678e64226shiqian msg.GetString().c_str()); 5266d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5267d201456903f3ecae1f7794edfab0d5678e64226shiqian 5268d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests streaming wide strings to testing::Message. 5269d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(MessageTest, WideStrings) { 5270d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type const wchar_t*. 5271d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* const_wstr = NULL; 5272d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 5273d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 5274d201456903f3ecae1f7794edfab0d5678e64226shiqian 5275d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a NULL of type wchar_t*. 5276d201456903f3ecae1f7794edfab0d5678e64226shiqian wchar_t* wstr = NULL; 5277d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("(null)", 5278d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 5279d201456903f3ecae1f7794edfab0d5678e64226shiqian 5280d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type const wchar_t*. 5281d201456903f3ecae1f7794edfab0d5678e64226shiqian const_wstr = L"abc\x8119"; 5282d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 5283d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << const_wstr).GetString().c_str()); 5284d201456903f3ecae1f7794edfab0d5678e64226shiqian 5285d201456903f3ecae1f7794edfab0d5678e64226shiqian // Streams a non-NULL of type wchar_t*. 5286d201456903f3ecae1f7794edfab0d5678e64226shiqian wstr = const_cast<wchar_t*>(const_wstr); 5287d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("abc\xe8\x84\x99", 5288d201456903f3ecae1f7794edfab0d5678e64226shiqian (Message() << wstr).GetString().c_str()); 5289d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5290d201456903f3ecae1f7794edfab0d5678e64226shiqian 5291d201456903f3ecae1f7794edfab0d5678e64226shiqian 5292d201456903f3ecae1f7794edfab0d5678e64226shiqian// This line tests that we can define tests in the testing namespace. 5293d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 5294d201456903f3ecae1f7794edfab0d5678e64226shiqian 5295d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests the TestInfo class. 5296d201456903f3ecae1f7794edfab0d5678e64226shiqian 52979b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass TestInfoTest : public Test { 5298d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5299b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan static const TestInfo* GetTestInfo(const char* test_name) { 5300b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestCase* const test_case = GetUnitTestImpl()-> 5301b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan GetTestCase("TestInfoTest", "", NULL, NULL); 5302b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan 5303b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan for (int i = 0; i < test_case->total_test_count(); ++i) { 5304b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = test_case->GetTestInfo(i); 5305b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan if (strcmp(test_name, test_info->name()) == 0) 5306b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return test_info; 5307b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan } 5308b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan return NULL; 5309d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5310d201456903f3ecae1f7794edfab0d5678e64226shiqian 5311d201456903f3ecae1f7794edfab0d5678e64226shiqian static const TestResult* GetTestResult( 53129b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian const TestInfo* test_info) { 5313d201456903f3ecae1f7794edfab0d5678e64226shiqian return test_info->result(); 5314d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5315d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5316d201456903f3ecae1f7794edfab0d5678e64226shiqian 5317d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::test_case_name() and TestInfo::name(). 5318d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, Names) { 5319b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("Names"); 5320d201456903f3ecae1f7794edfab0d5678e64226shiqian 5321d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("TestInfoTest", test_info->test_case_name()); 5322d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("Names", test_info->name()); 5323d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5324d201456903f3ecae1f7794edfab0d5678e64226shiqian 5325d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests TestInfo::result(). 5326d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(TestInfoTest, result) { 5327b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan const TestInfo* const test_info = GetTestInfo("result"); 5328d201456903f3ecae1f7794edfab0d5678e64226shiqian 5329d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initially, there is no TestPartResult for this test. 5330b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 5331d201456903f3ecae1f7794edfab0d5678e64226shiqian 5332d201456903f3ecae1f7794edfab0d5678e64226shiqian // After the previous assertion, there is still none. 5333b2db677c9905a34ca6454aa526f7a0cc5cfaeca1zhanyong.wan ASSERT_EQ(0, GetTestResult(test_info)->total_part_count()); 5334d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5335d201456903f3ecae1f7794edfab0d5678e64226shiqian 53364f8dc917ebce062f75defee3d4890bbcd07e277bkosak#define VERIFY_CODE_LOCATION \ 53374f8dc917ebce062f75defee3d4890bbcd07e277bkosak const int expected_line = __LINE__ - 1; \ 53384f8dc917ebce062f75defee3d4890bbcd07e277bkosak const TestInfo* const test_info = GetUnitTestImpl()->current_test_info(); \ 53394f8dc917ebce062f75defee3d4890bbcd07e277bkosak ASSERT_TRUE(test_info); \ 53404f8dc917ebce062f75defee3d4890bbcd07e277bkosak EXPECT_STREQ(__FILE__, test_info->file()); \ 53414f8dc917ebce062f75defee3d4890bbcd07e277bkosak EXPECT_EQ(expected_line, test_info->line()) 53424f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53434f8dc917ebce062f75defee3d4890bbcd07e277bkosakTEST(CodeLocationForTEST, Verify) { 53444f8dc917ebce062f75defee3d4890bbcd07e277bkosak VERIFY_CODE_LOCATION; 53454f8dc917ebce062f75defee3d4890bbcd07e277bkosak} 53464f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53474f8dc917ebce062f75defee3d4890bbcd07e277bkosakclass CodeLocationForTESTF : public Test { 53484f8dc917ebce062f75defee3d4890bbcd07e277bkosak}; 53494f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53504f8dc917ebce062f75defee3d4890bbcd07e277bkosakTEST_F(CodeLocationForTESTF, Verify) { 53514f8dc917ebce062f75defee3d4890bbcd07e277bkosak VERIFY_CODE_LOCATION; 53524f8dc917ebce062f75defee3d4890bbcd07e277bkosak} 53534f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53544f8dc917ebce062f75defee3d4890bbcd07e277bkosakclass CodeLocationForTESTP : public TestWithParam<int> { 53554f8dc917ebce062f75defee3d4890bbcd07e277bkosak}; 53564f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53574f8dc917ebce062f75defee3d4890bbcd07e277bkosakTEST_P(CodeLocationForTESTP, Verify) { 53584f8dc917ebce062f75defee3d4890bbcd07e277bkosak VERIFY_CODE_LOCATION; 53594f8dc917ebce062f75defee3d4890bbcd07e277bkosak} 53604f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53614f8dc917ebce062f75defee3d4890bbcd07e277bkosakINSTANTIATE_TEST_CASE_P(, CodeLocationForTESTP, Values(0)); 53624f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53634f8dc917ebce062f75defee3d4890bbcd07e277bkosaktemplate <typename T> 53644f8dc917ebce062f75defee3d4890bbcd07e277bkosakclass CodeLocationForTYPEDTEST : public Test { 53654f8dc917ebce062f75defee3d4890bbcd07e277bkosak}; 53664f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53674f8dc917ebce062f75defee3d4890bbcd07e277bkosakTYPED_TEST_CASE(CodeLocationForTYPEDTEST, int); 53684f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53694f8dc917ebce062f75defee3d4890bbcd07e277bkosakTYPED_TEST(CodeLocationForTYPEDTEST, Verify) { 53704f8dc917ebce062f75defee3d4890bbcd07e277bkosak VERIFY_CODE_LOCATION; 53714f8dc917ebce062f75defee3d4890bbcd07e277bkosak} 53724f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53734f8dc917ebce062f75defee3d4890bbcd07e277bkosaktemplate <typename T> 53744f8dc917ebce062f75defee3d4890bbcd07e277bkosakclass CodeLocationForTYPEDTESTP : public Test { 53754f8dc917ebce062f75defee3d4890bbcd07e277bkosak}; 53764f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53774f8dc917ebce062f75defee3d4890bbcd07e277bkosakTYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP); 53784f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53794f8dc917ebce062f75defee3d4890bbcd07e277bkosakTYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) { 53804f8dc917ebce062f75defee3d4890bbcd07e277bkosak VERIFY_CODE_LOCATION; 53814f8dc917ebce062f75defee3d4890bbcd07e277bkosak} 53824f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53834f8dc917ebce062f75defee3d4890bbcd07e277bkosakREGISTER_TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP, Verify); 53844f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53854f8dc917ebce062f75defee3d4890bbcd07e277bkosakINSTANTIATE_TYPED_TEST_CASE_P(My, CodeLocationForTYPEDTESTP, int); 53864f8dc917ebce062f75defee3d4890bbcd07e277bkosak 53874f8dc917ebce062f75defee3d4890bbcd07e277bkosak#undef VERIFY_CODE_LOCATION 53884f8dc917ebce062f75defee3d4890bbcd07e277bkosak 5389d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests setting up and tearing down a test case. 5390d201456903f3ecae1f7794edfab0d5678e64226shiqian 53919b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass SetUpTestCaseTest : public Test { 5392d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5393d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once before the first test in this test case 5394d201456903f3ecae1f7794edfab0d5678e64226shiqian // is run. 5395d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 5396d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Setting up the test case . . .\n"); 5397d201456903f3ecae1f7794edfab0d5678e64226shiqian 5398d201456903f3ecae1f7794edfab0d5678e64226shiqian // Initializes some shared resource. In this simple example, we 5399d201456903f3ecae1f7794edfab0d5678e64226shiqian // just create a C string. More complex stuff can be done if 5400d201456903f3ecae1f7794edfab0d5678e64226shiqian // desired. 5401d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = "123"; 5402d201456903f3ecae1f7794edfab0d5678e64226shiqian 5403d201456903f3ecae1f7794edfab0d5678e64226shiqian // Increments the number of test cases that have been set up. 5404d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_++; 5405d201456903f3ecae1f7794edfab0d5678e64226shiqian 5406d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once. 5407d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 5408d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5409d201456903f3ecae1f7794edfab0d5678e64226shiqian 5410d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called once after the last test in this test case is 5411d201456903f3ecae1f7794edfab0d5678e64226shiqian // run. 5412d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 5413d201456903f3ecae1f7794edfab0d5678e64226shiqian printf("Tearing down the test case . . .\n"); 5414d201456903f3ecae1f7794edfab0d5678e64226shiqian 5415d201456903f3ecae1f7794edfab0d5678e64226shiqian // Decrements the number of test cases that have been set up. 5416d201456903f3ecae1f7794edfab0d5678e64226shiqian counter_--; 5417d201456903f3ecae1f7794edfab0d5678e64226shiqian 5418d201456903f3ecae1f7794edfab0d5678e64226shiqian // TearDownTestCase() should be called only once. 5419d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(0, counter_); 5420d201456903f3ecae1f7794edfab0d5678e64226shiqian 5421d201456903f3ecae1f7794edfab0d5678e64226shiqian // Cleans up the shared resource. 5422d201456903f3ecae1f7794edfab0d5678e64226shiqian shared_resource_ = NULL; 5423d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5424d201456903f3ecae1f7794edfab0d5678e64226shiqian 5425d201456903f3ecae1f7794edfab0d5678e64226shiqian // This will be called before each test in this test case. 5426d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 5427d201456903f3ecae1f7794edfab0d5678e64226shiqian // SetUpTestCase() should be called only once, so counter_ should 5428d201456903f3ecae1f7794edfab0d5678e64226shiqian // always be 1. 5429d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, counter_); 5430d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5431d201456903f3ecae1f7794edfab0d5678e64226shiqian 5432d201456903f3ecae1f7794edfab0d5678e64226shiqian // Number of test cases that have been set up. 5433d201456903f3ecae1f7794edfab0d5678e64226shiqian static int counter_; 5434d201456903f3ecae1f7794edfab0d5678e64226shiqian 5435d201456903f3ecae1f7794edfab0d5678e64226shiqian // Some resource to be shared by all tests in this test case. 5436d201456903f3ecae1f7794edfab0d5678e64226shiqian static const char* shared_resource_; 5437d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5438d201456903f3ecae1f7794edfab0d5678e64226shiqian 5439d201456903f3ecae1f7794edfab0d5678e64226shiqianint SetUpTestCaseTest::counter_ = 0; 5440d201456903f3ecae1f7794edfab0d5678e64226shiqianconst char* SetUpTestCaseTest::shared_resource_ = NULL; 5441d201456903f3ecae1f7794edfab0d5678e64226shiqian 5442d201456903f3ecae1f7794edfab0d5678e64226shiqian// A test that uses the shared resource. 5443d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test1) { 5444d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE(NULL, shared_resource_); 5445d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5446d201456903f3ecae1f7794edfab0d5678e64226shiqian 5447d201456903f3ecae1f7794edfab0d5678e64226shiqian// Another test that uses the shared resource. 5448d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(SetUpTestCaseTest, Test2) { 5449d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("123", shared_resource_); 5450d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5451d201456903f3ecae1f7794edfab0d5678e64226shiqian 5452d201456903f3ecae1f7794edfab0d5678e64226shiqian// The InitGoogleTestTest test case tests testing::InitGoogleTest(). 5453d201456903f3ecae1f7794edfab0d5678e64226shiqian 5454d201456903f3ecae1f7794edfab0d5678e64226shiqian// The Flags struct stores a copy of all Google Test flags. 5455d201456903f3ecae1f7794edfab0d5678e64226shiqianstruct Flags { 5456d201456903f3ecae1f7794edfab0d5678e64226shiqian // Constructs a Flags struct where each flag has its default value. 5457fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags() : also_run_disabled_tests(false), 5458fe186c382905dcf57014985ccea8e067275e9f5fshiqian break_on_failure(false), 5459d201456903f3ecae1f7794edfab0d5678e64226shiqian catch_exceptions(false), 546053e0dc4041f660b6517b15b08b496e164be614f1shiqian death_test_use_fork(false), 5461d201456903f3ecae1f7794edfab0d5678e64226shiqian filter(""), 5462d201456903f3ecae1f7794edfab0d5678e64226shiqian list_tests(false), 5463d201456903f3ecae1f7794edfab0d5678e64226shiqian output(""), 5464f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan print_time(true), 54658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan random_seed(0), 546640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan repeat(1), 54678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan shuffle(false), 5468bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev stack_trace_depth(kMaxStackTraceDepth), 5469a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan stream_result_to(""), 547040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan throw_on_failure(false) {} 5471d201456903f3ecae1f7794edfab0d5678e64226shiqian 5472d201456903f3ecae1f7794edfab0d5678e64226shiqian // Factory methods. 5473d201456903f3ecae1f7794edfab0d5678e64226shiqian 5474fe186c382905dcf57014985ccea8e067275e9f5fshiqian // Creates a Flags struct where the gtest_also_run_disabled_tests flag has 5475fe186c382905dcf57014985ccea8e067275e9f5fshiqian // the given value. 5476fe186c382905dcf57014985ccea8e067275e9f5fshiqian static Flags AlsoRunDisabledTests(bool also_run_disabled_tests) { 5477fe186c382905dcf57014985ccea8e067275e9f5fshiqian Flags flags; 5478fe186c382905dcf57014985ccea8e067275e9f5fshiqian flags.also_run_disabled_tests = also_run_disabled_tests; 5479fe186c382905dcf57014985ccea8e067275e9f5fshiqian return flags; 5480fe186c382905dcf57014985ccea8e067275e9f5fshiqian } 5481fe186c382905dcf57014985ccea8e067275e9f5fshiqian 5482d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_break_on_failure flag has 5483d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 5484d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags BreakOnFailure(bool break_on_failure) { 5485d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5486d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = break_on_failure; 5487d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5488d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5489d201456903f3ecae1f7794edfab0d5678e64226shiqian 5490d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_catch_exceptions flag has 5491d201456903f3ecae1f7794edfab0d5678e64226shiqian // the given value. 5492d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags CatchExceptions(bool catch_exceptions) { 5493d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5494d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.catch_exceptions = catch_exceptions; 5495d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5496d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5497d201456903f3ecae1f7794edfab0d5678e64226shiqian 549853e0dc4041f660b6517b15b08b496e164be614f1shiqian // Creates a Flags struct where the gtest_death_test_use_fork flag has 549953e0dc4041f660b6517b15b08b496e164be614f1shiqian // the given value. 550053e0dc4041f660b6517b15b08b496e164be614f1shiqian static Flags DeathTestUseFork(bool death_test_use_fork) { 550153e0dc4041f660b6517b15b08b496e164be614f1shiqian Flags flags; 550253e0dc4041f660b6517b15b08b496e164be614f1shiqian flags.death_test_use_fork = death_test_use_fork; 550353e0dc4041f660b6517b15b08b496e164be614f1shiqian return flags; 550453e0dc4041f660b6517b15b08b496e164be614f1shiqian } 550553e0dc4041f660b6517b15b08b496e164be614f1shiqian 5506d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_filter flag has the given 5507d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5508d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Filter(const char* filter) { 5509d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5510d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = filter; 5511d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5512d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5513d201456903f3ecae1f7794edfab0d5678e64226shiqian 5514d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_list_tests flag has the 5515d201456903f3ecae1f7794edfab0d5678e64226shiqian // given value. 5516d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags ListTests(bool list_tests) { 5517d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5518d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.list_tests = list_tests; 5519d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5520d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5521d201456903f3ecae1f7794edfab0d5678e64226shiqian 5522d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_output flag has the given 5523d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5524d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Output(const char* output) { 5525d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5526d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.output = output; 5527d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5528d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5529d201456903f3ecae1f7794edfab0d5678e64226shiqian 553015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // Creates a Flags struct where the gtest_print_time flag has the given 553115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian // value. 553215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian static Flags PrintTime(bool print_time) { 553315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian Flags flags; 553415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian flags.print_time = print_time; 553515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian return flags; 553615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian } 553715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 55388bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_random_seed flag has 55398bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 55408bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags RandomSeed(Int32 random_seed) { 55418bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 55428bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.random_seed = random_seed; 55438bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 55448bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 55458bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5546d201456903f3ecae1f7794edfab0d5678e64226shiqian // Creates a Flags struct where the gtest_repeat flag has the given 5547d201456903f3ecae1f7794edfab0d5678e64226shiqian // value. 5548d201456903f3ecae1f7794edfab0d5678e64226shiqian static Flags Repeat(Int32 repeat) { 5549d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5550d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.repeat = repeat; 5551d201456903f3ecae1f7794edfab0d5678e64226shiqian return flags; 5552d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5553d201456903f3ecae1f7794edfab0d5678e64226shiqian 55548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // Creates a Flags struct where the gtest_shuffle flag has 55558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan // the given value. 55568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan static Flags Shuffle(bool shuffle) { 55578bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Flags flags; 55588bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan flags.shuffle = shuffle; 55598bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan return flags; 55608bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan } 55618bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 5562bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // Creates a Flags struct where the GTEST_FLAG(stack_trace_depth) flag has 5563bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // the given value. 5564bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev static Flags StackTraceDepth(Int32 stack_trace_depth) { 5565bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags flags; 5566bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev flags.stack_trace_depth = stack_trace_depth; 5567bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev return flags; 5568bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev } 5569bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5570a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan // Creates a Flags struct where the GTEST_FLAG(stream_result_to) flag has 5571a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan // the given value. 5572a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan static Flags StreamResultTo(const char* stream_result_to) { 5573a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan Flags flags; 5574a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan flags.stream_result_to = stream_result_to; 5575a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan return flags; 5576a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan } 5577a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 557840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // Creates a Flags struct where the gtest_throw_on_failure flag has 557940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan // the given value. 558040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan static Flags ThrowOnFailure(bool throw_on_failure) { 558140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan Flags flags; 558240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan flags.throw_on_failure = throw_on_failure; 558340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan return flags; 558440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan } 558540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 5586d201456903f3ecae1f7794edfab0d5678e64226shiqian // These fields store the flag values. 5587fe186c382905dcf57014985ccea8e067275e9f5fshiqian bool also_run_disabled_tests; 5588d201456903f3ecae1f7794edfab0d5678e64226shiqian bool break_on_failure; 5589d201456903f3ecae1f7794edfab0d5678e64226shiqian bool catch_exceptions; 559053e0dc4041f660b6517b15b08b496e164be614f1shiqian bool death_test_use_fork; 5591d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* filter; 5592d201456903f3ecae1f7794edfab0d5678e64226shiqian bool list_tests; 5593d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* output; 559415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian bool print_time; 55958bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan Int32 random_seed; 5596d201456903f3ecae1f7794edfab0d5678e64226shiqian Int32 repeat; 55978bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan bool shuffle; 5598bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Int32 stack_trace_depth; 5599a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* stream_result_to; 560040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan bool throw_on_failure; 5601d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5602d201456903f3ecae1f7794edfab0d5678e64226shiqian 5603d201456903f3ecae1f7794edfab0d5678e64226shiqian// Fixture for testing InitGoogleTest(). 56049b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass InitGoogleTestTest : public Test { 5605d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 5606d201456903f3ecae1f7794edfab0d5678e64226shiqian // Clears the flags before each test. 5607d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 5608fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests) = false; 5609d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(break_on_failure) = false; 5610d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(catch_exceptions) = false; 561153e0dc4041f660b6517b15b08b496e164be614f1shiqian GTEST_FLAG(death_test_use_fork) = false; 5612d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(filter) = ""; 5613d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(list_tests) = false; 5614d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(output) = ""; 5615f204cd89e591e8cda022f4b471962c8556e19b8czhanyong.wan GTEST_FLAG(print_time) = true; 56168bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(random_seed) = 0; 5617d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(repeat) = 1; 56188bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan GTEST_FLAG(shuffle) = false; 5619bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_FLAG(stack_trace_depth) = kMaxStackTraceDepth; 5620a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to) = ""; 562140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan GTEST_FLAG(throw_on_failure) = false; 5622d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5623d201456903f3ecae1f7794edfab0d5678e64226shiqian 5624d201456903f3ecae1f7794edfab0d5678e64226shiqian // Asserts that two narrow or wide string arrays are equal. 5625d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 5626d201456903f3ecae1f7794edfab0d5678e64226shiqian static void AssertStringArrayEq(size_t size1, CharType** array1, 5627d201456903f3ecae1f7794edfab0d5678e64226shiqian size_t size2, CharType** array2) { 5628d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(size1, size2) << " Array sizes different."; 5629d201456903f3ecae1f7794edfab0d5678e64226shiqian 5630d201456903f3ecae1f7794edfab0d5678e64226shiqian for (size_t i = 0; i != size1; i++) { 5631d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ(array1[i], array2[i]) << " where i == " << i; 5632d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5633d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5634d201456903f3ecae1f7794edfab0d5678e64226shiqian 5635d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the flag values match the expected values. 5636d201456903f3ecae1f7794edfab0d5678e64226shiqian static void CheckFlags(const Flags& expected) { 5637fe186c382905dcf57014985ccea8e067275e9f5fshiqian EXPECT_EQ(expected.also_run_disabled_tests, 5638fe186c382905dcf57014985ccea8e067275e9f5fshiqian GTEST_FLAG(also_run_disabled_tests)); 5639d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure)); 5640d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions)); 564153e0dc4041f660b6517b15b08b496e164be614f1shiqian EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork)); 5642d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str()); 5643d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests)); 5644d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str()); 564515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian EXPECT_EQ(expected.print_time, GTEST_FLAG(print_time)); 56468bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.random_seed, GTEST_FLAG(random_seed)); 5647d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(expected.repeat, GTEST_FLAG(repeat)); 56488bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan EXPECT_EQ(expected.shuffle, GTEST_FLAG(shuffle)); 5649bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(expected.stack_trace_depth, GTEST_FLAG(stack_trace_depth)); 5650a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_STREQ(expected.stream_result_to, 5651a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_FLAG(stream_result_to).c_str()); 5652a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan EXPECT_EQ(expected.throw_on_failure, GTEST_FLAG(throw_on_failure)); 5653d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5654d201456903f3ecae1f7794edfab0d5678e64226shiqian 5655d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses a command line (specified by argc1 and argv1), then 5656d201456903f3ecae1f7794edfab0d5678e64226shiqian // verifies that the flag values are expected and that the 5657d201456903f3ecae1f7794edfab0d5678e64226shiqian // recognized flags are removed from the command line. 5658d201456903f3ecae1f7794edfab0d5678e64226shiqian template <typename CharType> 5659d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TestParsingFlags(int argc1, const CharType** argv1, 5660d201456903f3ecae1f7794edfab0d5678e64226shiqian int argc2, const CharType** argv2, 5661bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const Flags& expected, bool should_print_help) { 5662bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const bool saved_help_flag = ::testing::internal::g_help_flag; 5663bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev ::testing::internal::g_help_flag = false; 5664bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 566535c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 566681e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan CaptureStdout(); 566735c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 566881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 5669d201456903f3ecae1f7794edfab0d5678e64226shiqian // Parses the command line. 56701998cf5d32a19aaffe8652545802744d9133022dvladlosev internal::ParseGoogleTestFlagsOnly(&argc1, const_cast<CharType**>(argv1)); 5671d201456903f3ecae1f7794edfab0d5678e64226shiqian 567235c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 567387fdda2cf24d953f3cbec1e0c266b2db9928f406jgm const std::string captured_stdout = GetCapturedStdout(); 567435c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif 567581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan 5676d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies the flag values. 5677d201456903f3ecae1f7794edfab0d5678e64226shiqian CheckFlags(expected); 5678d201456903f3ecae1f7794edfab0d5678e64226shiqian 5679d201456903f3ecae1f7794edfab0d5678e64226shiqian // Verifies that the recognized flags are removed from the command 5680d201456903f3ecae1f7794edfab0d5678e64226shiqian // line. 5681d201456903f3ecae1f7794edfab0d5678e64226shiqian AssertStringArrayEq(argc1 + 1, argv1, argc2 + 1, argv2); 5682bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5683bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // ParseGoogleTestFlagsOnly should neither set g_help_flag nor print the 5684bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev // help message for the flags it recognizes. 5685bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev EXPECT_EQ(should_print_help, ::testing::internal::g_help_flag); 5686bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 568735c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#if GTEST_HAS_STREAM_REDIRECTION 568881e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan const char* const expected_help_fragment = 568981e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan "This program contains tests written using"; 569081e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan if (should_print_help) { 569181e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan EXPECT_PRED_FORMAT2(IsSubstring, expected_help_fragment, captured_stdout); 569281e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan } else { 569381e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan EXPECT_PRED_FORMAT2(IsNotSubstring, 569481e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan expected_help_fragment, captured_stdout); 569581e1cc73c83265e54b2ec7edc17e77f4d1b89e86zhanyong.wan } 569635c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan#endif // GTEST_HAS_STREAM_REDIRECTION 5697bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 5698bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev ::testing::internal::g_help_flag = saved_help_flag; 5699d201456903f3ecae1f7794edfab0d5678e64226shiqian } 5700d201456903f3ecae1f7794edfab0d5678e64226shiqian 5701d201456903f3ecae1f7794edfab0d5678e64226shiqian // This macro wraps TestParsingFlags s.t. the user doesn't need 5702d201456903f3ecae1f7794edfab0d5678e64226shiqian // to specify the array sizes. 5703ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan 5704bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev#define GTEST_TEST_PARSING_FLAGS_(argv1, argv2, expected, should_print_help) \ 5705d201456903f3ecae1f7794edfab0d5678e64226shiqian TestParsingFlags(sizeof(argv1)/sizeof(*argv1) - 1, argv1, \ 5706bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev sizeof(argv2)/sizeof(*argv2) - 1, argv2, \ 5707bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev expected, should_print_help) 5708d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5709d201456903f3ecae1f7794edfab0d5678e64226shiqian 5710d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty command line. 5711d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Empty) { 5712d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5713d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5714d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5715d201456903f3ecae1f7794edfab0d5678e64226shiqian 5716d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5717d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5718d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5719d201456903f3ecae1f7794edfab0d5678e64226shiqian 5720bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 5721d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5722d201456903f3ecae1f7794edfab0d5678e64226shiqian 5723d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a command line that has no flag. 5724d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, NoFlag) { 5725d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5726d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5727d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5728d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5729d201456903f3ecae1f7794edfab0d5678e64226shiqian 5730d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5731d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5732d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5733d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5734d201456903f3ecae1f7794edfab0d5678e64226shiqian 5735bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 5736d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5737d201456903f3ecae1f7794edfab0d5678e64226shiqian 5738d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a bad --gtest_filter flag. 5739d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterBad) { 5740d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5741d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5742d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 5743d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5744d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5745d201456903f3ecae1f7794edfab0d5678e64226shiqian 5746d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5747d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5748d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter", 5749d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5750d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5751d201456903f3ecae1f7794edfab0d5678e64226shiqian 5752bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true); 5753d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5754d201456903f3ecae1f7794edfab0d5678e64226shiqian 5755d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing an empty --gtest_filter flag. 5756d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterEmpty) { 5757d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5758d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5759d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=", 5760d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5761d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5762d201456903f3ecae1f7794edfab0d5678e64226shiqian 5763d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5764d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5765d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5766d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5767d201456903f3ecae1f7794edfab0d5678e64226shiqian 5768bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), false); 5769d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5770d201456903f3ecae1f7794edfab0d5678e64226shiqian 5771d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a non-empty --gtest_filter flag. 5772d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, FilterNonEmpty) { 5773d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5774d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5775d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=abc", 5776d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5777d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5778d201456903f3ecae1f7794edfab0d5678e64226shiqian 5779d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5780d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5781d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5782d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5783d201456903f3ecae1f7794edfab0d5678e64226shiqian 5784bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); 5785d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5786d201456903f3ecae1f7794edfab0d5678e64226shiqian 5787d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure. 57888bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, BreakOnFailureWithoutValue) { 5789d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5790d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5791d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 5792d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5793d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 5794d201456903f3ecae1f7794edfab0d5678e64226shiqian 5795d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5796d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5797d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5798d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5799d201456903f3ecae1f7794edfab0d5678e64226shiqian 5800bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 5801d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5802d201456903f3ecae1f7794edfab0d5678e64226shiqian 5803d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=0. 5804d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_0) { 5805d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5806d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5807d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=0", 5808d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5809d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5810d201456903f3ecae1f7794edfab0d5678e64226shiqian 5811d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5812d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5813d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5814d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5815d201456903f3ecae1f7794edfab0d5678e64226shiqian 5816bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5817d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5818d201456903f3ecae1f7794edfab0d5678e64226shiqian 5819d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=f. 5820d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_f) { 5821d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5822d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5823d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=f", 5824d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5825d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5826d201456903f3ecae1f7794edfab0d5678e64226shiqian 5827d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5828d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5829d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5830d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5831d201456903f3ecae1f7794edfab0d5678e64226shiqian 5832bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5833d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5834d201456903f3ecae1f7794edfab0d5678e64226shiqian 5835d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_break_on_failure=F. 5836d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureFalse_F) { 5837d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5838d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5839d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=F", 5840d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5841d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5842d201456903f3ecae1f7794edfab0d5678e64226shiqian 5843d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5844d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5845d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5846d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5847d201456903f3ecae1f7794edfab0d5678e64226shiqian 5848bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(false), false); 5849d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5850d201456903f3ecae1f7794edfab0d5678e64226shiqian 5851d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing a --gtest_break_on_failure flag that has a "true" 5852d201456903f3ecae1f7794edfab0d5678e64226shiqian// definition. 5853d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, BreakOnFailureTrue) { 5854d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5855d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5856d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure=1", 5857d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5858d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5859d201456903f3ecae1f7794edfab0d5678e64226shiqian 5860d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5861d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5862d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5863d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5864d201456903f3ecae1f7794edfab0d5678e64226shiqian 5865bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::BreakOnFailure(true), false); 5866d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5867d201456903f3ecae1f7794edfab0d5678e64226shiqian 5868d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_catch_exceptions. 5869d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, CatchExceptions) { 5870d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5871d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5872d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_catch_exceptions", 5873d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5874d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5875d201456903f3ecae1f7794edfab0d5678e64226shiqian 5876d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5877d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5878d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5879d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5880d201456903f3ecae1f7794edfab0d5678e64226shiqian 5881bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::CatchExceptions(true), false); 5882d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5883d201456903f3ecae1f7794edfab0d5678e64226shiqian 588453e0dc4041f660b6517b15b08b496e164be614f1shiqian// Tests parsing --gtest_death_test_use_fork. 588553e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST_F(InitGoogleTestTest, DeathTestUseFork) { 588653e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv[] = { 588753e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 588853e0dc4041f660b6517b15b08b496e164be614f1shiqian "--gtest_death_test_use_fork", 588953e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 589053e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 589153e0dc4041f660b6517b15b08b496e164be614f1shiqian 589253e0dc4041f660b6517b15b08b496e164be614f1shiqian const char* argv2[] = { 589353e0dc4041f660b6517b15b08b496e164be614f1shiqian "foo.exe", 589453e0dc4041f660b6517b15b08b496e164be614f1shiqian NULL 589553e0dc4041f660b6517b15b08b496e164be614f1shiqian }; 589653e0dc4041f660b6517b15b08b496e164be614f1shiqian 5897bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::DeathTestUseFork(true), false); 589853e0dc4041f660b6517b15b08b496e164be614f1shiqian} 589953e0dc4041f660b6517b15b08b496e164be614f1shiqian 5900d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having the same flag twice with different values. The 5901d201456903f3ecae1f7794edfab0d5678e64226shiqian// expected behavior is that the one coming last takes precedence. 5902d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, DuplicatedFlags) { 5903d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5904d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5905d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=a", 5906d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5907d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5908d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5909d201456903f3ecae1f7794edfab0d5678e64226shiqian 5910d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5911d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5912d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5913d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5914d201456903f3ecae1f7794edfab0d5678e64226shiqian 5915bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("b"), false); 5916d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5917d201456903f3ecae1f7794edfab0d5678e64226shiqian 5918d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having an unrecognized flag on the command line. 5919d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, UnrecognizedFlag) { 5920d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5921d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5922d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_break_on_failure", 5923d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", // Unrecognized by Google Test. 5924d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_filter=b", 5925d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5926d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5927d201456903f3ecae1f7794edfab0d5678e64226shiqian 5928d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5929d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5930d201456903f3ecae1f7794edfab0d5678e64226shiqian "bar", 5931d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5932d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5933d201456903f3ecae1f7794edfab0d5678e64226shiqian 5934d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags flags; 5935d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.break_on_failure = true; 5936d201456903f3ecae1f7794edfab0d5678e64226shiqian flags.filter = "b"; 5937bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, flags, false); 5938d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5939d201456903f3ecae1f7794edfab0d5678e64226shiqian 5940d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag 5941d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFlag) { 5942d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5943d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5944d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests", 5945d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5946d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5947d201456903f3ecae1f7794edfab0d5678e64226shiqian 5948d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5949d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5950d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5951d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5952d201456903f3ecae1f7794edfab0d5678e64226shiqian 5953bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 5954d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5955d201456903f3ecae1f7794edfab0d5678e64226shiqian 5956d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "true" value 5957d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsTrue) { 5958d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5959d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5960d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=1", 5961d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5962d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5963d201456903f3ecae1f7794edfab0d5678e64226shiqian 5964d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5965d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5966d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5967d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5968d201456903f3ecae1f7794edfab0d5678e64226shiqian 5969bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(true), false); 5970d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5971d201456903f3ecae1f7794edfab0d5678e64226shiqian 5972d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests having a --gtest_list_tests flag with a "false" value 5973d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse) { 5974d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5975d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5976d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=0", 5977d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5978d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5979d201456903f3ecae1f7794edfab0d5678e64226shiqian 5980d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5981d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5982d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5983d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5984d201456903f3ecae1f7794edfab0d5678e64226shiqian 5985bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 5986d201456903f3ecae1f7794edfab0d5678e64226shiqian} 5987d201456903f3ecae1f7794edfab0d5678e64226shiqian 5988d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_list_tests=f. 5989d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_f) { 5990d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 5991d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5992d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=f", 5993d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5994d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 5995d201456903f3ecae1f7794edfab0d5678e64226shiqian 5996d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 5997d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 5998d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 5999d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6000d201456903f3ecae1f7794edfab0d5678e64226shiqian 6001bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 6002d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6003d201456903f3ecae1f7794edfab0d5678e64226shiqian 60048bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_list_tests=F. 6005d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, ListTestsFalse_F) { 6006d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6007d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6008d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_list_tests=F", 6009d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6010d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6011d201456903f3ecae1f7794edfab0d5678e64226shiqian 6012d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6013d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6014d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6015d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6016d201456903f3ecae1f7794edfab0d5678e64226shiqian 6017bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ListTests(false), false); 6018d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6019d201456903f3ecae1f7794edfab0d5678e64226shiqian 6020d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output (invalid). 6021d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputEmpty) { 6022d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6023d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6024d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 6025d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6026d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6027d201456903f3ecae1f7794edfab0d5678e64226shiqian 6028d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6029d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6030d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output", 6031d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6032d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6033d201456903f3ecae1f7794edfab0d5678e64226shiqian 6034bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true); 6035d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6036d201456903f3ecae1f7794edfab0d5678e64226shiqian 6037d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml 6038d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXml) { 6039d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6040d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6041d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml", 6042d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6043d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6044d201456903f3ecae1f7794edfab0d5678e64226shiqian 6045d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6046d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6047d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6048d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6049d201456903f3ecae1f7794edfab0d5678e64226shiqian 6050bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml"), false); 6051d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6052d201456903f3ecae1f7794edfab0d5678e64226shiqian 6053d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:file 6054d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlFile) { 6055d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6056d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6057d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:file", 6058d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6059d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6060d201456903f3ecae1f7794edfab0d5678e64226shiqian 6061d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6062d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6063d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6064d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6065d201456903f3ecae1f7794edfab0d5678e64226shiqian 6066bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Output("xml:file"), false); 6067d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6068d201456903f3ecae1f7794edfab0d5678e64226shiqian 6069d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_output=xml:directory/path/ 6070d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, OutputXmlDirectory) { 6071d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6072d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6073d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_output=xml:directory/path/", 6074d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6075d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6076d201456903f3ecae1f7794edfab0d5678e64226shiqian 6077d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6078d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6079d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6080d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6081d201456903f3ecae1f7794edfab0d5678e64226shiqian 6082bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 6083bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::Output("xml:directory/path/"), false); 6084d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6085d201456903f3ecae1f7794edfab0d5678e64226shiqian 608615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag 608715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFlag) { 608815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 608915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 609015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time", 609115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 609215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 609315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 609415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 609515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 609615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 609715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 609815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 6099bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 610015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 610115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 610215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "true" value 610315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeTrue) { 610415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 610515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 610615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=1", 610715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 610815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 610915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 611015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 611115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 611215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 611315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 611415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 6115bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(true), false); 611615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 611715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 611815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests having a --gtest_print_time flag with a "false" value 611915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse) { 612015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 612115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 612215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=0", 612315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 612415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 612515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 612615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 612715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 612815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 612915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 613015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 6131bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 613215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 613315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 613415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=f. 613515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_f) { 613615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 613715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 613815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=f", 613915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 614015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 614115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 614215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 614315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 614415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 614515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 614615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 6147bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 614815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 614915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 615015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian// Tests parsing --gtest_print_time=F. 615115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqianTEST_F(InitGoogleTestTest, PrintTimeFalse_F) { 615215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv[] = { 615315cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 615415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "--gtest_print_time=F", 615515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 615615cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 615715cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 615815cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian const char* argv2[] = { 615915cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian "foo.exe", 616015cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian NULL 616115cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian }; 616215cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 6163bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::PrintTime(false), false); 616415cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian} 616515cbe5f70adaade1a8a11afc37601fc6606e7e0dshiqian 61668bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_random_seed=number 61678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, RandomSeed) { 61688bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 61698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 61708bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_random_seed=1000", 61718bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 61728bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 61738bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 61748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 61758bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 61768bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 61778bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 61788bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6179bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::RandomSeed(1000), false); 61808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 61818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6182d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing --gtest_repeat=number 6183d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, Repeat) { 6184d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv[] = { 6185d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6186d201456903f3ecae1f7794edfab0d5678e64226shiqian "--gtest_repeat=1000", 6187d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6188d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6189d201456903f3ecae1f7794edfab0d5678e64226shiqian 6190d201456903f3ecae1f7794edfab0d5678e64226shiqian const char* argv2[] = { 6191d201456903f3ecae1f7794edfab0d5678e64226shiqian "foo.exe", 6192d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6193d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6194d201456903f3ecae1f7794edfab0d5678e64226shiqian 6195bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Repeat(1000), false); 6196d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6197d201456903f3ecae1f7794edfab0d5678e64226shiqian 6198fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag 6199fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFlag) { 6200fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 6201fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6202fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests", 6203fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6204fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6205fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6206fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 6207fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6208fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6209fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6210fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6211bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 6212bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(true), false); 6213fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 6214fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6215fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "true" value 6216fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsTrue) { 6217fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 6218fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6219fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=1", 6220fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6221fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6222fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6223fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 6224fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6225fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6226fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6227fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6228bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 6229bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(true), false); 6230fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 6231fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6232fe186c382905dcf57014985ccea8e067275e9f5fshiqian// Tests having a --gtest_also_run_disabled_tests flag with a "false" value 6233fe186c382905dcf57014985ccea8e067275e9f5fshiqianTEST_F(InitGoogleTestTest, AlsoRunDisabledTestsFalse) { 6234fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv[] = { 6235fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6236fe186c382905dcf57014985ccea8e067275e9f5fshiqian "--gtest_also_run_disabled_tests=0", 6237fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6238fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6239fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6240fe186c382905dcf57014985ccea8e067275e9f5fshiqian const char* argv2[] = { 6241fe186c382905dcf57014985ccea8e067275e9f5fshiqian "foo.exe", 6242fe186c382905dcf57014985ccea8e067275e9f5fshiqian NULL 6243fe186c382905dcf57014985ccea8e067275e9f5fshiqian }; 6244fe186c382905dcf57014985ccea8e067275e9f5fshiqian 6245bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, 6246bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev Flags::AlsoRunDisabledTests(false), false); 6247fe186c382905dcf57014985ccea8e067275e9f5fshiqian} 6248fe186c382905dcf57014985ccea8e067275e9f5fshiqian 62498bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle. 62508bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleWithoutValue) { 62518bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 62528bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62538bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle", 62548bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62558bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan}; 62568bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 62578bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 62588bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62598bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62608bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 62618bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6262bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 62638bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 62648bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 62658bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing --gtest_shuffle=0. 62668bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleFalse_0) { 62678bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 62688bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62698bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=0", 62708bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62718bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 62728bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 62738bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 62748bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62758bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62768bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 62778bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6278bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(false), false); 62798bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 62808bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 62818bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// Tests parsing a --gtest_shuffle flag that has a "true" 62828bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan// definition. 62838bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ShuffleTrue) { 62848bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv[] = { 62858bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62868bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "--gtest_shuffle=1", 62878bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62888bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 62898bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 62908bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan const char* argv2[] = { 62918bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan "foo.exe", 62928bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan NULL 62938bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan }; 62948bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan 6295bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Shuffle(true), false); 6296bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev} 6297bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6298bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev// Tests parsing --gtest_stack_trace_depth=number. 6299bf26ca01f23e432f8b2355fd700707ba217a7605vladlosevTEST_F(InitGoogleTestTest, StackTraceDepth) { 6300bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const char* argv[] = { 6301bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "foo.exe", 6302bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "--gtest_stack_trace_depth=5", 6303bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev NULL 6304bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev }; 6305bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6306bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev const char* argv2[] = { 6307bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev "foo.exe", 6308bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev NULL 6309bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev }; 6310bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev 6311bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::StackTraceDepth(5), false); 63128bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wan} 631340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6314a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wanTEST_F(InitGoogleTestTest, StreamResultTo) { 6315a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* argv[] = { 6316a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "foo.exe", 6317a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "--gtest_stream_result_to=localhost:1234", 6318a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan NULL 6319a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan }; 6320a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 6321a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan const char* argv2[] = { 6322a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan "foo.exe", 6323a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan NULL 6324a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan }; 6325a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 6326a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan GTEST_TEST_PARSING_FLAGS_( 6327a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan argv, argv2, Flags::StreamResultTo("localhost:1234"), false); 6328a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan} 6329a9f380f5c7ff75cd715c58e11885dddc54baef02zhanyong.wan 633040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure. 63318bdb31e0540c46de485b362178f60e8bb947ff43zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureWithoutValue) { 633240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 633340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 633440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure", 633540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 633640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan}; 633740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 633840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 633940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 634040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 634140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 634240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6343bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 634440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 634540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 634640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing --gtest_throw_on_failure=0. 634740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureFalse_0) { 634840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 634940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 635040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=0", 635140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 635240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 635340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 635440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 635540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 635640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 635740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 635840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6359bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(false), false); 636040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 636140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 636240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// Tests parsing a --gtest_throw_on_failure flag that has a "true" 636340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan// definition. 636440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wanTEST_F(InitGoogleTestTest, ThrowOnFailureTrue) { 636540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv[] = { 636640e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 636740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "--gtest_throw_on_failure=1", 636840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 636940e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 637040e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 637140e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan const char* argv2[] = { 637240e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan "foo.exe", 637340e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan NULL 637440e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan }; 637540e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 6376bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::ThrowOnFailure(true), false); 637740e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan} 637840e72a8a837b47cbfe2e695068c1845073ab2630zhanyong.wan 63790af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 6380d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests parsing wide strings. 6381d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(InitGoogleTestTest, WideStrings) { 6382d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv[] = { 6383d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 6384d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_filter=Foo*", 6385d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_list_tests=1", 6386d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--gtest_break_on_failure", 6387d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 6388d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6389d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6390d201456903f3ecae1f7794edfab0d5678e64226shiqian 6391d201456903f3ecae1f7794edfab0d5678e64226shiqian const wchar_t* argv2[] = { 6392d201456903f3ecae1f7794edfab0d5678e64226shiqian L"foo.exe", 6393d201456903f3ecae1f7794edfab0d5678e64226shiqian L"--non_gtest_flag", 6394d201456903f3ecae1f7794edfab0d5678e64226shiqian NULL 6395d201456903f3ecae1f7794edfab0d5678e64226shiqian }; 6396d201456903f3ecae1f7794edfab0d5678e64226shiqian 6397d201456903f3ecae1f7794edfab0d5678e64226shiqian Flags expected_flags; 6398d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.break_on_failure = true; 6399d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.filter = "Foo*"; 6400d201456903f3ecae1f7794edfab0d5678e64226shiqian expected_flags.list_tests = true; 6401d201456903f3ecae1f7794edfab0d5678e64226shiqian 6402bf26ca01f23e432f8b2355fd700707ba217a7605vladlosev GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false); 6403d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6404fb9caa4a18853ed3fc404c3ba5c47c9be695eae7kosak# endif // GTEST_OS_WINDOWS 6405d201456903f3ecae1f7794edfab0d5678e64226shiqian 64064d69b1607a876a77b8719f035b23254677617a47kosak#if GTEST_USE_OWN_FLAGFILE_FLAG_ 6407195610d30c2234b76bef70a85426ac8d7dbdf9f3kosakclass FlagfileTest : public InitGoogleTestTest { 6408195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak public: 6409195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak virtual void SetUp() { 6410195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak InitGoogleTestTest::SetUp(); 6411195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6412195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak testdata_path_.Set(internal::FilePath( 6413195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::TempDir() + internal::GetCurrentExecutableName().string() + 6414195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "_flagfile_test")); 6415195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak testing::internal::posix::RmDir(testdata_path_.c_str()); 6416195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak EXPECT_TRUE(testdata_path_.CreateFolder()); 6417195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak } 6418195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6419195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak virtual void TearDown() { 6420195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak testing::internal::posix::RmDir(testdata_path_.c_str()); 6421195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak InitGoogleTestTest::TearDown(); 6422195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak } 6423195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6424195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath CreateFlagfile(const char* contents) { 6425195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath file_path(internal::FilePath::GenerateUniqueFileName( 6426195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak testdata_path_, internal::FilePath("unique"), "txt")); 6427195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak FILE* f = testing::internal::posix::FOpen(file_path.c_str(), "w"); 6428195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak fprintf(f, "%s", contents); 6429195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak fclose(f); 6430195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak return file_path; 6431195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak } 6432195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6433195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak private: 6434195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath testdata_path_; 6435195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak}; 6436195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6437195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak// Tests an empty flagfile. 6438195610d30c2234b76bef70a85426ac8d7dbdf9f3kosakTEST_F(FlagfileTest, Empty) { 6439195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath flagfile_path(CreateFlagfile("")); 6440195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string flagfile_flag = 6441195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str(); 6442195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6443195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv[] = { 6444195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6445195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak flagfile_flag.c_str(), 6446195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6447195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6448195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6449195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv2[] = { 6450195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6451195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6452195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6453195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6454195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false); 6455195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak} 6456195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6457195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak// Tests passing a non-empty --gtest_filter flag via --gtest_flagfile. 6458195610d30c2234b76bef70a85426ac8d7dbdf9f3kosakTEST_F(FlagfileTest, FilterNonEmpty) { 6459195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath flagfile_path(CreateFlagfile( 6460195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "--" GTEST_FLAG_PREFIX_ "filter=abc")); 6461195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string flagfile_flag = 6462195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str(); 6463195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6464195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv[] = { 6465195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6466195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak flagfile_flag.c_str(), 6467195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6468195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6469195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6470195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv2[] = { 6471195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6472195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6473195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6474195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6475195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abc"), false); 6476195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak} 6477195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6478195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak// Tests passing several flags via --gtest_flagfile. 6479195610d30c2234b76bef70a85426ac8d7dbdf9f3kosakTEST_F(FlagfileTest, SeveralFlags) { 6480195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak internal::FilePath flagfile_path(CreateFlagfile( 6481195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "--" GTEST_FLAG_PREFIX_ "filter=abc\n" 6482195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "--" GTEST_FLAG_PREFIX_ "break_on_failure\n" 6483195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "--" GTEST_FLAG_PREFIX_ "list_tests")); 6484195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string flagfile_flag = 6485195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak std::string("--" GTEST_FLAG_PREFIX_ "flagfile=") + flagfile_path.c_str(); 6486195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6487195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv[] = { 6488195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6489195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak flagfile_flag.c_str(), 6490195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6491195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6492195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6493195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak const char* argv2[] = { 6494195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak "foo.exe", 6495195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak NULL 6496195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak }; 6497195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6498195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak Flags expected_flags; 6499195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak expected_flags.break_on_failure = true; 6500195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak expected_flags.filter = "abc"; 6501195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak expected_flags.list_tests = true; 6502195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6503195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak GTEST_TEST_PARSING_FLAGS_(argv, argv2, expected_flags, false); 6504195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak} 65054d69b1607a876a77b8719f035b23254677617a47kosak#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ 6506195610d30c2234b76bef70a85426ac8d7dbdf9f3kosak 6507d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests current_test_info() in UnitTest. 6508d201456903f3ecae1f7794edfab0d5678e64226shiqianclass CurrentTestInfoTest : public Test { 6509d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 6510d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL before the first test in 6511d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case is run. 6512d201456903f3ecae1f7794edfab0d5678e64226shiqian static void SetUpTestCase() { 6513d201456903f3ecae1f7794edfab0d5678e64226shiqian // There should be no tests running at this point. 6514d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6515d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6516e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 6517d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 6518d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6519d201456903f3ecae1f7794edfab0d5678e64226shiqian 6520d201456903f3ecae1f7794edfab0d5678e64226shiqian // Tests that current_test_info() returns NULL after the last test in 6521d201456903f3ecae1f7794edfab0d5678e64226shiqian // the test case has run. 6522d201456903f3ecae1f7794edfab0d5678e64226shiqian static void TearDownTestCase() { 6523d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6524d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6525e6095deec89dcf5237948b3460d84a137622f16czhanyong.wan EXPECT_TRUE(test_info == NULL) 6526d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There should be no tests running at this point."; 6527d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6528d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 6529d201456903f3ecae1f7794edfab0d5678e64226shiqian 6530d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 6531d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. 6532d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { 6533d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6534d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6535d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 6536d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 6537d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 6538d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 6539d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) 6540d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 6541d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6542d201456903f3ecae1f7794edfab0d5678e64226shiqian 6543d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that current_test_info() returns TestInfo for currently running 6544d201456903f3ecae1f7794edfab0d5678e64226shiqian// test by checking the expected test name against the actual one. We 6545d201456903f3ecae1f7794edfab0d5678e64226shiqian// use this test to see that the TestInfo object actually changed from 6546d201456903f3ecae1f7794edfab0d5678e64226shiqian// the previous invocation. 6547d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { 6548d201456903f3ecae1f7794edfab0d5678e64226shiqian const TestInfo* test_info = 6549d201456903f3ecae1f7794edfab0d5678e64226shiqian UnitTest::GetInstance()->current_test_info(); 6550d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(NULL != test_info) 6551d201456903f3ecae1f7794edfab0d5678e64226shiqian << "There is a test running so we should have a valid TestInfo."; 6552d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) 6553d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test case."; 6554d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) 6555d201456903f3ecae1f7794edfab0d5678e64226shiqian << "Expected the name of the currently running test."; 6556d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6557d201456903f3ecae1f7794edfab0d5678e64226shiqian 6558d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 6559d201456903f3ecae1f7794edfab0d5678e64226shiqian 6560d201456903f3ecae1f7794edfab0d5678e64226shiqian// These two lines test that we can define tests in a namespace that 6561d201456903f3ecae1f7794edfab0d5678e64226shiqian// has the name "testing" and is nested in another namespace. 6562d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace my_namespace { 6563d201456903f3ecae1f7794edfab0d5678e64226shiqiannamespace testing { 6564d201456903f3ecae1f7794edfab0d5678e64226shiqian 6565d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that TEST knows to use ::testing::Test instead of 6566d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Test. 6567d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Test {}; 6568d201456903f3ecae1f7794edfab0d5678e64226shiqian 6569d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use ::testing::Message instead of 6570d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::Message. 6571d201456903f3ecae1f7794edfab0d5678e64226shiqianclass Message {}; 6572d201456903f3ecae1f7794edfab0d5678e64226shiqian 6573d201456903f3ecae1f7794edfab0d5678e64226shiqian// Makes sure that an assertion knows to use 6574d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::testing::AssertionResult instead of 6575d201456903f3ecae1f7794edfab0d5678e64226shiqian// ::my_namespace::testing::AssertionResult. 6576d201456903f3ecae1f7794edfab0d5678e64226shiqianclass AssertionResult {}; 6577d201456903f3ecae1f7794edfab0d5678e64226shiqian 6578d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should succeed works as expected. 6579d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Success) { 6580d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "This shouldn't fail."; 6581d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6582d201456903f3ecae1f7794edfab0d5678e64226shiqian 6583d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that an assertion that should fail works as expected. 6584d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(NestedTestingNamespaceTest, Failure) { 6585d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "This failure is expected.", 6586d201456903f3ecae1f7794edfab0d5678e64226shiqian "This failure is expected."); 6587d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6588d201456903f3ecae1f7794edfab0d5678e64226shiqian 6589d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace testing 6590d201456903f3ecae1f7794edfab0d5678e64226shiqian} // namespace my_namespace 6591d201456903f3ecae1f7794edfab0d5678e64226shiqian 6592d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that one can call superclass SetUp and TearDown methods-- 6593d201456903f3ecae1f7794edfab0d5678e64226shiqian// that is, that they are not private. 6594d201456903f3ecae1f7794edfab0d5678e64226shiqian// No tests are based on this fixture; the test "passes" if it compiles 6595d201456903f3ecae1f7794edfab0d5678e64226shiqian// successfully. 65969b093c1779eb48a55db026cfd525f4cf1bbd4749shiqianclass ProtectedFixtureMethodsTest : public Test { 6597d201456903f3ecae1f7794edfab0d5678e64226shiqian protected: 6598d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void SetUp() { 65999b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::SetUp(); 6600d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6601d201456903f3ecae1f7794edfab0d5678e64226shiqian virtual void TearDown() { 66029b093c1779eb48a55db026cfd525f4cf1bbd4749shiqian Test::TearDown(); 6603d201456903f3ecae1f7794edfab0d5678e64226shiqian } 6604d201456903f3ecae1f7794edfab0d5678e64226shiqian}; 6605d201456903f3ecae1f7794edfab0d5678e64226shiqian 6606d201456903f3ecae1f7794edfab0d5678e64226shiqian// StreamingAssertionsTest tests the streaming versions of a representative 6607d201456903f3ecae1f7794edfab0d5678e64226shiqian// sample of assertions. 6608d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Unconditional) { 6609d201456903f3ecae1f7794edfab0d5678e64226shiqian SUCCEED() << "expected success"; 6610d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(ADD_FAILURE() << "expected failure", 6611d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6612d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(FAIL() << "expected failure", 6613d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6614d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6615d201456903f3ecae1f7794edfab0d5678e64226shiqian 6616c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 6617c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Silences warnings: "Condition is always true", "Unreachable code" 6618ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option push -w-ccc -w-rch 6619c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 6620c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 6621d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth) { 6622d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(true) << "unexpected failure"; 6623d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_TRUE(true) << "unexpected failure"; 6624d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_TRUE(false) << "expected failure", 6625d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6626d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_TRUE(false) << "expected failure", 6627d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6628d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6629d201456903f3ecae1f7794edfab0d5678e64226shiqian 6630d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, Truth2) { 6631d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(false) << "unexpected failure"; 6632d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FALSE(false) << "unexpected failure"; 6633d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FALSE(true) << "expected failure", 6634d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6635d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FALSE(true) << "expected failure", 6636d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6637d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6638d201456903f3ecae1f7794edfab0d5678e64226shiqian 6639c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#ifdef __BORLANDC__ 6640c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan// Restores warnings after previous "#pragma option push" supressed them 6641ffeb11d14a890b902dbb26ff2296cda7bf2d31dfzhanyong.wan# pragma option pop 6642c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan#endif 6643c78ae6196dc9c24380b5cf86f8fd75a4d3edc704zhanyong.wan 6644d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerEquals) { 6645d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_EQ(1, 1) << "unexpected failure"; 6646d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_EQ(1, 1) << "unexpected failure"; 6647d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_EQ(1, 2) << "expected failure", 6648d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6649d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_EQ(1, 2) << "expected failure", 6650d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6651d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6652d201456903f3ecae1f7794edfab0d5678e64226shiqian 6653d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, IntegerLessThan) { 6654d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_LT(1, 2) << "unexpected failure"; 6655d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_LT(1, 2) << "unexpected failure"; 6656d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_LT(2, 1) << "expected failure", 6657d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6658d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_LT(2, 1) << "expected failure", 6659d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6660d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6661d201456903f3ecae1f7794edfab0d5678e64226shiqian 6662d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqual) { 6663d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STREQ("foo", "foo") << "unexpected failure"; 6664d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STREQ("foo", "foo") << "unexpected failure"; 6665d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STREQ("foo", "bar") << "expected failure", 6666d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6667d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STREQ("foo", "bar") << "expected failure", 6668d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6669d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6670d201456903f3ecae1f7794edfab0d5678e64226shiqian 6671d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsNotEqual) { 6672d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRNE("foo", "bar") << "unexpected failure"; 6673d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRNE("foo", "bar") << "unexpected failure"; 6674d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRNE("foo", "foo") << "expected failure", 6675d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6676d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRNE("foo", "foo") << "expected failure", 6677d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6678d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6679d201456903f3ecae1f7794edfab0d5678e64226shiqian 6680d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringsEqualIgnoringCase) { 6681d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 6682d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASEEQ("foo", "FOO") << "unexpected failure"; 6683d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASEEQ("foo", "bar") << "expected failure", 6684d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6685d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASEEQ("foo", "bar") << "expected failure", 6686d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6687d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6688d201456903f3ecae1f7794edfab0d5678e64226shiqian 6689d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, StringNotEqualIgnoringCase) { 6690d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_STRCASENE("foo", "bar") << "unexpected failure"; 6691d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_STRCASENE("foo", "bar") << "unexpected failure"; 6692d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_STRCASENE("foo", "FOO") << "expected failure", 6693d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6694d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_STRCASENE("bar", "BAR") << "expected failure", 6695d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6696d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6697d201456903f3ecae1f7794edfab0d5678e64226shiqian 6698d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(StreamingAssertionsTest, FloatingPointEquals) { 6699d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 6700d201456903f3ecae1f7794edfab0d5678e64226shiqian ASSERT_FLOAT_EQ(1.0, 1.0) << "unexpected failure"; 6701d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(0.0, 1.0) << "expected failure", 6702d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6703d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(0.0, 1.0) << "expected failure", 6704d201456903f3ecae1f7794edfab0d5678e64226shiqian "expected failure"); 6705d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6706d201456903f3ecae1f7794edfab0d5678e64226shiqian 670736865d8d354465e3461eedf2949a4b7799985d5dshiqian#if GTEST_HAS_EXCEPTIONS 670836865d8d354465e3461eedf2949a4b7799985d5dshiqian 670936865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, Throw) { 671036865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 671136865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_THROW(ThrowAnInteger(), int) << "unexpected failure"; 671236865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_THROW(ThrowAnInteger(), bool) << 671336865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 671436865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_THROW(ThrowAnInteger(), bool) << 671536865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 671636865d8d354465e3461eedf2949a4b7799985d5dshiqian} 671736865d8d354465e3461eedf2949a4b7799985d5dshiqian 671836865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, NoThrow) { 6719886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NO_THROW(ThrowNothing()) << "unexpected failure"; 6720886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan ASSERT_NO_THROW(ThrowNothing()) << "unexpected failure"; 672136865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_NONFATAL_FAILURE(EXPECT_NO_THROW(ThrowAnInteger()) << 672236865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 672336865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_FATAL_FAILURE(ASSERT_NO_THROW(ThrowAnInteger()) << 672436865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 672536865d8d354465e3461eedf2949a4b7799985d5dshiqian} 672636865d8d354465e3461eedf2949a4b7799985d5dshiqian 672736865d8d354465e3461eedf2949a4b7799985d5dshiqianTEST(StreamingAssertionsTest, AnyThrow) { 672836865d8d354465e3461eedf2949a4b7799985d5dshiqian EXPECT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 672936865d8d354465e3461eedf2949a4b7799985d5dshiqian ASSERT_ANY_THROW(ThrowAnInteger()) << "unexpected failure"; 6730886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_NONFATAL_FAILURE(EXPECT_ANY_THROW(ThrowNothing()) << 673136865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 6732886cafd4a37fd5e7325da1ae5a5a948b6c2bc895zhanyong.wan EXPECT_FATAL_FAILURE(ASSERT_ANY_THROW(ThrowNothing()) << 673336865d8d354465e3461eedf2949a4b7799985d5dshiqian "expected failure", "expected failure"); 673436865d8d354465e3461eedf2949a4b7799985d5dshiqian} 673536865d8d354465e3461eedf2949a4b7799985d5dshiqian 673636865d8d354465e3461eedf2949a4b7799985d5dshiqian#endif // GTEST_HAS_EXCEPTIONS 673736865d8d354465e3461eedf2949a4b7799985d5dshiqian 6738d201456903f3ecae1f7794edfab0d5678e64226shiqian// Tests that Google Test correctly decides whether to use colors in the output. 6739d201456903f3ecae1f7794edfab0d5678e64226shiqian 6740d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsYes) { 6741d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "yes"; 6742d201456903f3ecae1f7794edfab0d5678e64226shiqian 6743d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6744d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6745d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6746d201456903f3ecae1f7794edfab0d5678e64226shiqian 6747d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6748d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6749d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6750d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6751d201456903f3ecae1f7794edfab0d5678e64226shiqian 6752d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenGTestColorFlagIsAliasOfYes) { 6753d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6754d201456903f3ecae1f7794edfab0d5678e64226shiqian 6755d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "True"; 6756d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6757d201456903f3ecae1f7794edfab0d5678e64226shiqian 6758d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "t"; 6759d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6760d201456903f3ecae1f7794edfab0d5678e64226shiqian 6761d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "1"; 6762d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(false)); // Stdout is not a TTY. 6763d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6764d201456903f3ecae1f7794edfab0d5678e64226shiqian 6765d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsNo) { 6766d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "no"; 6767d201456903f3ecae1f7794edfab0d5678e64226shiqian 6768d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6769d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6770d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6771d201456903f3ecae1f7794edfab0d5678e64226shiqian 6772d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6773d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6774d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6775d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6776d201456903f3ecae1f7794edfab0d5678e64226shiqian 6777d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesNoColorWhenGTestColorFlagIsInvalid) { 6778d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6779d201456903f3ecae1f7794edfab0d5678e64226shiqian 6780d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "F"; 6781d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6782d201456903f3ecae1f7794edfab0d5678e64226shiqian 6783d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "0"; 6784d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6785d201456903f3ecae1f7794edfab0d5678e64226shiqian 6786d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "unknown"; 6787d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6788d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6789d201456903f3ecae1f7794edfab0d5678e64226shiqian 6790d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) { 6791d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 6792d201456903f3ecae1f7794edfab0d5678e64226shiqian 6793d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6794d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(false)); // Stdout is not a TTY. 6795d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6796d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6797d201456903f3ecae1f7794edfab0d5678e64226shiqian 6798d201456903f3ecae1f7794edfab0d5678e64226shiqianTEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { 6799d201456903f3ecae1f7794edfab0d5678e64226shiqian GTEST_FLAG(color) = "auto"; 6800d201456903f3ecae1f7794edfab0d5678e64226shiqian 68010af0709b02899f9177db55eba7929e65e5834b29zhanyong.wan#if GTEST_OS_WINDOWS 6802d201456903f3ecae1f7794edfab0d5678e64226shiqian // On Windows, we ignore the TERM variable as it's usually not set. 6803d201456903f3ecae1f7794edfab0d5678e64226shiqian 6804d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); 6805d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6806d201456903f3ecae1f7794edfab0d5678e64226shiqian 6807d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", ""); 6808d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6809d201456903f3ecae1f7794edfab0d5678e64226shiqian 6810d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); 6811d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6812d201456903f3ecae1f7794edfab0d5678e64226shiqian#else 6813d201456903f3ecae1f7794edfab0d5678e64226shiqian // On non-Windows platforms, we rely on TERM to determine if the 6814d201456903f3ecae1f7794edfab0d5678e64226shiqian // terminal supports colors. 6815d201456903f3ecae1f7794edfab0d5678e64226shiqian 6816d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "dumb"); // TERM doesn't support colors. 6817d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6818d201456903f3ecae1f7794edfab0d5678e64226shiqian 6819d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "emacs"); // TERM doesn't support colors. 6820d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6821d201456903f3ecae1f7794edfab0d5678e64226shiqian 6822d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "vt100"); // TERM doesn't support colors. 6823d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6824d201456903f3ecae1f7794edfab0d5678e64226shiqian 6825d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-mono"); // TERM doesn't support colors. 6826d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_FALSE(ShouldUseColor(true)); // Stdout is a TTY. 6827d201456903f3ecae1f7794edfab0d5678e64226shiqian 6828d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm"); // TERM supports colors. 6829d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6830d201456903f3ecae1f7794edfab0d5678e64226shiqian 6831d201456903f3ecae1f7794edfab0d5678e64226shiqian SetEnv("TERM", "xterm-color"); // TERM supports colors. 6832d201456903f3ecae1f7794edfab0d5678e64226shiqian EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 683389080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan 6834e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "xterm-256color"); // TERM supports colors. 6835e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6836e05489605fc58736f837563db1fc33f9131ee810vladlosev 6837e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "screen"); // TERM supports colors. 6838e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6839e05489605fc58736f837563db1fc33f9131ee810vladlosev 68406b7a167dca7a9007d14fc95a07f4f6e07fec3162zhanyong.wan SetEnv("TERM", "screen-256color"); // TERM supports colors. 68416b7a167dca7a9007d14fc95a07f4f6e07fec3162zhanyong.wan EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 68426b7a167dca7a9007d14fc95a07f4f6e07fec3162zhanyong.wan 68431197daf3571161590dce2bc4879512ef7bc1ba67kosak SetEnv("TERM", "rxvt-unicode"); // TERM supports colors. 68441197daf3571161590dce2bc4879512ef7bc1ba67kosak EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 68451197daf3571161590dce2bc4879512ef7bc1ba67kosak 68461197daf3571161590dce2bc4879512ef7bc1ba67kosak SetEnv("TERM", "rxvt-unicode-256color"); // TERM supports colors. 68471197daf3571161590dce2bc4879512ef7bc1ba67kosak EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 68481197daf3571161590dce2bc4879512ef7bc1ba67kosak 684989080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan SetEnv("TERM", "linux"); // TERM supports colors. 685089080477aee9bd91536c9fb47bc31c62ea7d75bbzhanyong.wan EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6851e05489605fc58736f837563db1fc33f9131ee810vladlosev 6852e05489605fc58736f837563db1fc33f9131ee810vladlosev SetEnv("TERM", "cygwin"); // TERM supports colors. 6853e05489605fc58736f837563db1fc33f9131ee810vladlosev EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY. 6854d201456903f3ecae1f7794edfab0d5678e64226shiqian#endif // GTEST_OS_WINDOWS 6855d201456903f3ecae1f7794edfab0d5678e64226shiqian} 6856d201456903f3ecae1f7794edfab0d5678e64226shiqian 685753e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a namespace scope. 685853e0dc4041f660b6517b15b08b496e164be614f1shiqian 685948b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wanstatic bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>(); 686048b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wanstatic bool dummy2 GTEST_ATTRIBUTE_UNUSED_ = 686148b1315108cdba8f37394aedb8098102ca00e8b9zhanyong.wan StaticAssertTypeEq<const int, const int>(); 686253e0dc4041f660b6517b15b08b496e164be614f1shiqian 686353e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works in a class. 686453e0dc4041f660b6517b15b08b496e164be614f1shiqian 686553e0dc4041f660b6517b15b08b496e164be614f1shiqiantemplate <typename T> 686653e0dc4041f660b6517b15b08b496e164be614f1shiqianclass StaticAssertTypeEqTestHelper { 686753e0dc4041f660b6517b15b08b496e164be614f1shiqian public: 686853e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper() { StaticAssertTypeEq<bool, T>(); } 686953e0dc4041f660b6517b15b08b496e164be614f1shiqian}; 687053e0dc4041f660b6517b15b08b496e164be614f1shiqian 687153e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, WorksInClass) { 687253e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEqTestHelper<bool>(); 687353e0dc4041f660b6517b15b08b496e164be614f1shiqian} 687453e0dc4041f660b6517b15b08b496e164be614f1shiqian 687553e0dc4041f660b6517b15b08b496e164be614f1shiqian// Verifies that StaticAssertTypeEq works inside a function. 687653e0dc4041f660b6517b15b08b496e164be614f1shiqian 687753e0dc4041f660b6517b15b08b496e164be614f1shiqiantypedef int IntAlias; 687853e0dc4041f660b6517b15b08b496e164be614f1shiqian 687953e0dc4041f660b6517b15b08b496e164be614f1shiqianTEST(StaticAssertTypeEqTest, CompilesForEqualTypes) { 688053e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int, IntAlias>(); 688153e0dc4041f660b6517b15b08b496e164be614f1shiqian StaticAssertTypeEq<int*, IntAlias*>(); 688253e0dc4041f660b6517b15b08b496e164be614f1shiqian} 688353e0dc4041f660b6517b15b08b496e164be614f1shiqian 68843d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosevTEST(GetCurrentOsStackTraceExceptTopTest, ReturnsTheStackTrace) { 68853d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev testing::UnitTest* const unit_test = testing::UnitTest::GetInstance(); 68863d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev 68873d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev // We don't have a stack walker in Google Test yet. 68883d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 0).c_str()); 68893d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev EXPECT_STREQ("", GetCurrentOsStackTraceExceptTop(unit_test, 1).c_str()); 68903d7042176307f0d7700a3640f3b3bcc8790b8fcdvladlosev} 6891c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6892c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsNoFailure) { 6893c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailure()); 6894c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6895c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6896c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic void FailFatally() { FAIL(); } 6897c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6898c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsFalseWhenThereIsOnlyFatalFailure) { 6899c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6900c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6901c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6902c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(has_nonfatal_failure); 6903c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6904c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6905c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 6906c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6907c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6908c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6909c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6910c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6911c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6912c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 6913c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6914c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6915c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailure(); 6916c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6917c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6918c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6919c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6920c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasNonfatalFailure outside of a test body. 6921c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasNonfatalFailureHelper() { 6922c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan return testing::Test::HasNonfatalFailure(); 6923c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6924c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6925c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody) { 6926c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasNonfatalFailureHelper()); 6927c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6928c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6929c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasNonfatalFailureTest, WorksOutsideOfTestBody2) { 6930c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6931c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_nonfatal_failure = HasNonfatalFailureHelper(); 6932c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6933c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_nonfatal_failure); 6934c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6935c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6936c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsFalseWhenThereIsNoFailure) { 6937c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailure()); 6938c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6939c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6940c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsFatalFailure) { 6941c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6942c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6943c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6944c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6945c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6946c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6947c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereIsNonfatalFailure) { 6948c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6949c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6950c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6951c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6952c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6953c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6954c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, ReturnsTrueWhenThereAreFatalAndNonfatalFailures) { 6955c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan FailFatally(); 6956c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6957c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailure(); 6958c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6959c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6960c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6961c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6962c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan// A wrapper for calling HasFailure outside of a test body. 6963c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanstatic bool HasFailureHelper() { return testing::Test::HasFailure(); } 6964c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6965c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody) { 6966c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_FALSE(HasFailureHelper()); 6967c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 6968c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan 6969c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wanTEST(HasFailureTest, WorksOutsideOfTestBody2) { 6970c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ADD_FAILURE(); 6971c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan const bool has_failure = HasFailureHelper(); 6972c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan ClearCurrentTestPartResults(); 6973c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan EXPECT_TRUE(has_failure); 6974c12f63214e9b7761d27e68353e4aaf1761c9cf88zhanyong.wan} 697516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 697616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanclass TestListener : public EmptyTestEventListener { 697716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 697816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener() : on_start_counter_(NULL), is_destroyed_(NULL) {} 697916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener(int* on_start_counter, bool* is_destroyed) 698016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan : on_start_counter_(on_start_counter), 698116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan is_destroyed_(is_destroyed) {} 698216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 698316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan virtual ~TestListener() { 698416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan if (is_destroyed_) 698516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *is_destroyed_ = true; 698616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 698716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 698816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan protected: 6989f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 699016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan if (on_start_counter_ != NULL) 699116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan (*on_start_counter_)++; 699216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 699316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 699416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan private: 699516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int* on_start_counter_; 699616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool* is_destroyed_; 699716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 699816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 699916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests the constructor. 7000f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, ConstructionWorks) { 7001f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 700216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7003f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan EXPECT_TRUE(TestEventListenersAccessor::GetRepeater(&listeners) != NULL); 700416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 700516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 700616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 700716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7008f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that the TestEventListeners destructor deletes all the listeners it 700916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// owns. 7010f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, DestructionWorks) { 701116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool default_result_printer_is_destroyed = false; 701216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool default_xml_printer_is_destroyed = false; 701316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool extra_listener_is_destroyed = false; 701416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* default_result_printer = new TestListener( 701516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &default_result_printer_is_destroyed); 701616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* default_xml_printer = new TestListener( 701716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &default_xml_printer_is_destroyed); 701816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* extra_listener = new TestListener( 701916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan NULL, &extra_listener_is_destroyed); 702016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 702116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 7022f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7023f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, 7024f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan default_result_printer); 7025f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, 7026f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan default_xml_printer); 702716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(extra_listener); 702816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 702916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(default_result_printer_is_destroyed); 703016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(default_xml_printer_is_destroyed); 703116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(extra_listener_is_destroyed); 703216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 703316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7034f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that a listener Append'ed to a TestEventListeners list starts 703516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events. 7036f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, Append) { 703716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 703816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 703916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 704016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 7041f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 704216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 7043f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 704416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 704516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 704616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 704716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 704816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 704916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7050f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// Tests that listeners receive events in the order they were appended to 7051f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// the list, except for *End requests, which must be received in the reverse 7052f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan// order. 705316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanclass SequenceTestingListener : public EmptyTestEventListener { 705416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan public: 705587fdda2cf24d953f3cbec1e0c266b2db9928f406jgm SequenceTestingListener(std::vector<std::string>* vector, const char* id) 7056f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan : vector_(vector), id_(id) {} 705716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 705816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan protected: 7059f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) { 70600d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestProgramStart")); 7061f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 7062f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 7063f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) { 70640d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestProgramEnd")); 7065f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 7066f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 7067f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, 7068f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan int /*iteration*/) { 70690d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestIterationStart")); 7070f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 7071f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 7072f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, 7073f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan int /*iteration*/) { 70740d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vector_->push_back(GetEventDescription("OnTestIterationEnd")); 707516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 707616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 707716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan private: 707887fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::string GetEventDescription(const char* method) { 7079f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan Message message; 7080f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan message << id_ << "." << method; 7081f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan return message.GetString(); 7082f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan } 7083f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 708487fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::vector<std::string>* vector_; 7085f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan const char* const id_; 70869f894c2b36e83e9414b3369f9a4974644d843d8dzhanyong.wan 70879f894c2b36e83e9414b3369f9a4974644d843d8dzhanyong.wan GTEST_DISALLOW_COPY_AND_ASSIGN_(SequenceTestingListener); 708816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan}; 708916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 709016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, AppendKeepsOrder) { 709187fdda2cf24d953f3cbec1e0c266b2db9928f406jgm std::vector<std::string> vec; 7092f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7093f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "1st")); 7094f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "2nd")); 7095f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan listeners.Append(new SequenceTestingListener(&vec, "3rd")); 7096f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 7097f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 7098f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance()); 70990d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 71000d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestProgramStart", vec[0].c_str()); 71010d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestProgramStart", vec[1].c_str()); 71020d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestProgramStart", vec[2].c_str()); 7103f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 71040d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 7105f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramEnd( 710616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 71070d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 71080d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestProgramEnd", vec[0].c_str()); 71090d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestProgramEnd", vec[1].c_str()); 71100d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestProgramEnd", vec[2].c_str()); 7111f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 71120d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 7113f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationStart( 7114f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance(), 0); 71150d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 71160d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestIterationStart", vec[0].c_str()); 71170d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestIterationStart", vec[1].c_str()); 71180d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestIterationStart", vec[2].c_str()); 7119f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan 71200d27868d0faef474594682f25336229daa89d6d7zhanyong.wan vec.clear(); 7121f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestIterationEnd( 7122f43e4ff3ad12ace9d423cc3ce02feadb8f24fe67zhanyong.wan *UnitTest::GetInstance(), 0); 71230d27868d0faef474594682f25336229daa89d6d7zhanyong.wan ASSERT_EQ(3U, vec.size()); 71240d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("3rd.OnTestIterationEnd", vec[0].c_str()); 71250d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("2nd.OnTestIterationEnd", vec[1].c_str()); 71260d27868d0faef474594682f25336229daa89d6d7zhanyong.wan EXPECT_STREQ("1st.OnTestIterationEnd", vec[2].c_str()); 712716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 712816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7129f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan// Tests that a listener removed from a TestEventListeners list stops receiving 713016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// events and is not deleted when the list is destroyed. 7131f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wanTEST(TestEventListenersTest, Release) { 713216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 713316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 713416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 713516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 713616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 713716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 713816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 7139f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 714016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 714116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 7142f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 714316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 714416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.Release(listener) == NULL); 714516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 714616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 714716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 714816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 714916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 715016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 715116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that no events are forwarded when event forwarding is disabled. 715216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, SuppressEventForwarding) { 715316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 715416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, NULL); 715516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7156f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 715716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan listeners.Append(listener); 7158f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan ASSERT_TRUE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 7159f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SuppressEventForwarding(&listeners); 7160f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan ASSERT_FALSE(TestEventListenersAccessor::EventForwardingEnabled(listeners)); 7161f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 716216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 716316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 716416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 716516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 716616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that events generated by Google Test are not forwarded in 716716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// death test subprocesses. 716816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) { 7169b2ee82ebf9b8f1be859d08611b768ae6c0700090zhanyong.wan EXPECT_DEATH_IF_SUPPORTED({ 7170f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled( 717116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *GetUnitTestImpl()->listeners())) << "expected failure";}, 717216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan "expected failure"); 717316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 717416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 717516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that a listener installed via SetDefaultResultPrinter() starts 717616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events and is returned via default_result_printer() and that 717716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// the previous default_result_printer is removed from the list and deleted. 717816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, default_result_printer) { 717916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 718016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 718116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 718216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7183f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7184f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 718516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 718616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.default_result_printer()); 718716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7188f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 718916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 719016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 719116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 719216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 719316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Replacing default_result_printer with something else should remove it 719416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // from the list and destroy it. 7195f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, NULL); 719616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 719716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 719816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 719916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 720016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // After broadcasting an event the counter is still the same, indicating 720116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the listener is not in the list anymore. 7202f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 720316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 720416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 720516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 720616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 720716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that the default_result_printer listener stops receiving events 720816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// when removed via Release and that is not owned by the list anymore. 720916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, RemovingDefaultResultPrinterWorks) { 721016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 721116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 721216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 721316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 721416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 721516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 721616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 7217f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7218f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultResultPrinter(&listeners, listener); 721916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 722016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 722116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_result_printer() == NULL); 722216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 722316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 722416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Broadcasting events now should not affect default_result_printer. 7225f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 722616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 722716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 722816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 722916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Destroying the list should not affect the listener now, too. 723016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 723116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 723216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 723316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 723416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that a listener installed via SetDefaultXmlGenerator() starts 723516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// receiving events and is returned via default_xml_generator() and that 723616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// the previous default_xml_generator is removed from the list and deleted. 723716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, default_xml_generator) { 723816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 723916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 724016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 724116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7242f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7243f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 724416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 724516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.default_xml_generator()); 724616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 7247f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 724816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 724916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 725016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 725116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 725216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Replacing default_xml_generator with something else should remove it 725316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // from the list and destroy it. 7254f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, NULL); 725516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 725616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 725716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(is_destroyed); 725816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 725916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // After broadcasting an event the counter is still the same, indicating 726016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the listener is not in the list anymore. 7261f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 726216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 726316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(1, on_start_counter); 726416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 726516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 726616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// Tests that the default_xml_generator listener stops receiving events 726716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan// when removed via Release and that is not owned by the list anymore. 726816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wanTEST(EventListenerTest, RemovingDefaultXmlGeneratorWorks) { 726916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan int on_start_counter = 0; 727016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan bool is_destroyed = false; 727116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Although Append passes the ownership of this object to the list, 727216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // the following calls release it, and we need to delete it before the 727316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // test ends. 727416e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan TestListener* listener = new TestListener(&on_start_counter, &is_destroyed); 727516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan { 7276f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListeners listeners; 7277f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::SetDefaultXmlGenerator(&listeners, listener); 727816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 727916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(listener, listeners.Release(listener)); 728016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_TRUE(listeners.default_xml_generator() == NULL); 728116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 728216e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan 728316e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Broadcasting events now should not affect default_xml_generator. 7284f8b268ee86ca74bba3276352f1e7de53d1336c3ezhanyong.wan TestEventListenersAccessor::GetRepeater(&listeners)->OnTestProgramStart( 728516e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan *UnitTest::GetInstance()); 728616e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_EQ(0, on_start_counter); 728716e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan } 728816e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan // Destroying the list should not affect the listener now, too. 728916e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan EXPECT_FALSE(is_destroyed); 729016e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan delete listener; 729116e9dd6e28a8a7fb2d611011e7353e042fcb282fzhanyong.wan} 72921b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan 72931b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// Sanity tests to ensure that the alternative, verbose spellings of 72941b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// some of the macros work. We don't test them thoroughly as that 72951b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// would be quite involved. Since their implementations are 72961b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// straightforward, and they are rarely used, we'll just rely on the 72971b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan// users to tell us when they are broken. 72981b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wanGTEST_TEST(AlternativeNameTest, Works) { // GTEST_TEST is the same as TEST. 72991b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan GTEST_SUCCEED() << "OK"; // GTEST_SUCCEED is the same as SUCCEED. 73001b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan 73011b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan // GTEST_FAIL is the same as FAIL. 73021b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan EXPECT_FATAL_FAILURE(GTEST_FAIL() << "An expected failure", 73031b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan "An expected failure"); 7304345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7305345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan // GTEST_ASSERT_XY is the same as ASSERT_XY. 7306345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7307345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_EQ(0, 0); 7308345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(0, 1) << "An expected failure", 7309345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7310345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_EQ(1, 0) << "An expected failure", 7311345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7312345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7313345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_NE(0, 1); 7314345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_NE(1, 0); 7315345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_NE(0, 0) << "An expected failure", 7316345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7317345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7318345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LE(0, 0); 7319345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LE(0, 1); 7320345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LE(1, 0) << "An expected failure", 7321345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7322345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7323345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_LT(0, 1); 7324345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(0, 0) << "An expected failure", 7325345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7326345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_LT(1, 0) << "An expected failure", 7327345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7328345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7329345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GE(0, 0); 7330345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GE(1, 0); 7331345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GE(0, 1) << "An expected failure", 7332345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7333345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan 7334345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan GTEST_ASSERT_GT(1, 0); 7335345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(0, 1) << "An expected failure", 7336345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 7337345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan EXPECT_FATAL_FAILURE(GTEST_ASSERT_GT(1, 1) << "An expected failure", 7338345d9ebf30ccc2747c4e4c224b95fd8406093e29zhanyong.wan "An expected failure"); 73391b71f0b272f4d3dfb45db44ab39a77727ddafb9bzhanyong.wan} 73402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests for internal utilities necessary for implementation of the universal 73422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// printing. 73432ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// TODO(vladl@google.com): Find a better home for them. 73442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass ConversionHelperBase {}; 73462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass ConversionHelperDerived : public ConversionHelperBase {}; 73472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is a compile-time constant. 73492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsCompileTimeConstant) { 73502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_(IsAProtocolMessage<ProtocolMessage>::value, 73512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const_true); 73522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_(!IsAProtocolMessage<int>::value, const_false); 73532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is true when T is 735635c39756495bea5959de5778aaaf33a94f8c1e2ezhanyong.wan// proto2::Message or a sub-class of it. 73572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsTrueWhenTypeIsAProtocolMessage) { 73582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(IsAProtocolMessage< ::proto2::Message>::value); 73592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(IsAProtocolMessage<ProtocolMessage>::value); 73602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that IsAProtocolMessage<T>::value is false when T is neither 73632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// ProtocolMessage nor a sub-class of it. 73642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsAProtocolMessageTest, ValueIsFalseWhenTypeIsNotAProtocolMessage) { 73652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(IsAProtocolMessage<int>::value); 73662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(IsAProtocolMessage<const ConversionHelperBase>::value); 73672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that CompileAssertTypesEqual compiles when the type arguments are 73702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// equal. 73712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CompileAssertTypesEqual, CompilesWhenTypesAreEqual) { 73722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<void, void>(); 73732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int*, int*>(); 73742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveReference does not affect non-reference types. 73772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, DoesNotAffectNonReferenceType) { 73782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveReference<int>::type>(); 73792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char, RemoveReference<const char>::type>(); 73802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveReference removes reference from reference types. 73832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, RemovesReference) { 73842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveReference<int&>::type>(); 73852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char, RemoveReference<const char&>::type>(); 73862ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REMOVE_REFERENCE_. 73892ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 73912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestRemoveReference() { 73922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_(T2)>(); 73932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 73952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveReferenceTest, MacroVersion) { 73962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveReference<int, int>(); 73972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveReference<const char, const char&>(); 73982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 73992ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveConst does not affect non-const types. 74022ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, DoesNotAffectNonConstType) { 74032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveConst<int>::type>(); 74042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char&, RemoveConst<char&>::type>(); 74052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that RemoveConst removes const from const types. 74082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, RemovesConst) { 74092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int, RemoveConst<const int>::type>(); 74102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char[2], RemoveConst<const char[2]>::type>(); 74112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<char[2][3], RemoveConst<const char[2][3]>::type>(); 74122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74132ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REMOVE_CONST_. 74152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 74172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestRemoveConst() { 74182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_CONST_(T2)>(); 74192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(RemoveConstTest, MacroVersion) { 74222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<int, int>(); 74232ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<double&, double&>(); 74242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestRemoveConst<char, const char>(); 74252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 742755d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan// Tests GTEST_REMOVE_REFERENCE_AND_CONST_. 742855d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 742955d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wantemplate <typename T1, typename T2> 743055d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wanvoid TestGTestRemoveReferenceAndConst() { 743155d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan CompileAssertTypesEqual<T1, GTEST_REMOVE_REFERENCE_AND_CONST_(T2)>(); 743255d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan} 743355d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 743455d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wanTEST(RemoveReferenceToConstTest, Works) { 743555d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<int, int>(); 743655d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<double, double&>(); 743755d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<char, const char>(); 743855d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<char, const char&>(); 743955d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan TestGTestRemoveReferenceAndConst<const char*, const char*>(); 744055d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan} 744155d166a2228d7e3b3500b8651ab9b8e56fb43b7ezhanyong.wan 74422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that AddReference does not affect reference types. 74432ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, DoesNotAffectReferenceType) { 74442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int&, AddReference<int&>::type>(); 74452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char&, AddReference<const char&>::type>(); 74462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that AddReference adds reference to non-reference types. 74492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, AddsReference) { 74502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<int&, AddReference<int>::type>(); 74512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<const char&, AddReference<const char>::type>(); 74522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_ADD_REFERENCE_. 74552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 74572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestAddReference() { 74582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_ADD_REFERENCE_(T2)>(); 74592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(AddReferenceTest, MacroVersion) { 74622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestAddReference<int&, int>(); 74632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestAddReference<const char&, const char&>(); 74642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests GTEST_REFERENCE_TO_CONST_. 74672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wantemplate <typename T1, typename T2> 74692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanvoid TestGTestReferenceToConst() { 74702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CompileAssertTypesEqual<T1, GTEST_REFERENCE_TO_CONST_(T2)>(); 74712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(GTestReferenceToConstTest, Works) { 74742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const char&, char>(); 74752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const int&, const int>(); 74762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan TestGTestReferenceToConst<const double&, double>(); 747787fdda2cf24d953f3cbec1e0c266b2db9928f406jgm TestGTestReferenceToConst<const std::string&, const std::string&>(); 74782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is a compile-time constant. 74812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsCompileTimeConstant) { 74822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_((ImplicitlyConvertible<int, int>::value), const_true); 74832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan GTEST_COMPILE_ASSERT_((!ImplicitlyConvertible<void*, int*>::value), 74842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const_false); 74852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74862ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 74872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is true when T1 can 74882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// be implicitly converted to T2. 74892ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsTrueWhenConvertible) { 74902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int, double>::value)); 74912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<double, int>::value)); 74922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int*, void*>::value)); 74932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<int*, const int*>::value)); 74942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<ConversionHelperDerived&, 74952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const ConversionHelperBase&>::value)); 74962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE((ImplicitlyConvertible<const ConversionHelperBase, 74972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ConversionHelperBase>::value)); 74982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 74992ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests that ImplicitlyConvertible<T1, T2>::value is false when T1 75012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// cannot be implicitly converted to T2. 75022ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ImplicitlyConvertibleTest, ValueIsFalseWhenNotConvertible) { 75032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<double, int*>::value)); 75042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<void*, int*>::value)); 75052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<const int*, int*>::value)); 75062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE((ImplicitlyConvertible<ConversionHelperBase&, 75072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ConversionHelperDerived&>::value)); 75082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests IsContainerTest. 75112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanclass NonContainer {}; 75132ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsContainerTestTest, WorksForNonContainer) { 75152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<int>(0))); 75162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<char[5]>(0))); 75172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsNotContainer), sizeof(IsContainerTest<NonContainer>(0))); 75182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(IsContainerTestTest, WorksForContainer) { 75212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsContainer), 75222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan sizeof(IsContainerTest<std::vector<bool> >(0))); 75232ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(sizeof(IsContainer), 75242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan sizeof(IsContainerTest<std::map<int, double> >(0))); 75252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75272ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests ArrayEq(). 75282ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForDegeneratedArrays) { 75302ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(5, 5L)); 75312ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq('a', 0)); 75322ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75332ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75342ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForOneDimensionalArrays) { 75358965a6a0d2165f32e6413594bba6367f271f51e7vladlosev // Note that a and b are distinct but compatible types. 75362ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[] = { 0, 1 }; 75372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan long b[] = { 0, 1 }; 75382ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 75392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, 2, b)); 75402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan b[0] = 2; 75422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, b)); 75432ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, 1, b)); 75442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayEqTest, WorksForTwoDimensionalArrays) { 75472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[][3] = { "hi", "lo" }; 75482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char b[][3] = { "hi", "lo" }; 75492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char c[][3] = { "hi", "li" }; 75502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 75522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, 2, b)); 75532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, c)); 75552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_FALSE(ArrayEq(a, 2, c)); 75562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75582ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests ArrayAwareFind(). 75592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayAwareFindTest, WorksForOneDimensionalArray) { 75612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[] = "hello"; 75622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 4, ArrayAwareFind(a, a + 5, 'o')); 75632ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 5, ArrayAwareFind(a, a + 5, 'x')); 75642ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(ArrayAwareFindTest, WorksForTwoDimensionalArray) { 75672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int a[][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } }; 75682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b[2] = { 2, 3 }; 75692ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 1, ArrayAwareFind(a, a + 3, b)); 75702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int c[2] = { 6, 7 }; 75722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a + 3, ArrayAwareFind(a, a + 3, c)); 75732ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75742ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75752ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests CopyArray(). 75762ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75772ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForDegeneratedArrays) { 75782ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int n = 0; 75792ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray('a', &n); 75802ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ('a', n); 75812ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75822ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75832ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForOneDimensionalArrays) { 75842ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[3] = "hi"; 75852ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int b[3]; 7586603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions. 75872ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, &b); 75882ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 7589603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#endif 75902ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75912ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int c[3]; 75922ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, 3, c); 75932ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, c)); 75942ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 75952ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 75962ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(CopyArrayTest, WorksForTwoDimensionalArrays) { 75972ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; 75982ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int b[2][3]; 7599603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#ifndef __BORLANDC__ // C++Builder cannot compile some array size deductions. 76002ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, &b); 76012ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, b)); 7602603533a0a4dcfc2ef33051b9ae8237568a19adc4zhanyong.wan#endif 76032ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76042ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan int c[2][3]; 76052ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan CopyArray(a, 2, c); 76062ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(ArrayEq(a, c)); 76072ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 76082ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76092ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan// Tests NativeArray. 76102ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76112ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, ConstructorFromArrayWorks) { 76122ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[3] = { 0, 1, 2 }; 76138120f66c3249e253f03fdb48bee7e528bc038d31billydonahue NativeArray<int> na(a, 3, RelationToSourceReference()); 76142ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(3U, na.size()); 76152ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a, na.begin()); 76162ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 76172ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76182ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, CreatesAndDeletesCopyOfArrayWhenAskedTo) { 76192ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan typedef int Array[2]; 76202ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan Array* a = new Array[1]; 76212ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan (*a)[0] = 0; 76222ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan (*a)[1] = 1; 76238120f66c3249e253f03fdb48bee7e528bc038d31billydonahue NativeArray<int> na(*a, 2, RelationToSourceCopy()); 76242ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_NE(*a, na.begin()); 76252ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan delete[] a; 76262ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(0, na.begin()[0]); 76272ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(1, na.begin()[1]); 76282ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76292ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan // We rely on the heap checker to verify that na deletes the copy of 76302ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan // array. 76312ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 76322ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76332ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, TypeMembersAreCorrect) { 76342ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<char, NativeArray<char>::value_type>(); 76352ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<int[2], NativeArray<int[2]>::value_type>(); 76362ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76372ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<const char*, NativeArray<char>::const_iterator>(); 76382ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan StaticAssertTypeEq<const bool(*)[2], NativeArray<bool[2]>::const_iterator>(); 76392ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 76402ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76412ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, MethodsWork) { 76422ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int a[3] = { 0, 1, 2 }; 76438120f66c3249e253f03fdb48bee7e528bc038d31billydonahue NativeArray<int> na(a, 3, RelationToSourceCopy()); 76442ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ASSERT_EQ(3U, na.size()); 76452ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(3, na.end() - na.begin()); 76462ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76472ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan NativeArray<int>::const_iterator it = na.begin(); 76482ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(0, *it); 76492ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ++it; 76502ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(1, *it); 76512ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan it++; 76522ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(2, *it); 76532ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ++it; 76542ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(na.end(), it); 76552ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76562ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(na == na); 76572ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76588120f66c3249e253f03fdb48bee7e528bc038d31billydonahue NativeArray<int> na2(a, 3, RelationToSourceReference()); 76592ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_TRUE(na == na2); 76602ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76612ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b1[3] = { 0, 1, 1 }; 76622ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const int b2[4] = { 0, 1, 2, 3 }; 76638120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_FALSE(na == NativeArray<int>(b1, 3, RelationToSourceReference())); 76648120f66c3249e253f03fdb48bee7e528bc038d31billydonahue EXPECT_FALSE(na == NativeArray<int>(b2, 4, RelationToSourceCopy())); 76652ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 76662ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan 76672ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wanTEST(NativeArrayTest, WorksForTwoDimensionalArray) { 76682ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan const char a[2][3] = { "hi", "lo" }; 76698120f66c3249e253f03fdb48bee7e528bc038d31billydonahue NativeArray<char[3]> na(a, 2, RelationToSourceReference()); 76702ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan ASSERT_EQ(2U, na.size()); 76712ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan EXPECT_EQ(a, na.begin()); 76722ccea88c99d1ae23383d1b8eb3680a4a4d2edd66zhanyong.wan} 7673985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7674985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan// Tests SkipPrefix(). 7675985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7676985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanTEST(SkipPrefixTest, SkipsWhenPrefixMatches) { 7677985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* const str = "hello"; 7678985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7679985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* p = str; 7680985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_TRUE(SkipPrefix("", &p)); 7681985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7682985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7683985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan p = str; 7684985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_TRUE(SkipPrefix("hell", &p)); 7685985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str + 4, p); 7686985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan} 7687985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7688985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wanTEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) { 7689985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* const str = "world"; 7690985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7691985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan const char* p = str; 7692985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_FALSE(SkipPrefix("W", &p)); 7693985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7694985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan 7695985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan p = str; 7696985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_FALSE(SkipPrefix("world!", &p)); 7697985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan EXPECT_EQ(str, p); 7698985a30360ce4824b65cb35ad55faa0d7c1ad1104zhanyong.wan} 76998120f66c3249e253f03fdb48bee7e528bc038d31billydonahue 7700