1c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Copyright 2005, Google Inc. 2c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// All rights reserved. 3c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 4c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Redistribution and use in source and binary forms, with or without 5c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// modification, are permitted provided that the following conditions are 6c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// met: 7c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 8c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Redistributions of source code must retain the above copyright 9c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// notice, this list of conditions and the following disclaimer. 10c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Redistributions in binary form must reproduce the above 11c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// copyright notice, this list of conditions and the following disclaimer 12c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// in the documentation and/or other materials provided with the 13c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// distribution. 14c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// * Neither the name of Google Inc. nor the names of its 15c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// contributors may be used to endorse or promote products derived from 16c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// this software without specific prior written permission. 17c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 18c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 30c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A unit test for Google Test itself. This verifies that the basic 31c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// constructs of Google Test work. 32c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 33c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Author: wan@google.com (Zhanyong Wan) 34c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 35731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "gtest/gtest-spi.h" 36731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick#include "gtest/gtest.h" 37c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 38c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Indicates that this translation unit is part of Google Test's 39c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// implementation. It must come before gtest-internal-inl.h is 40c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// included, or there will be a compiler error. This trick is to 41c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// prevent a user from accidentally including gtest-internal-inl.h in 42c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// his code. 43c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#define GTEST_IMPLEMENTATION_ 1 44c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include "src/gtest-internal-inl.h" 45c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#undef GTEST_IMPLEMENTATION_ 46c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 47c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#include <stdlib.h> 48c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 49c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_IS_THREADSAFE 50c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::ScopedFakeTestPartResultReporter; 51c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::TestPartResultArray; 52c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 53c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::Notification; 54c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::ThreadWithParam; 55c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif 56c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 57c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace posix = ::testing::internal::posix; 58c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::String; 59c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochusing testing::internal::scoped_ptr; 60c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 61c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests catching fatal failures. 62c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 63c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A subroutine used by the following test. 64c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid TestEq1(int x) { 65c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_EQ(1, x); 66c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 67c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 68c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This function calls a test subroutine, catches the fatal failure it 69c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates, and then returns early. 70c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid TryTestSubroutine() { 71c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Calls a subrountine that yields a fatal failure. 72c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestEq1(2); 73c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 74c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Catches the fatal failure and aborts the test. 75c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 76c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The testing::Test:: prefix is necessary when calling 77c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // HasFatalFailure() outside of a TEST, TEST_F, or test fixture. 78c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (testing::Test::HasFatalFailure()) return; 79c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 80c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we get here, something is wrong. 81c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "This should never be reached."; 82c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 83c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 84c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PassingTest, PassingTest1) { 85c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 86c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 87c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(PassingTest, PassingTest2) { 88c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 89c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 903345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// Tests that parameters of failing parameterized tests are printed in the 913345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// failing test summary. 923345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickclass FailingParamTest : public testing::TestWithParam<int> {}; 933345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 943345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickTEST_P(FailingParamTest, Fails) { 953345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick EXPECT_EQ(1, GetParam()); 963345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick} 973345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 983345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// This generates a test which will fail. Google Test is expected to print 993345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick// its parameter when it outputs the list of all failed tests. 1003345a6884c488ff3a535c2c9acdd33d74b37e311Iain MerrickINSTANTIATE_TEST_CASE_P(PrintingFailingParams, 1013345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick FailingParamTest, 1023345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick testing::Values(2)); 1033345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick 104c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests catching a fatal failure in a subroutine. 105c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FatalFailureTest, FatalFailureInSubroutine) { 106c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure that x should be 1)\n"); 107c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 108c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TryTestSubroutine(); 109c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 110c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 111c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests catching a fatal failure in a nested subroutine. 112c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FatalFailureTest, FatalFailureInNestedSubroutine) { 113c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure that x should be 1)\n"); 114c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 115c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Calls a subrountine that yields a fatal failure. 116c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TryTestSubroutine(); 117c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 118c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Catches the fatal failure and aborts the test. 119c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // 120c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // When calling HasFatalFailure() inside a TEST, TEST_F, or test 121c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // fixture, the testing::Test:: prefix is not needed. 122c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (HasFatalFailure()) return; 123c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 124c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // If we get here, something is wrong. 125c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "This should never be reached."; 126c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 127c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 128c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests HasFatalFailure() after a failed EXPECT check. 129c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(FatalFailureTest, NonfatalFailureInSubroutine) { 130c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure on false)\n"); 131c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(false); // Generates a nonfatal failure 132c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_FALSE(HasFatalFailure()); // This should succeed. 133c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 134c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 135c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests interleaving user logging and Google Test assertions. 136c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(LoggingTest, InterleavingLoggingAndAssertions) { 137c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static const int a[4] = { 138c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 3, 9, 2, 6 139c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 140c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 141c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 2 failures on (3) >= (a[i]))\n"); 142c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (int i = 0; i < static_cast<int>(sizeof(a)/sizeof(*a)); i++) { 143c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("i == %d\n", i); 144c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_GE(3, a[i]); 145c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 146c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 147c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 148c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests the SCOPED_TRACE macro. 149c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 150c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A helper function for testing SCOPED_TRACE. 151c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid SubWithoutTrace(int n) { 152c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(1, n); 153c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_EQ(2, n); 154c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 155c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 156c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Another helper function for testing SCOPED_TRACE. 157c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid SubWithTrace(int n) { 158c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE(testing::Message() << "n = " << n); 159c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 160c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubWithoutTrace(n); 161c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 162c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 163c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SCOPED_TRACE() obeys lexical scopes. 164c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, ObeysScopes) { 165c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expected to fail)\n"); 166c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 167c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // There should be no trace before SCOPED_TRACE() is invoked. 168c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "This failure is expected, and shouldn't have a trace."; 169c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 170c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { 171c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("Expected trace"); 172c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // After SCOPED_TRACE(), a failure in the current scope should contain 173c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the trace. 174c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "This failure is expected, and should have a trace."; 175c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 176c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 177c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Once the control leaves the scope of the SCOPED_TRACE(), there 178c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // should be no trace again. 179c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "This failure is expected, and shouldn't have a trace."; 180c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 181c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 182c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SCOPED_TRACE works inside a loop. 183c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, WorksInLoop) { 184c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expected to fail)\n"); 185c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 186c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch for (int i = 1; i <= 2; i++) { 187c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE(testing::Message() << "i = " << i); 188c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 189c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubWithoutTrace(i); 190c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 191c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 192c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 193c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SCOPED_TRACE works in a subroutine. 194c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, WorksInSubroutine) { 195c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expected to fail)\n"); 196c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 197c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubWithTrace(1); 198c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubWithTrace(2); 199c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 200c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 201c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SCOPED_TRACE can be nested. 202c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, CanBeNested) { 203c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expected to fail)\n"); 204c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 205c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE(""); // A trace without a message. 206c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 207c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SubWithTrace(2); 208c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 209c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 210c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that multiple SCOPED_TRACEs can be used in the same scope. 211c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, CanBeRepeated) { 212c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expected to fail)\n"); 213c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 214c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("A"); 215c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 216c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "This failure is expected, and should contain trace point A."; 217c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 218c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("B"); 219c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 220c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "This failure is expected, and should contain trace point A and B."; 221c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 222c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { 223c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("C"); 224c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "This failure is expected, and should contain " 225c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "trace point A, B, and C."; 226c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 227c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 228c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("D"); 229c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "This failure is expected, and should contain " 230c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "trace point A, B, and D."; 231c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 232c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 233c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_IS_THREADSAFE 234c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that SCOPED_TRACE()s can be used concurrently from multiple 235c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// threads. Namely, an assertion should be affected by 236c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// SCOPED_TRACE()s in its own thread only. 237c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 238c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Here's the sequence of actions that happen in the test: 239c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 240c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Thread A (main) | Thread B (spawned) 241c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// ===============================|================================ 242c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// spawns thread B | 243c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// -------------------------------+-------------------------------- 244c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// waits for n1 | SCOPED_TRACE("Trace B"); 245c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// | generates failure #1 246c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// | notifies n1 247c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// -------------------------------+-------------------------------- 248c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// SCOPED_TRACE("Trace A"); | waits for n2 249c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates failure #2 | 250c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// notifies n2 | 251c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// -------------------------------|-------------------------------- 252c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// waits for n3 | generates failure #3 253c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// | trace B dies 254c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// | generates failure #4 255c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// | notifies n3 256c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// -------------------------------|-------------------------------- 257c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates failure #5 | finishes 258c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// trace A dies | 259c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates failure #6 | 260c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// -------------------------------|-------------------------------- 261c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// waits for thread B to finish | 262c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 263c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct CheckPoints { 264c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Notification n1; 265c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Notification n2; 266c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Notification n3; 267c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 268c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 269c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic void ThreadWithScopedTrace(CheckPoints* check_points) { 270c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { 271c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("Trace B"); 272c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 273c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #1 (in thread B, only trace B alive)."; 274c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points->n1.Notify(); 275c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points->n2.WaitForNotification(); 276c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 277c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 278c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #3 (in thread B, trace A & B both alive)."; 279c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } // Trace B dies here. 280c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 281c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #4 (in thread B, only trace A alive)."; 282c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points->n3.Notify(); 283c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 284c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 285c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(SCOPED_TRACETest, WorksConcurrently) { 286c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 6 failures)\n"); 287c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 288c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch CheckPoints check_points; 289c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ThreadWithParam<CheckPoints*> thread(&ThreadWithScopedTrace, 290c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &check_points, 291c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NULL); 292c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points.n1.WaitForNotification(); 293c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 294c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { 295c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SCOPED_TRACE("Trace A"); 296c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 297c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #2 (in thread A, trace A & B both alive)."; 298c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points.n2.Notify(); 299c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch check_points.n3.WaitForNotification(); 300c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 301c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 302c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #5 (in thread A, only trace A alive)."; 303c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } // Trace A dies here. 304c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() 305c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "Expected failure #6 (in thread A, no trace alive)."; 306c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch thread.Join(); 307c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 308c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_IS_THREADSAFE 309c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 310c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(DisabledTestsWarningTest, 311c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch DISABLED_AlsoRunDisabledTestsFlagSuppressesWarning) { 312c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // This test body is intentionally empty. Its sole purpose is for 313c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // verifying that the --gtest_also_run_disabled_tests flag 314c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // suppresses the "YOU HAVE 12 DISABLED TESTS" warning at the end of 315c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // the test output. 316c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 317c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 318c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests using assertions outside of TEST and TEST_F. 319c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 320c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This function creates two failures intentionally. 321c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid AdHocTest() { 322c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("The non-test part of the code is expected to have 2 failures.\n\n"); 323c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_TRUE(false); 324c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(2, 3); 325c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 326c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 327c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Runs all TESTs, all TEST_Fs, and the ad hoc test. 328c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochint RunAllTests() { 329c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AdHocTest(); 330c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return RUN_ALL_TESTS(); 331c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 332c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 333c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests non-fatal failures in the fixture constructor. 334c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass NonFatalFailureInFixtureConstructorTest : public testing::Test { 335c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 336c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NonFatalFailureInFixtureConstructorTest() { 337c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 5 failures)\n"); 338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #1, in the test fixture c'tor."; 339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ~NonFatalFailureInFixtureConstructorTest() { 342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #5, in the test fixture d'tor."; 343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #2, in SetUp()."; 347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 350c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #4, in TearDown."; 351c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 352c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 353c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 354c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(NonFatalFailureInFixtureConstructorTest, FailureInConstructor) { 355c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #3, in the test body."; 356c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 357c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 358c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests fatal failures in the fixture constructor. 359c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass FatalFailureInFixtureConstructorTest : public testing::Test { 360c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 361c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FatalFailureInFixtureConstructorTest() { 362c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 2 failures)\n"); 363c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Init(); 364c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 365c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 366c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ~FatalFailureInFixtureConstructorTest() { 367c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #2, in the test fixture d'tor."; 368c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 369c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 370c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 371c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "UNEXPECTED failure in SetUp(). " 372c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "We should never get here, as the test fixture c'tor " 373c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "had a fatal failure."; 374c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 375c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 376c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 377c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "UNEXPECTED failure in TearDown(). " 378c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "We should never get here, as the test fixture c'tor " 379c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "had a fatal failure."; 380c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 381c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 382c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void Init() { 383c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #1, in the test fixture c'tor."; 384c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 385c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 386c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 387c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FatalFailureInFixtureConstructorTest, FailureInConstructor) { 388c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "UNEXPECTED failure in the test body. " 389c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "We should never get here, as the test fixture c'tor " 390c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "had a fatal failure."; 391c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 392c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 393c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests non-fatal failures in SetUp(). 394c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass NonFatalFailureInSetUpTest : public testing::Test { 395c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 396c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual ~NonFatalFailureInSetUpTest() { 397c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Deinit(); 398c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 399c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 400c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 401c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 4 failures)\n"); 402c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected failure #1, in SetUp()."; 403c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 404c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 405c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 406c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #3, in TearDown()."; 407c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 408c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 409c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void Deinit() { 410c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #4, in the test fixture d'tor."; 411c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 412c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 413c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 414c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(NonFatalFailureInSetUpTest, FailureInSetUp) { 415c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #2, in the test function."; 416c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 417c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 418c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests fatal failures in SetUp(). 419c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass FatalFailureInSetUpTest : public testing::Test { 420c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 421c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual ~FatalFailureInSetUpTest() { 422c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Deinit(); 423c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 424c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 425c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 426c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 3 failures)\n"); 427c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #1, in SetUp()."; 428c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 429c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 430c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 431c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #2, in TearDown()."; 432c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 433c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 434c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch void Deinit() { 435c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected failure #3, in the test fixture d'tor."; 436c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 437c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 438c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 439c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(FatalFailureInSetUpTest, FailureInSetUp) { 440c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "UNEXPECTED failure in the test function. " 441c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch << "We should never get here, as SetUp() failed."; 442c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 443c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 444731df977c0511bca2206b5f333555b1205ff1f43Iain MerrickTEST(AddFailureAtTest, MessageContainsSpecifiedFileAndLineNumber) { 445731df977c0511bca2206b5f333555b1205ff1f43Iain Merrick ADD_FAILURE_AT("foo.cc", 42) << "Expected failure in foo.cc"; 446c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 447c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 448c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_IS_THREADSAFE 449c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 450c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A unary function that may die. 451c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid DieIf(bool should_die) { 452c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_CHECK_(!should_die) << " - death inside DieIf()."; 453c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 454c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 455c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests running death tests in a multi-threaded context. 456c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 457c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Used for coordination between the main and the spawn thread. 458c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstruct SpawnThreadNotifications { 459c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SpawnThreadNotifications() {} 460c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 461c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Notification spawn_thread_started; 462c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch Notification spawn_thread_ok_to_terminate; 463c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 464c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 465c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_DISALLOW_COPY_AND_ASSIGN_(SpawnThreadNotifications); 466c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 467c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 468c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The function to be executed in the thread spawn by the 469c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// MultipleThreads test (below). 470c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochstatic void ThreadRoutine(SpawnThreadNotifications* notifications) { 471c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Signals the main thread that this thread has started. 472c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch notifications->spawn_thread_started.Notify(); 473c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 474c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Waits for permission to finish from the main thread. 475c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch notifications->spawn_thread_ok_to_terminate.WaitForNotification(); 476c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 477c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 478c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This is a death-test test, but it's not named with a DeathTest 479c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// suffix. It starts threads which might interfere with later 480c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// death tests, so it must run after all other death tests. 481c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass DeathTestAndMultiThreadsTest : public testing::Test { 482c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 483c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Starts a thread and waits for it to begin. 484c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 485c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch thread_.reset(new ThreadWithParam<SpawnThreadNotifications*>( 486c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &ThreadRoutine, ¬ifications_, NULL)); 487c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch notifications_.spawn_thread_started.WaitForNotification(); 488c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 489c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Tells the thread to finish, and reaps it. 490c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Depending on the version of the thread library in use, 491c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // a manager thread might still be left running that will interfere 492c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // with later death tests. This is unfortunate, but this class 493c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // cleans up after itself as best it can. 494c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 495c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch notifications_.spawn_thread_ok_to_terminate.Notify(); 496c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 497c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 498c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch private: 499c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch SpawnThreadNotifications notifications_; 500c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch scoped_ptr<ThreadWithParam<SpawnThreadNotifications*> > thread_; 501c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 502c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 503c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_IS_THREADSAFE 504c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 505c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The MixedUpTestCaseTest test case verifies that Google Test will fail a 506c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// test if it uses a different fixture class than what other tests in 507c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the same test case use. It deliberately contains two fixture 508c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// classes with the same name but defined in different namespaces. 509c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 510c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The MixedUpTestCaseWithSameTestNameTest test case verifies that 511c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// when the user defines two tests with the same test case name AND 512c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// same test name (but in different namespaces), the second test will 513c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// fail. 514c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 515c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace foo { 516c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 517c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass MixedUpTestCaseTest : public testing::Test { 518c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 519c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 520c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {} 521c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {} 522c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 523c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass MixedUpTestCaseWithSameTestNameTest : public testing::Test { 524c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 525c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 526c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseWithSameTestNameTest, 527c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TheSecondTestWithThisNameShouldFail) {} 528c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 529c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace foo 530c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 531c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochnamespace bar { 532c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 533c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass MixedUpTestCaseTest : public testing::Test { 534c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 535c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 536c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The following two tests are expected to fail. We rely on the 537c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// golden file to check that Google Test generates the right error message. 538c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseTest, ThisShouldFail) {} 539c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {} 540c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 541c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass MixedUpTestCaseWithSameTestNameTest : public testing::Test { 542c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 543c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 544c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Expected to fail. We rely on the golden file to check that Google Test 545c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates the right error message. 546c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(MixedUpTestCaseWithSameTestNameTest, 547c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TheSecondTestWithThisNameShouldFail) {} 548c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 549c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} // namespace bar 550c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 551c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The following two test cases verify that Google Test catches the user 552c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// error of mixing TEST and TEST_F in the same test case. The first 553c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// test case checks the scenario where TEST_F appears before TEST, and 554c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the second one checks where TEST appears before TEST_F. 555c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 556c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass TEST_F_before_TEST_in_same_test_case : public testing::Test { 557c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 558c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 559c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(TEST_F_before_TEST_in_same_test_case, DefinedUsingTEST_F) {} 560c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 561c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Expected to fail. We rely on the golden file to check that Google Test 562c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates the right error message. 563c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TEST_F_before_TEST_in_same_test_case, DefinedUsingTESTAndShouldFail) {} 564c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 565c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass TEST_before_TEST_F_in_same_test_case : public testing::Test { 566c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 567c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 568c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST) {} 569c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 570c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Expected to fail. We rely on the golden file to check that Google Test 571c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// generates the right error message. 572c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(TEST_before_TEST_F_in_same_test_case, DefinedUsingTEST_FAndShouldFail) { 573c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 574c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 575c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Used for testing EXPECT_NONFATAL_FAILURE() and EXPECT_FATAL_FAILURE(). 576c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochint global_integer = 0; 577c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 578c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() can reference global variables. 579c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, CanReferenceGlobalVariables) { 580c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch global_integer = 0; 581c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 582c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(1, global_integer) << "Expected non-fatal failure."; 583c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected non-fatal failure."); 584c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 585c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 586c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() can reference local variables 587c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// (static or not). 588c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, CanReferenceLocalVariables) { 589c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch int m = 0; 590c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static int n; 591c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 1; 592c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 593c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(m, n) << "Expected non-fatal failure."; 594c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected non-fatal failure."); 595c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 596c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 597c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() succeeds when there is exactly 598c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// one non-fatal failure and no fatal failure. 599c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, SucceedsWhenThereIsOneNonfatalFailure) { 600c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 601c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure."; 602c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected non-fatal failure."); 603c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 604c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 605c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() fails when there is no 606c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// non-fatal failure. 607c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, FailsWhenThereIsNoNonfatalFailure) { 608c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 609c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 610c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 611c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 612c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 613c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() fails when there are two 614c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// non-fatal failures. 615c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, FailsWhenThereAreTwoNonfatalFailures) { 616c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 617c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 618c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure 1."; 619c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure 2."; 620c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 621c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 622c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 623c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() fails when there is one fatal 624c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// failure. 625c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, FailsWhenThereIsOneFatalFailure) { 626c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 627c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 628c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected fatal failure."; 629c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 630c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 631c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 632c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being 633c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// tested returns. 634c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, FailsWhenStatementReturns) { 635c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 636c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 637c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 638c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 639c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 640c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 641c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_EXCEPTIONS 642c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 643c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_NONFATAL_FAILURE() fails when the statement being 644c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// tested throws. 645c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectNonfatalFailureTest, FailsWhenStatementThrows) { 646c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 647c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch try { 648c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE({ 649c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch throw 0; 650c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 651c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } catch(int) { // NOLINT 652c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 653c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 654c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 655c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_EXCEPTIONS 656c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 657c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() can reference global variables. 658c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, CanReferenceGlobalVariables) { 659c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch global_integer = 0; 660c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 661c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_EQ(1, global_integer) << "Expected fatal failure."; 662c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected fatal failure."); 663c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 664c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 665c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() can reference local static 666c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// variables. 667c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, CanReferenceLocalStaticVariables) { 668c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static int n; 669c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch n = 1; 670c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 671c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ASSERT_EQ(0, n) << "Expected fatal failure."; 672c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected fatal failure."); 673c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 674c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 675c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() succeeds when there is exactly 676c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// one fatal failure and no non-fatal failure. 677c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, SucceedsWhenThereIsOneFatalFailure) { 678c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 679c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected fatal failure."; 680c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, "Expected fatal failure."); 681c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 682c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 683c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() fails when there is no fatal 684c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// failure. 685c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, FailsWhenThereIsNoFatalFailure) { 686c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 687c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 688c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 689c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 690c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 691c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// A helper for generating a fatal failure. 692c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochvoid FatalFailure() { 693c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected fatal failure."; 694c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 695c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 696c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() fails when there are two 697c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// fatal failures. 698c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, FailsWhenThereAreTwoFatalFailures) { 699c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 700c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 701c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FatalFailure(); 702c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FatalFailure(); 703c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 704c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 705c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 706c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() fails when there is one non-fatal 707c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// failure. 708c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, FailsWhenThereIsOneNonfatalFailure) { 709c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 710c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 711c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure."; 712c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 713c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 714c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 715c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() fails when the statement being 716c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// tested returns. 717c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, FailsWhenStatementReturns) { 718c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 719c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 720c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return; 721c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 722c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 723c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 724c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_EXCEPTIONS 725c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 726c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that EXPECT_FATAL_FAILURE() fails when the statement being 727c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// tested throws. 728c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ExpectFatalFailureTest, FailsWhenStatementThrows) { 729c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting a failure)\n"); 730c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch try { 731c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE({ 732c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch throw 0; 733c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }, ""); 734c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } catch(int) { // NOLINT 735c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 736c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 737c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 738c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_EXCEPTIONS 739c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 740c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This #ifdef block tests the output of typed tests. 741c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_TYPED_TEST 742c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 743c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 744c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass TypedTest : public testing::Test { 745c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 746c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 747c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_CASE(TypedTest, testing::Types<int>); 748c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 749c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(TypedTest, Success) { 750c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(0, TypeParam()); 751c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 752c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 753c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(TypedTest, Failure) { 754c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(1, TypeParam()) << "Expected failure"; 755c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 756c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 757c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_TYPED_TEST 758c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 759c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// This #ifdef block tests the output of type-parameterized tests. 760c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_TYPED_TEST_P 761c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 762c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 763c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass TypedTestP : public testing::Test { 764c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 765c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 766c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_CASE_P(TypedTestP); 767c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 768c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_P(TypedTestP, Success) { 769c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(0U, TypeParam()); 770c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 771c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 772c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_P(TypedTestP, Failure) { 773c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(1U, TypeParam()) << "Expected failure"; 774c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 775c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 776c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochREGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure); 777c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 778c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef testing::Types<unsigned char, unsigned int> UnsignedTypes; 779c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochINSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes); 780c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 781c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_TYPED_TEST_P 782c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 783c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_DEATH_TEST 784c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 785c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// We rely on the golden file to verify that tests whose test case 786c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// name ends with DeathTest are run first. 787c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 788c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST(ADeathTest, ShouldRunFirst) { 789c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 790c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 791ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# if GTEST_HAS_TYPED_TEST 792c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 793c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// We rely on the golden file to verify that typed tests whose test 794c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// case name ends with DeathTest are run first. 795c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 796c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 797c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ATypedDeathTest : public testing::Test { 798c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 799c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 800c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef testing::Types<int, double> NumericTypes; 801c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_CASE(ATypedDeathTest, NumericTypes); 802c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 803c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST(ATypedDeathTest, ShouldRunFirst) { 804c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 805c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 806ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# endif // GTEST_HAS_TYPED_TEST 807c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 808ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# if GTEST_HAS_TYPED_TEST_P 809c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 810c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 811c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// We rely on the golden file to verify that type-parameterized tests 812c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// whose test case name ends with DeathTest are run first. 813c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 814c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate <typename T> 815c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ATypeParamDeathTest : public testing::Test { 816c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 817c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 818c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_CASE_P(ATypeParamDeathTest); 819c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 820c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) { 821c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 822c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 823c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochREGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst); 824c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 825c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochINSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes); 826c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 827ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# endif // GTEST_HAS_TYPED_TEST_P 828c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 829c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_DEATH_TEST 830c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 831c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests various failure conditions of 832c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// EXPECT_{,NON}FATAL_FAILURE{,_ON_ALL_THREADS}. 833c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ExpectFailureTest : public testing::Test { 834c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: // Must be public and not protected due to a bug in g++ 3.4.2. 835c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch enum FailureMode { 836c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FATAL_FAILURE, 837c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch NONFATAL_FAILURE 838c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch }; 839c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static void AddFailure(FailureMode failure) { 840c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (failure == FATAL_FAILURE) { 841c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected fatal failure."; 842c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } else { 843c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure."; 844c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 845c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 846c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 847c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 848c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureTest, ExpectFatalFailure) { 849c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected fatal failure, but succeeds. 850c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 851c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(SUCCEED(), "Expected fatal failure."); 852c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected fatal failure, but got a non-fatal failure. 853c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 854c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Expected non-fatal " 855c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "failure."); 856c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Wrong message. 857c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 858c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(AddFailure(FATAL_FAILURE), "Some other fatal failure " 859c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "expected."); 860c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 861c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 862c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureTest, ExpectNonFatalFailure) { 863c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected non-fatal failure, but succeeds. 864c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 865c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE(SUCCEED(), "Expected non-fatal failure."); 866c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected non-fatal failure, but got a fatal failure. 867c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 868c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE(AddFailure(FATAL_FAILURE), "Expected fatal failure."); 869c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Wrong message. 870c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 871c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE(AddFailure(NONFATAL_FAILURE), "Some other non-fatal " 872c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "failure."); 873c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 874c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 875c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_IS_THREADSAFE 876c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 877c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass ExpectFailureWithThreadsTest : public ExpectFailureTest { 878c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch protected: 879c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch static void AddFailureInOtherThread(FailureMode failure) { 880c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ThreadWithParam<FailureMode> thread(&AddFailure, failure, NULL); 881c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch thread.Join(); 882c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 883c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 884c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 885c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureWithThreadsTest, ExpectFatalFailure) { 886c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We only intercept the current thread. 887c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 2 failures)\n"); 888c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE(AddFailureInOtherThread(FATAL_FAILURE), 889c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected fatal failure."); 890c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 891c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 892c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureWithThreadsTest, ExpectNonFatalFailure) { 893c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We only intercept the current thread. 894c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 2 failures)\n"); 895c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE(AddFailureInOtherThread(NONFATAL_FAILURE), 896c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected non-fatal failure."); 897c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 898c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 899c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtypedef ExpectFailureWithThreadsTest ScopedFakeTestPartResultReporterTest; 900c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 901c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Tests that the ScopedFakeTestPartResultReporter only catches failures from 902c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// the current thread if it is instantiated with INTERCEPT_ONLY_CURRENT_THREAD. 903c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ScopedFakeTestPartResultReporterTest, InterceptOnlyCurrentThread) { 904c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 2 failures)\n"); 905c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch TestPartResultArray results; 906c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch { 907c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ScopedFakeTestPartResultReporter reporter( 908c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ScopedFakeTestPartResultReporter::INTERCEPT_ONLY_CURRENT_THREAD, 909c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch &results); 910c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AddFailureInOtherThread(FATAL_FAILURE); 911c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch AddFailureInOtherThread(NONFATAL_FAILURE); 912c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 913c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The two failures should not have been intercepted. 914c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_EQ(0, results.size()) << "This shouldn't fail."; 915c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 916c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 917c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_IS_THREADSAFE 918c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 919c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureTest, ExpectFatalFailureOnAllThreads) { 920c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected fatal failure, but succeeds. 921c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 922c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected fatal failure."); 923c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected fatal failure, but got a non-fatal failure. 924c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 925c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE), 926c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected non-fatal failure."); 927c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Wrong message. 928c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 929c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_FATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE), 930c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Some other fatal failure expected."); 931c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 932c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 933c407dc5cd9bdc5668497f21b26b09d988ab439deBen MurdochTEST_F(ExpectFailureTest, ExpectNonFatalFailureOnAllThreads) { 934c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected non-fatal failure, but succeeds. 935c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 936c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(SUCCEED(), "Expected non-fatal " 937c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "failure."); 938c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Expected non-fatal failure, but got a fatal failure. 939c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 940c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(FATAL_FAILURE), 941c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Expected fatal failure."); 942c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Wrong message. 943c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("(expecting 1 failure)\n"); 944c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(AddFailure(NONFATAL_FAILURE), 945c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch "Some other non-fatal failure."); 946c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 947c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 948c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 949c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Two test environments for testing testing::AddGlobalTestEnvironment(). 950c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 951c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass FooEnvironment : public testing::Environment { 952c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 953c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 954c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("%s", "FooEnvironment::SetUp() called.\n"); 955c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 956c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 957c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 958c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("%s", "FooEnvironment::TearDown() called.\n"); 959c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch FAIL() << "Expected fatal failure."; 960c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 961c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 962c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 963c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochclass BarEnvironment : public testing::Environment { 964c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch public: 965c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void SetUp() { 966c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("%s", "BarEnvironment::SetUp() called.\n"); 967c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 968c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 969c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch virtual void TearDown() { 970c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch printf("%s", "BarEnvironment::TearDown() called.\n"); 971c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch ADD_FAILURE() << "Expected non-fatal failure."; 972c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 973c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch}; 974c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 9753345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrickbool GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = false; 976c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 977c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The main function. 978c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 979c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// The idea is to use Google Test to run all the tests we have defined (some 980c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// of them are intended to fail), and then compare the test results 981c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// with the "golden" file. 982c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochint main(int argc, char **argv) { 983c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch testing::GTEST_FLAG(print_time) = false; 984c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 985c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We just run the tests, knowing some of them are intended to fail. 986c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // We will use a separate Python script to compare the output of 987c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // this program with the golden file. 988c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 989c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // It's hard to test InitGoogleTest() directly, as it has many 990c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // global side effects. The following line serves as a sanity test 991c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // for it. 992c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch testing::InitGoogleTest(&argc, argv); 993c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (argc >= 2 && 994c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch String(argv[1]) == "--gtest_internal_skip_environment_and_ad_hoc_tests") 995c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests) = true; 996c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 997c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#if GTEST_HAS_DEATH_TEST 998c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (testing::internal::GTEST_FLAG(internal_run_death_test) != "") { 999c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Skip the usual output capturing if we're running as the child 1000c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // process of an threadsafe-style death test. 1001ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# if GTEST_OS_WINDOWS 1002c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch posix::FReopen("nul:", "w", stdout); 1003ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# else 1004c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch posix::FReopen("/dev/null", "w", stdout); 1005ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen# endif // GTEST_OS_WINDOWS 1006c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return RUN_ALL_TESTS(); 1007c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch } 1008c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch#endif // GTEST_HAS_DEATH_TEST 1009c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1010c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch if (GTEST_FLAG(internal_skip_environment_and_ad_hoc_tests)) 1011c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return RUN_ALL_TESTS(); 1012c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1013c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // Registers two global test environments. 1014c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // The golden file verifies that they are set up in the order they 1015c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch // are registered, and torn down in the reverse order. 1016c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch testing::AddGlobalTestEnvironment(new FooEnvironment); 1017c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch testing::AddGlobalTestEnvironment(new BarEnvironment); 1018c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 1019c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch return RunAllTests(); 1020c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 1021