"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

---