PageRenderTime 20ms CodeModel.GetById 13ms app.highlight 3ms RepoModel.GetById 1ms app.codeStats 0ms

/firmware/tests/gtest-1.4.0/include/gtest/gtest-spi.h

http://github.com/makerbot/G3Firmware
C Header | 232 lines | 97 code | 20 blank | 115 comment | 6 complexity | 9eaa913d33c336ad97ef5032c115c4b8 MD5 | raw file
  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// Utilities for testing Google Test itself and code that uses Google Test
 33// (e.g. frameworks built on top of Google Test).
 34
 35#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
 36#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
 37
 38#include <gtest/gtest.h>
 39
 40namespace testing {
 41
 42// This helper class can be used to mock out Google Test failure reporting
 43// so that we can test Google Test or code that builds on Google Test.
 44//
 45// An object of this class appends a TestPartResult object to the
 46// TestPartResultArray object given in the constructor whenever a Google Test
 47// failure is reported. It can either intercept only failures that are
 48// generated in the same thread that created this object or it can intercept
 49// all generated failures. The scope of this mock object can be controlled with
 50// the second argument to the two arguments constructor.
 51class ScopedFakeTestPartResultReporter
 52    : public TestPartResultReporterInterface {
 53 public:
 54  // The two possible mocking modes of this object.
 55  enum InterceptMode {
 56    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
 57    INTERCEPT_ALL_THREADS           // Intercepts all failures.
 58  };
 59
 60  // The c'tor sets this object as the test part result reporter used
 61  // by Google Test.  The 'result' parameter specifies where to report the
 62  // results. This reporter will only catch failures generated in the current
 63  // thread. DEPRECATED
 64  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
 65
 66  // Same as above, but you can choose the interception scope of this object.
 67  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
 68                                   TestPartResultArray* result);
 69
 70  // The d'tor restores the previous test part result reporter.
 71  virtual ~ScopedFakeTestPartResultReporter();
 72
 73  // Appends the TestPartResult object to the TestPartResultArray
 74  // received in the constructor.
 75  //
 76  // This method is from the TestPartResultReporterInterface
 77  // interface.
 78  virtual void ReportTestPartResult(const TestPartResult& result);
 79 private:
 80  void Init();
 81
 82  const InterceptMode intercept_mode_;
 83  TestPartResultReporterInterface* old_reporter_;
 84  TestPartResultArray* const result_;
 85
 86  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
 87};
 88
 89namespace internal {
 90
 91// A helper class for implementing EXPECT_FATAL_FAILURE() and
 92// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
 93// TestPartResultArray contains exactly one failure that has the given
 94// type and contains the given substring.  If that's not the case, a
 95// non-fatal failure will be generated.
 96class SingleFailureChecker {
 97 public:
 98  // The constructor remembers the arguments.
 99  SingleFailureChecker(const TestPartResultArray* results,
100                       TestPartResult::Type type,
101                       const char* substr);
102  ~SingleFailureChecker();
103 private:
104  const TestPartResultArray* const results_;
105  const TestPartResult::Type type_;
106  const String substr_;
107
108  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
109};
110
111}  // namespace internal
112
113}  // namespace testing
114
115// A set of macros for testing Google Test assertions or code that's expected
116// to generate Google Test fatal failures.  It verifies that the given
117// statement will cause exactly one fatal Google Test failure with 'substr'
118// being part of the failure message.
119//
120// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
121// affects and considers failures generated in the current thread and
122// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
123//
124// The verification of the assertion is done correctly even when the statement
125// throws an exception or aborts the current function.
126//
127// Known restrictions:
128//   - 'statement' cannot reference local non-static variables or
129//     non-static members of the current object.
130//   - 'statement' cannot return a value.
131//   - You cannot stream a failure message to this macro.
132//
133// Note that even though the implementations of the following two
134// macros are much alike, we cannot refactor them to use a common
135// helper macro, due to some peculiarity in how the preprocessor
136// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
137// gtest_unittest.cc will fail to compile if we do that.
138#define EXPECT_FATAL_FAILURE(statement, substr) \
139  do { \
140    class GTestExpectFatalFailureHelper {\
141     public:\
142      static void Execute() { statement; }\
143    };\
144    ::testing::TestPartResultArray gtest_failures;\
145    ::testing::internal::SingleFailureChecker gtest_checker(\
146        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
147    {\
148      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
149          ::testing::ScopedFakeTestPartResultReporter:: \
150          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
151      GTestExpectFatalFailureHelper::Execute();\
152    }\
153  } while (::testing::internal::AlwaysFalse())
154
155#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
156  do { \
157    class GTestExpectFatalFailureHelper {\
158     public:\
159      static void Execute() { statement; }\
160    };\
161    ::testing::TestPartResultArray gtest_failures;\
162    ::testing::internal::SingleFailureChecker gtest_checker(\
163        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
164    {\
165      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
166          ::testing::ScopedFakeTestPartResultReporter:: \
167          INTERCEPT_ALL_THREADS, &gtest_failures);\
168      GTestExpectFatalFailureHelper::Execute();\
169    }\
170  } while (::testing::internal::AlwaysFalse())
171
172// A macro for testing Google Test assertions or code that's expected to
173// generate Google Test non-fatal failures.  It asserts that the given
174// statement will cause exactly one non-fatal Google Test failure with 'substr'
175// being part of the failure message.
176//
177// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
178// affects and considers failures generated in the current thread and
179// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
180//
181// 'statement' is allowed to reference local variables and members of
182// the current object.
183//
184// The verification of the assertion is done correctly even when the statement
185// throws an exception or aborts the current function.
186//
187// Known restrictions:
188//   - You cannot stream a failure message to this macro.
189//
190// Note that even though the implementations of the following two
191// macros are much alike, we cannot refactor them to use a common
192// helper macro, due to some peculiarity in how the preprocessor
193// works.  If we do that, the code won't compile when the user gives
194// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
195// expands to code containing an unprotected comma.  The
196// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
197// catches that.
198//
199// For the same reason, we have to write
200//   if (::testing::internal::AlwaysTrue()) { statement; }
201// instead of
202//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
203// to avoid an MSVC warning on unreachable code.
204#define EXPECT_NONFATAL_FAILURE(statement, substr) \
205  do {\
206    ::testing::TestPartResultArray gtest_failures;\
207    ::testing::internal::SingleFailureChecker gtest_checker(\
208        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
209        (substr));\
210    {\
211      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
212          ::testing::ScopedFakeTestPartResultReporter:: \
213          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
214      if (::testing::internal::AlwaysTrue()) { statement; }\
215    }\
216  } while (::testing::internal::AlwaysFalse())
217
218#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
219  do {\
220    ::testing::TestPartResultArray gtest_failures;\
221    ::testing::internal::SingleFailureChecker gtest_checker(\
222        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
223        (substr));\
224    {\
225      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
226          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\
227          &gtest_failures);\
228      if (::testing::internal::AlwaysTrue()) { statement; }\
229    }\
230  } while (::testing::internal::AlwaysFalse())
231
232#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_