On Tue, Nov 6, 2012 at 7:57 PM, Peter Hutterer <peter.hutte...@who-t.net>wrote:
> This header is for self-testing, specifically EXPECT_FATAL_FAILURE > > Signed-off-by: Peter Hutterer <peter.hutte...@who-t.net> > --- > gtest/include/Makefile.am | 2 +- > gtest/include/gtest/gtest-spi.h | 232 > ++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 233 insertions(+), 1 deletion(-) > create mode 100644 gtest/include/gtest/gtest-spi.h > > diff --git a/gtest/include/Makefile.am b/gtest/include/Makefile.am > index 54d3088..6456b01 100644 > --- a/gtest/include/Makefile.am > +++ b/gtest/include/Makefile.am > @@ -22,4 +22,4 @@ > # SOFTWARE. > # > > -nobase_include_HEADERS = gtest/gtest.h > +nobase_include_HEADERS = gtest/gtest.h gtest/gtest-spi.h > diff --git a/gtest/include/gtest/gtest-spi.h > b/gtest/include/gtest/gtest-spi.h > new file mode 100644 > index 0000000..f63fa9a > --- /dev/null > +++ b/gtest/include/gtest/gtest-spi.h > @@ -0,0 +1,232 @@ > +// Copyright 2007, Google Inc. > +// All rights reserved. > +// > +// Redistribution and use in source and binary forms, with or without > +// modification, are permitted provided that the following conditions are > +// met: > +// > +// * Redistributions of source code must retain the above copyright > +// notice, this list of conditions and the following disclaimer. > +// * Redistributions in binary form must reproduce the above > +// copyright notice, this list of conditions and the following disclaimer > +// in the documentation and/or other materials provided with the > +// distribution. > +// * Neither the name of Google Inc. nor the names of its > +// contributors may be used to endorse or promote products derived from > +// this software without specific prior written permission. > +// > +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR > +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT > +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, > +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY > +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE > +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > +// > +// Author: w...@google.com (Zhanyong Wan) > +// > +// Utilities for testing Google Test itself and code that uses Google Test > +// (e.g. frameworks built on top of Google Test). > + > +#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ > +#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ > + > +#include "gtest/gtest.h" > + > +namespace testing { > + > +// This helper class can be used to mock out Google Test failure reporting > +// so that we can test Google Test or code that builds on Google Test. > +// > +// An object of this class appends a TestPartResult object to the > +// TestPartResultArray object given in the constructor whenever a Google > Test > +// failure is reported. It can either intercept only failures that are > +// generated in the same thread that created this object or it can > intercept > +// all generated failures. The scope of this mock object can be > controlled with > +// the second argument to the two arguments constructor. > +class GTEST_API_ ScopedFakeTestPartResultReporter > + : public TestPartResultReporterInterface { > + public: > + // The two possible mocking modes of this object. > + enum InterceptMode { > + INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local > failures. > + INTERCEPT_ALL_THREADS // Intercepts all failures. > + }; > + > + // The c'tor sets this object as the test part result reporter used > + // by Google Test. The 'result' parameter specifies where to report the > + // results. This reporter will only catch failures generated in the > current > + // thread. DEPRECATED > + explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); > + > + // Same as above, but you can choose the interception scope of this > object. > + ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, > + TestPartResultArray* result); > + > + // The d'tor restores the previous test part result reporter. > + virtual ~ScopedFakeTestPartResultReporter(); > + > + // Appends the TestPartResult object to the TestPartResultArray > + // received in the constructor. > + // > + // This method is from the TestPartResultReporterInterface > + // interface. > + virtual void ReportTestPartResult(const TestPartResult& result); > + private: > + void Init(); > + > + const InterceptMode intercept_mode_; > + TestPartResultReporterInterface* old_reporter_; > + TestPartResultArray* const result_; > + > + GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); > +}; > + > +namespace internal { > + > +// A helper class for implementing EXPECT_FATAL_FAILURE() and > +// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given > +// TestPartResultArray contains exactly one failure that has the given > +// type and contains the given substring. If that's not the case, a > +// non-fatal failure will be generated. > +class GTEST_API_ SingleFailureChecker { > + public: > + // The constructor remembers the arguments. > + SingleFailureChecker(const TestPartResultArray* results, > + TestPartResult::Type type, > + const string& substr); > + ~SingleFailureChecker(); > + private: > + const TestPartResultArray* const results_; > + const TestPartResult::Type type_; > + const string substr_; > + > + GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); > +}; > + > +} // namespace internal > + > +} // namespace testing > + > +// 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 > +// statement will cause exactly one fatal Google Test failure with > 'substr' > +// being part of the failure message. > +// > +// There are two different versions of this macro. EXPECT_FATAL_FAILURE > only > +// affects and considers failures generated in the current thread and > +// 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 > +// throws an exception or aborts the current function. > +// > +// Known restrictions: > +// - 'statement' cannot reference local non-static variables or > +// non-static members of the current object. > +// - 'statement' cannot return a value. > +// - You cannot stream a failure message to this macro. > +// > +// Note that even though the implementations of the following two > +// macros are much alike, we cannot refactor them to use a common > +// helper macro, due to some peculiarity in how the preprocessor > +// works. The AcceptsMacroThatExpandsToUnprotectedComma test in > +// gtest_unittest.cc will fail to compile if we do that. > +#define EXPECT_FATAL_FAILURE(statement, substr) \ > + do { \ > + class GTestExpectFatalFailureHelper {\ > + public:\ > + static void Execute() { statement; }\ > + };\ > + ::testing::TestPartResultArray gtest_failures;\ > + ::testing::internal::SingleFailureChecker gtest_checker(\ > + >est_failures, ::testing::TestPartResult::kFatalFailure, > (substr));\ > + {\ > + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ > + ::testing::ScopedFakeTestPartResultReporter:: \ > + INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ > + GTestExpectFatalFailureHelper::Execute();\ > + }\ > + } while (::testing::internal::AlwaysFalse()) > + > +#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ > + do { \ > + class GTestExpectFatalFailureHelper {\ > + public:\ > + static void Execute() { statement; }\ > + };\ > + ::testing::TestPartResultArray gtest_failures;\ > + ::testing::internal::SingleFailureChecker gtest_checker(\ > + >est_failures, ::testing::TestPartResult::kFatalFailure, > (substr));\ > + {\ > + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ > + ::testing::ScopedFakeTestPartResultReporter:: \ > + INTERCEPT_ALL_THREADS, >est_failures);\ > + GTestExpectFatalFailureHelper::Execute();\ > + }\ > + } while (::testing::internal::AlwaysFalse()) > + > +// A macro for testing Google Test assertions or code that's expected to > +// generate Google Test non-fatal failures. It asserts that the given > +// statement will cause 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 > +// affects and considers failures generated in the current thread and > +// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all > threads. > +// > +// 'statement' is allowed to reference local variables and members of > +// the current object. > +// > +// The verification of the assertion is done correctly even when the > statement > +// throws an exception or aborts the current function. > +// > +// Known restrictions: > +// - You cannot stream a failure message to this macro. > +// > +// Note that even though the implementations of the following two > +// macros are much alike, we cannot refactor them to use a common > +// helper macro, due to some peculiarity in how the preprocessor > +// works. If we do that, the code won't compile when the user gives > +// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that > +// expands to code containing an unprotected comma. The > +// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc > +// catches that. > +// > +// For the same reason, we have to write > +// if (::testing::internal::AlwaysTrue()) { statement; } > +// instead of > +// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) > +// to avoid an MSVC warning on unreachable code. > +#define EXPECT_NONFATAL_FAILURE(statement, substr) \ > + do {\ > + ::testing::TestPartResultArray gtest_failures;\ > + ::testing::internal::SingleFailureChecker gtest_checker(\ > + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ > + (substr));\ > + {\ > + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ > + ::testing::ScopedFakeTestPartResultReporter:: \ > + INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ > + if (::testing::internal::AlwaysTrue()) { statement; }\ > + }\ > + } while (::testing::internal::AlwaysFalse()) > + > +#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ > + do {\ > + ::testing::TestPartResultArray gtest_failures;\ > + ::testing::internal::SingleFailureChecker gtest_checker(\ > + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ > + (substr));\ > + {\ > + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ > + > ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ > + >est_failures);\ > + if (::testing::internal::AlwaysTrue()) { statement; }\ > + }\ > + } while (::testing::internal::AlwaysFalse()) > + > +#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ Works for me. Reviewed-by: Chase Douglas <chase.doug...@ubuntu.com>
_______________________________________________ xorg-devel@lists.x.org: X.Org development Archives: http://lists.x.org/archives/xorg-devel Info: http://lists.x.org/mailman/listinfo/xorg-devel