"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/include/gtest/gtest-spi.h" 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-spi.h  (googletest-release-1.11.0)	:	gtest-spi.h  (googletest-release-1.12.0)
skipping to change at line 30		skipping to change at line 30
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR		// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT		// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,		// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// 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.
//
// Utilities for testing Google Test itself and code that uses Google Test		// Utilities for testing Google Test itself and code that uses Google Test
// (e.g. frameworks built on top of Google Test).		// (e.g. frameworks built on top of Google Test).
// GOOGLETEST_CM0004 DO NOT DELETE
#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_		#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_		#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
#include "gtest/gtest.h"		#include "gtest/gtest.h"
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \		GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)		/* class A needs to have dll-interface to be used by clients of class B */)
namespace testing {		namespace testing {
skipping to change at line 91		skipping to change at line 88
// interface.		// interface.
void ReportTestPartResult(const TestPartResult& result) override;		void ReportTestPartResult(const TestPartResult& result) override;
private:		private:
void Init();		void Init();
const InterceptMode intercept_mode_;		const InterceptMode intercept_mode_;
TestPartResultReporterInterface* old_reporter_;		TestPartResultReporterInterface* old_reporter_;
TestPartResultArray* const result_;		TestPartResultArray* const result_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);		ScopedFakeTestPartResultReporter(const ScopedFakeTestPartResultReporter&) =
		delete;
		ScopedFakeTestPartResultReporter& operator=(
		const ScopedFakeTestPartResultReporter&) = delete;
};		};
namespace internal {		namespace internal {
// A helper class for implementing EXPECT_FATAL_FAILURE() and		// A helper class for implementing EXPECT_FATAL_FAILURE() and
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given		// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given
// TestPartResultArray contains exactly one failure that has the given		// TestPartResultArray contains exactly one failure that has the given
// type and contains the given substring. If that's not the case, a		// type and contains the given substring. If that's not the case, a
// non-fatal failure will be generated.		// non-fatal failure will be generated.
class GTEST_API_ SingleFailureChecker {		class GTEST_API_ SingleFailureChecker {
public:		public:
// The constructor remembers the arguments.		// The constructor remembers the arguments.
SingleFailureChecker(const TestPartResultArray* results,		SingleFailureChecker(const TestPartResultArray* results,
TestPartResult::Type type, const std::string& substr);		TestPartResult::Type type, const std::string& substr);
~SingleFailureChecker();		~SingleFailureChecker();
private:		private:
const TestPartResultArray* const results_;		const TestPartResultArray* const results_;
const TestPartResult::Type type_;		const TestPartResult::Type type_;
const std::string substr_;		const std::string substr_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);		SingleFailureChecker(const SingleFailureChecker&) = delete;
		SingleFailureChecker& operator=(const SingleFailureChecker&) = delete;
};		};
} // namespace internal		} // namespace internal
} // namespace testing		} // namespace testing
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251		GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
// A set of macros for testing Google Test assertions or code that's expected		// A set of macros for testing Google Test assertions or code that's expected
// to generate Google Test fatal failures. It verifies that the given		// to generate Google Test fatal failures (e.g. a failure from an ASSERT_EQ, but
		// not a non-fatal failure, as from EXPECT_EQ). It verifies that the given
