1// Copyright 2007, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29// 30// Author: wan@google.com (Zhanyong Wan) 31// 32// Tests using global test environments. 33 34#include <stdlib.h> 35#include <stdio.h> 36#include "gtest/gtest.h" 37 38#define GTEST_IMPLEMENTATION_ 1 // Required for the next #include. 39#include "src/gtest-internal-inl.h" 40#undef GTEST_IMPLEMENTATION_ 41 42namespace testing { 43GTEST_DECLARE_string_(filter); 44} 45 46namespace { 47 48enum FailureType { 49 NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE 50}; 51 52// For testing using global test environments. 53class MyEnvironment : public testing::Environment { 54 public: 55 MyEnvironment() { Reset(); } 56 57 // Depending on the value of failure_in_set_up_, SetUp() will 58 // generate a non-fatal failure, generate a fatal failure, or 59 // succeed. 60 virtual void SetUp() { 61 set_up_was_run_ = true; 62 63 switch (failure_in_set_up_) { 64 case NON_FATAL_FAILURE: 65 ADD_FAILURE() << "Expected non-fatal failure in global set-up."; 66 break; 67 case FATAL_FAILURE: 68 FAIL() << "Expected fatal failure in global set-up."; 69 break; 70 default: 71 break; 72 } 73 } 74 75 // Generates a non-fatal failure. 76 virtual void TearDown() { 77 tear_down_was_run_ = true; 78 ADD_FAILURE() << "Expected non-fatal failure in global tear-down."; 79 } 80 81 // Resets the state of the environment s.t. it can be reused. 82 void Reset() { 83 failure_in_set_up_ = NO_FAILURE; 84 set_up_was_run_ = false; 85 tear_down_was_run_ = false; 86 } 87 88 // We call this function to set the type of failure SetUp() should 89 // generate. 90 void set_failure_in_set_up(FailureType type) { 91 failure_in_set_up_ = type; 92 } 93 94 // Was SetUp() run? 95 bool set_up_was_run() const { return set_up_was_run_; } 96 97 // Was TearDown() run? 98 bool tear_down_was_run() const { return tear_down_was_run_; } 99 private: 100 FailureType failure_in_set_up_; 101 bool set_up_was_run_; 102 bool tear_down_was_run_; 103}; 104 105// Was the TEST run? 106bool test_was_run; 107 108// The sole purpose of this TEST is to enable us to check whether it 109// was run. 110TEST(FooTest, Bar) { 111 test_was_run = true; 112} 113 114// Prints the message and aborts the program if condition is false. 115void Check(bool condition, const char* msg) { 116 if (!condition) { 117 printf("FAILED: %s\n", msg); 118 testing::internal::posix::Abort(); 119 } 120} 121 122// Runs the tests. Return true iff successful. 123// 124// The 'failure' parameter specifies the type of failure that should 125// be generated by the global set-up. 126int RunAllTests(MyEnvironment* env, FailureType failure) { 127 env->Reset(); 128 env->set_failure_in_set_up(failure); 129 test_was_run = false; 130 testing::internal::GetUnitTestImpl()->ClearAdHocTestResult(); 131 return RUN_ALL_TESTS(); 132} 133 134} // namespace 135 136int main(int argc, char **argv) { 137 testing::InitGoogleTest(&argc, argv); 138 139 // Registers a global test environment, and verifies that the 140 // registration function returns its argument. 141 MyEnvironment* const env = new MyEnvironment; 142 Check(testing::AddGlobalTestEnvironment(env) == env, 143 "AddGlobalTestEnvironment() should return its argument."); 144 145 // Verifies that RUN_ALL_TESTS() runs the tests when the global 146 // set-up is successful. 147 Check(RunAllTests(env, NO_FAILURE) != 0, 148 "RUN_ALL_TESTS() should return non-zero, as the global tear-down " 149 "should generate a failure."); 150 Check(test_was_run, 151 "The tests should run, as the global set-up should generate no " 152 "failure"); 153 Check(env->tear_down_was_run(), 154 "The global tear-down should run, as the global set-up was run."); 155 156 // Verifies that RUN_ALL_TESTS() runs the tests when the global 157 // set-up generates no fatal failure. 158 Check(RunAllTests(env, NON_FATAL_FAILURE) != 0, 159 "RUN_ALL_TESTS() should return non-zero, as both the global set-up " 160 "and the global tear-down should generate a non-fatal failure."); 161 Check(test_was_run, 162 "The tests should run, as the global set-up should generate no " 163 "fatal failure."); 164 Check(env->tear_down_was_run(), 165 "The global tear-down should run, as the global set-up was run."); 166 167 // Verifies that RUN_ALL_TESTS() runs no test when the global set-up 168 // generates a fatal failure. 169 Check(RunAllTests(env, FATAL_FAILURE) != 0, 170 "RUN_ALL_TESTS() should return non-zero, as the global set-up " 171 "should generate a fatal failure."); 172 Check(!test_was_run, 173 "The tests should not run, as the global set-up should generate " 174 "a fatal failure."); 175 Check(env->tear_down_was_run(), 176 "The global tear-down should run, as the global set-up was run."); 177 178 // Verifies that RUN_ALL_TESTS() doesn't do global set-up or 179 // tear-down when there is no test to run. 180 testing::GTEST_FLAG(filter) = "-*"; 181 Check(RunAllTests(env, NO_FAILURE) == 0, 182 "RUN_ALL_TESTS() should return zero, as there is no test to run."); 183 Check(!env->set_up_was_run(), 184 "The global set-up should not run, as there is no test to run."); 185 Check(!env->tear_down_was_run(), 186 "The global tear-down should not run, " 187 "as the global set-up was not run."); 188 189 printf("PASS\n"); 190 return 0; 191} 192