"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/gtest_environment_test.cc" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

gtest_environment_test.cc  (googletest-release-1.11.0):gtest_environment_test.cc  (googletest-release-1.12.0)
skipping to change at line 33 skipping to change at line 33
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Tests using global test environments. // Tests using global test environments.
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
namespace testing {
GTEST_DECLARE_string_(filter);
}
namespace { namespace {
enum FailureType { enum FailureType { NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE };
NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE
};
// For testing using global test environments. // For testing using global test environments.
class MyEnvironment : public testing::Environment { class MyEnvironment : public testing::Environment {
public: public:
MyEnvironment() { Reset(); } MyEnvironment() { Reset(); }
// Depending on the value of failure_in_set_up_, SetUp() will // Depending on the value of failure_in_set_up_, SetUp() will
// generate a non-fatal failure, generate a fatal failure, or // generate a non-fatal failure, generate a fatal failure, or
// succeed. // succeed.
void SetUp() override { void SetUp() override {
skipping to change at line 86 skipping to change at line 81
// Resets the state of the environment s.t. it can be reused. // Resets the state of the environment s.t. it can be reused.
void Reset() { void Reset() {
failure_in_set_up_ = NO_FAILURE; failure_in_set_up_ = NO_FAILURE;
set_up_was_run_ = false; set_up_was_run_ = false;
tear_down_was_run_ = false; tear_down_was_run_ = false;
} }
// We call this function to set the type of failure SetUp() should // We call this function to set the type of failure SetUp() should
// generate. // generate.
void set_failure_in_set_up(FailureType type) { void set_failure_in_set_up(FailureType type) { failure_in_set_up_ = type; }
failure_in_set_up_ = type;
}
// Was SetUp() run? // Was SetUp() run?
bool set_up_was_run() const { return set_up_was_run_; } bool set_up_was_run() const { return set_up_was_run_; }
// Was TearDown() run? // Was TearDown() run?
bool tear_down_was_run() const { return tear_down_was_run_; } bool tear_down_was_run() const { return tear_down_was_run_; }
private: private:
FailureType failure_in_set_up_; FailureType failure_in_set_up_;
bool set_up_was_run_; bool set_up_was_run_;
bool tear_down_was_run_; bool tear_down_was_run_;
}; };
// Was the TEST run? // Was the TEST run?
bool test_was_run; bool test_was_run;
// The sole purpose of this TEST is to enable us to check whether it // The sole purpose of this TEST is to enable us to check whether it
// was run. // was run.
TEST(FooTest, Bar) { TEST(FooTest, Bar) { test_was_run = true; }
test_was_run = true;
}
// Prints the message and aborts the program if condition is false. // Prints the message and aborts the program if condition is false.
void Check(bool condition, const char* msg) { void Check(bool condition, const char* msg) {
if (!condition) { if (!condition) {
printf("FAILED: %s\n", msg); printf("FAILED: %s\n", msg);
testing::internal::posix::Abort(); testing::internal::posix::Abort();
} }
} }
// Runs the tests. Return true if and only if successful. // Runs the tests. Return true if and only if successful.
skipping to change at line 133 skipping to change at line 124
int RunAllTests(MyEnvironment* env, FailureType failure) { int RunAllTests(MyEnvironment* env, FailureType failure) {
env->Reset(); env->Reset();
env->set_failure_in_set_up(failure); env->set_failure_in_set_up(failure);
test_was_run = false; test_was_run = false;
testing::internal::GetUnitTestImpl()->ClearAdHocTestResult(); testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
} // namespace } // namespace
int main(int argc, char **argv) { int main(int argc, char** argv) {
testing::InitGoogleTest(&argc, argv); testing::InitGoogleTest(&argc, argv);
// Registers a global test environment, and verifies that the // Registers a global test environment, and verifies that the
// registration function returns its argument. // registration function returns its argument.
MyEnvironment* const env = new MyEnvironment; MyEnvironment* const env = new MyEnvironment;
Check(testing::AddGlobalTestEnvironment(env) == env, Check(testing::AddGlobalTestEnvironment(env) == env,
"AddGlobalTestEnvironment() should return its argument."); "AddGlobalTestEnvironment() should return its argument.");
// Verifies that RUN_ALL_TESTS() runs the tests when the global // Verifies that RUN_ALL_TESTS() runs the tests when the global
// set-up is successful. // set-up is successful.
skipping to change at line 177 skipping to change at line 168
"RUN_ALL_TESTS() should return non-zero, as the global set-up " "RUN_ALL_TESTS() should return non-zero, as the global set-up "
"should generate a fatal failure."); "should generate a fatal failure.");
Check(!test_was_run, Check(!test_was_run,
"The tests should not run, as the global set-up should generate " "The tests should not run, as the global set-up should generate "
"a fatal failure."); "a fatal failure.");
Check(env->tear_down_was_run(), Check(env->tear_down_was_run(),
"The global tear-down should run, as the global set-up was run."); "The global tear-down should run, as the global set-up was run.");
// Verifies that RUN_ALL_TESTS() doesn't do global set-up or // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
// tear-down when there is no test to run. // tear-down when there is no test to run.
testing::GTEST_FLAG(filter) = "-*"; GTEST_FLAG_SET(filter, "-*");
Check(RunAllTests(env, NO_FAILURE) == 0, Check(RunAllTests(env, NO_FAILURE) == 0,
"RUN_ALL_TESTS() should return zero, as there is no test to run."); "RUN_ALL_TESTS() should return zero, as there is no test to run.");
Check(!env->set_up_was_run(), Check(!env->set_up_was_run(),
"The global set-up should not run, as there is no test to run."); "The global set-up should not run, as there is no test to run.");
Check(!env->tear_down_was_run(), Check(!env->tear_down_was_run(),
"The global tear-down should not run, " "The global tear-down should not run, "
"as the global set-up was not run."); "as the global set-up was not run.");
printf("PASS\n"); printf("PASS\n");
return 0; return 0;
 End of changes. 8 change blocks. 
16 lines changed or deleted 7 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)