// statement will cause exactly one fatal Google Test failure with 'substr'		// statement will cause exactly one fatal Google Test failure with 'substr'
// being part of the failure message.		// being part of the failure message.
//		//
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only		// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
// affects and considers failures generated in the current thread and		// affects and considers failures generated in the current thread and
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.		// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//		//
// The verification of the assertion is done correctly even when the statement		// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.		// throws an exception or aborts the current function.
//		//
skipping to change at line 144		skipping to change at line 147
// - 'statement' cannot reference local non-static variables or		// - 'statement' cannot reference local non-static variables or
// non-static members of the current object.		// non-static members of the current object.
// - 'statement' cannot return a value.		// - 'statement' cannot return a value.
// - You cannot stream a failure message to this macro.		// - You cannot stream a failure message to this macro.
//		//
// Note that even though the implementations of the following two		// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common		// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor		// helper macro, due to some peculiarity in how the preprocessor
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in		// works. The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.		// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \		#define EXPECT_FATAL_FAILURE(statement, substr) \
do { \		do { \
class GTestExpectFatalFailureHelper {\		class GTestExpectFatalFailureHelper { \
public:\		public: \
static void Execute() { statement; }\		static void Execute() { statement; } \
};\		}; \
::testing::TestPartResultArray gtest_failures;\		::testing::TestPartResultArray gtest_failures; \
::testing::internal::SingleFailureChecker gtest_checker(\		::testing::internal::SingleFailureChecker gtest_checker( \
&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\		&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \
{\		{ \
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\		::testing::ScopedFakeTestPartResultReporter gtest_reporter( \
::testing::ScopedFakeTestPartResultReporter:: \		::testing::ScopedFakeTestPartResultReporter:: \
INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\		INTERCEPT_ONLY_CURRENT_THREAD, \
GTestExpectFatalFailureHelper::Execute();\		&gtest_failures); \
}\		GTestExpectFatalFailureHelper::Execute(); \
		} \
} while (::testing::internal::AlwaysFalse())		} while (::testing::internal::AlwaysFalse())
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \		#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
do { \		do { \
class GTestExpectFatalFailureHelper {\		class GTestExpectFatalFailureHelper { \
public:\		public: \
static void Execute() { statement; }\		static void Execute() { statement; } \
};\		}; \
::testing::TestPartResultArray gtest_failures;\		::testing::TestPartResultArray gtest_failures; \
::testing::internal::SingleFailureChecker gtest_checker(\		::testing::internal::SingleFailureChecker gtest_checker( \
&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\		&gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \
{\		{ \
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\		::testing::ScopedFakeTestPartResultReporter gtest_reporter( \
::testing::ScopedFakeTestPartResultReporter:: \		::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
INTERCEPT_ALL_THREADS, &gtest_failures);\		&gtest_failures); \
GTestExpectFatalFailureHelper::Execute();\		GTestExpectFatalFailureHelper::Execute(); \
}\		} \
} while (::testing::internal::AlwaysFalse())		} while (::testing::internal::AlwaysFalse())
// A macro for testing Google Test assertions or code that's expected to		// A macro for testing Google Test assertions or code that's expected to
// generate Google Test non-fatal failures. It asserts that the given		// generate Google Test non-fatal failures (e.g. a failure from an EXPECT_EQ,
// statement will cause exactly one non-fatal Google Test failure with 'substr'		// but not from an ASSERT_EQ). It asserts that the given statement will cause
// being part of the failure message.		// exactly one non-fatal Google Test failure with 'substr' being part of the
		// failure message.
//		//
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only		// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
// affects and considers failures generated in the current thread and		// affects and considers failures generated in the current thread and
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.		// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
//		//
// 'statement' is allowed to reference local variables and members of		// 'statement' is allowed to reference local variables and members of
// the current object.		// the current object.
//		//
// The verification of the assertion is done correctly even when the statement		// The verification of the assertion is done correctly even when the statement
// throws an exception or aborts the current function.		// throws an exception or aborts the current function.
skipping to change at line 210		skipping to change at line 215
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that		// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
// expands to code containing an unprotected comma. The		// expands to code containing an unprotected comma. The
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc		// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
// catches that.		// catches that.
//		//
// For the same reason, we have to write		// For the same reason, we have to write
// if (::testing::internal::AlwaysTrue()) { statement; }		// if (::testing::internal::AlwaysTrue()) { statement; }
// instead of		// instead of
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)		// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
// to avoid an MSVC warning on unreachable code.		// to avoid an MSVC warning on unreachable code.
#define EXPECT_NONFATAL_FAILURE(statement, substr) \		#define EXPECT_NONFATAL_FAILURE(statement, substr) \
do {\		do { \
::testing::TestPartResultArray gtest_failures;\		::testing::TestPartResultArray gtest_failures; \
::testing::internal::SingleFailureChecker gtest_checker(\		::testing::internal::SingleFailureChecker gtest_checker( \
&gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \		&gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
(substr));\		(substr)); \
{\		{ \
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\		::testing::ScopedFakeTestPartResultReporter gtest_reporter( \
::testing::ScopedFakeTestPartResultReporter:: \		::testing::ScopedFakeTestPartResultReporter:: \
INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\		INTERCEPT_ONLY_CURRENT_THREAD, \
if (::testing::internal::AlwaysTrue()) { statement; }\		&gtest_failures); \
}\		if (::testing::internal::AlwaysTrue()) { \
		statement; \
		} \
		} \
} while (::testing::internal::AlwaysFalse())		} while (::testing::internal::AlwaysFalse())
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \		#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
do {\		do { \
::testing::TestPartResultArray gtest_failures;\		::testing::TestPartResultArray gtest_failures; \
::testing::internal::SingleFailureChecker gtest_checker(\		::testing::internal::SingleFailureChecker gtest_checker( \
&gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \		&gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
(substr));\		(substr)); \
{\		{ \
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\		::testing::ScopedFakeTestPartResultReporter gtest_reporter( \
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \		::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
&gtest_failures);\		&gtest_failures); \
if (::testing::internal::AlwaysTrue()) { statement; }\		if (::testing::internal::AlwaysTrue()) { \
}\		statement; \
		} \
		} \
} while (::testing::internal::AlwaysFalse())		} while (::testing::internal::AlwaysFalse())
#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_		#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
End of changes. 13 change blocks.
61 lines changed or deleted		71 lines changed or added

---