gtest-internal.h
Go to the documentation of this file.
1 // Copyright 2005, 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 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
31 //
32 // The Google C++ Testing Framework (Google Test)
33 //
34 // This header file declares functions and macros used internally by
35 // Google Test. They are subject to change without notice.
36 
37 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
38 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
39 
41 
42 #if GTEST_OS_LINUX
43 # include <stdlib.h>
44 # include <sys/types.h>
45 # include <sys/wait.h>
46 # include <unistd.h>
47 #endif // GTEST_OS_LINUX
48 
49 #if GTEST_HAS_EXCEPTIONS
50 # include <stdexcept>
51 #endif
52 
53 #include <ctype.h>
54 #include <float.h>
55 #include <string.h>
56 #include <iomanip>
57 #include <limits>
58 #include <set>
59 
60 #include "gtest/gtest-message.h"
64 
65 // Due to C++ preprocessor weirdness, we need double indirection to
66 // concatenate two tokens when one of them is __LINE__. Writing
67 //
68 // foo ## __LINE__
69 //
70 // will result in the token foo__LINE__, instead of foo followed by
71 // the current line number. For more details, see
72 // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
73 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
74 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
75 
76 class ProtocolMessage;
77 namespace proto2 { class Message; }
78 
79 namespace testing {
80 
81 // Forward declarations.
82 
83 class AssertionResult; // Result of an assertion.
84 class Message; // Represents a failure message.
85 class Test; // Represents a test.
86 class TestInfo; // Information about a test.
87 class TestPartResult; // Result of a test part.
88 class UnitTest; // A collection of test cases.
89 
90 template <typename T>
91 ::std::string PrintToString(const T& value);
92 
93 namespace internal {
94 
95 struct TraceInfo; // Information about a trace point.
96 class ScopedTrace; // Implements scoped trace.
97 class TestInfoImpl; // Opaque implementation of TestInfo
98 class UnitTestImpl; // Opaque implementation of UnitTest
99 
100 // How many times InitGoogleTest() has been called.
101 GTEST_API_ extern int g_init_gtest_count;
102 
103 // The text used in failure messages to indicate the start of the
104 // stack trace.
105 GTEST_API_ extern const char kStackTraceMarker[];
106 
107 // Two overloaded helpers for checking at compile time whether an
108 // expression is a null pointer literal (i.e. NULL or any 0-valued
109 // compile-time integral constant). Their return values have
110 // different sizes, so we can use sizeof() to test which version is
111 // picked by the compiler. These helpers have no implementations, as
112 // we only need their signatures.
113 //
114 // Given IsNullLiteralHelper(x), the compiler will pick the first
115 // version if x can be implicitly converted to Secret*, and pick the
116 // second version otherwise. Since Secret is a secret and incomplete
117 // type, the only expression a user can write that has type Secret* is
118 // a null pointer literal. Therefore, we know that x is a null
119 // pointer literal if and only if the first version is picked by the
120 // compiler.
121 char IsNullLiteralHelper(Secret* p);
122 char (&IsNullLiteralHelper(...))[2]; // NOLINT
123 
124 // A compile-time bool constant that is true if and only if x is a
125 // null pointer literal (i.e. NULL or any 0-valued compile-time
126 // integral constant).
127 #ifdef GTEST_ELLIPSIS_NEEDS_POD_
128 // We lose support for NULL detection where the compiler doesn't like
129 // passing non-POD classes through ellipsis (...).
130 # define GTEST_IS_NULL_LITERAL_(x) false
131 #else
132 # define GTEST_IS_NULL_LITERAL_(x) \
133  (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
134 #endif // GTEST_ELLIPSIS_NEEDS_POD_
135 
136 // Appends the user-supplied message to the Google-Test-generated message.
138  const std::string& gtest_msg, const Message& user_msg);
139 
140 #if GTEST_HAS_EXCEPTIONS
141 
142 // This exception is thrown by (and only by) a failed Google Test
143 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
144 // are enabled). We derive it from std::runtime_error, which is for
145 // errors presumably detectable only at run time. Since
146 // std::runtime_error inherits from std::exception, many testing
147 // frameworks know how to extract and print the message inside it.
148 class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
149  public:
150  explicit GoogleTestFailureException(const TestPartResult& failure);
151 };
152 
153 #endif // GTEST_HAS_EXCEPTIONS
154 
155 // A helper class for creating scoped traces in user programs.
157  public:
158  // The c'tor pushes the given source file location and message onto
159  // a trace stack maintained by Google Test.
160  ScopedTrace(const char* file, int line, const Message& message);
161 
162  // The d'tor pops the info pushed by the c'tor.
163  //
164  // Note that the d'tor is not virtual in order to be efficient.
165  // Don't inherit from ScopedTrace!
166  ~ScopedTrace();
167 
168  private:
170 } GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its
171  // c'tor and d'tor. Therefore it doesn't
172  // need to be used otherwise.
173 
174 // Constructs and returns the message for an equality assertion
175 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
176 //
177 // The first four parameters are the expressions used in the assertion
178 // and their values, as strings. For example, for ASSERT_EQ(foo, bar)
179 // where foo is 5 and bar is 6, we have:
180 //
181 // expected_expression: "foo"
182 // actual_expression: "bar"
183 // expected_value: "5"
184 // actual_value: "6"
185 //
186 // The ignoring_case parameter is true iff the assertion is a
187 // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will
188 // be inserted into the message.
189 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
190  const char* actual_expression,
191  const std::string& expected_value,
192  const std::string& actual_value,
193  bool ignoring_case);
194 
195 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
197  const AssertionResult& assertion_result,
198  const char* expression_text,
199  const char* actual_predicate_value,
200  const char* expected_predicate_value);
201 
202 // This template class represents an IEEE floating-point number
203 // (either single-precision or double-precision, depending on the
204 // template parameters).
205 //
206 // The purpose of this class is to do more sophisticated number
207 // comparison. (Due to round-off error, etc, it's very unlikely that
208 // two floating-points will be equal exactly. Hence a naive
209 // comparison by the == operation often doesn't work.)
210 //
211 // Format of IEEE floating-point:
212 //
213 // The most-significant bit being the leftmost, an IEEE
214 // floating-point looks like
215 //
216 // sign_bit exponent_bits fraction_bits
217 //
218 // Here, sign_bit is a single bit that designates the sign of the
219 // number.
220 //
221 // For float, there are 8 exponent bits and 23 fraction bits.
222 //
223 // For double, there are 11 exponent bits and 52 fraction bits.
224 //
225 // More details can be found at
226 // http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
227 //
228 // Template parameter:
229 //
230 // RawType: the raw floating-point type (either float or double)
231 template <typename RawType>
233  public:
234  // Defines the unsigned integer type that has the same size as the
235  // floating point number.
236  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
237 
238  // Constants.
239 
240  // # of bits in a number.
241  static const size_t kBitCount = 8*sizeof(RawType);
242 
243  // # of fraction bits in a number.
244  static const size_t kFractionBitCount =
245  std::numeric_limits<RawType>::digits - 1;
246 
247  // # of exponent bits in a number.
248  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
249 
250  // The mask for the sign bit.
251  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
252 
253  // The mask for the fraction bits.
254  static const Bits kFractionBitMask =
255  ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
256 
257  // The mask for the exponent bits.
259 
260  // How many ULP's (Units in the Last Place) we want to tolerate when
261  // comparing two numbers. The larger the value, the more error we
262  // allow. A 0 value means that two numbers must be exactly the same
263  // to be considered equal.
264  //
265  // The maximum error of a single floating-point operation is 0.5
266  // units in the last place. On Intel CPU's, all floating-point
267  // calculations are done with 80-bit precision, while double has 64
268  // bits. Therefore, 4 should be enough for ordinary use.
269  //
270  // See the following article for more details on ULP:
271  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
272  static const size_t kMaxUlps = 4;
273 
274  // Constructs a FloatingPoint from a raw floating-point number.
275  //
276  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
277  // around may change its bits, although the new value is guaranteed
278  // to be also a NAN. Therefore, don't expect this constructor to
279  // preserve the bits in x when x is a NAN.
280  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
281 
282  // Static methods
283 
284  // Reinterprets a bit pattern as a floating-point number.
285  //
286  // This function is needed to test the AlmostEquals() method.
287  static RawType ReinterpretBits(const Bits bits) {
288  FloatingPoint fp(0);
289  fp.u_.bits_ = bits;
290  return fp.u_.value_;
291  }
292 
293  // Returns the floating-point number that represent positive infinity.
294  static RawType Infinity() {
296  }
297 
298  // Returns the maximum representable finite floating-point number.
299  static RawType Max();
300 
301  // Non-static methods
302 
303  // Returns the bits that represents this number.
304  const Bits &bits() const { return u_.bits_; }
305 
306  // Returns the exponent bits of this number.
308 
309  // Returns the fraction bits of this number.
311 
312  // Returns the sign bit of this number.
313  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
314 
315  // Returns true iff this is NAN (not a number).
316  bool is_nan() const {
317  // It's a NAN if the exponent bits are all ones and the fraction
318  // bits are not entirely zeros.
319  return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
320  }
321 
322  // Returns true iff this number is at most kMaxUlps ULP's away from
323  // rhs. In particular, this function:
324  //
325  // - returns false if either number is (or both are) NAN.
326  // - treats really large numbers as almost equal to infinity.
327  // - thinks +0.0 and -0.0 are 0 DLP's apart.
328  bool AlmostEquals(const FloatingPoint& rhs) const {
329  // The IEEE standard says that any comparison operation involving
330  // a NAN must return false.
331  if (is_nan() || rhs.is_nan()) return false;
332 
334  <= kMaxUlps;
335  }
336 
337  private:
338  // The data type used to store the actual floating-point number.
340  RawType value_; // The raw floating-point number.
341  Bits bits_; // The bits that represent the number.
342  };
343 
344  // Converts an integer from the sign-and-magnitude representation to
345  // the biased representation. More precisely, let N be 2 to the
346  // power of (kBitCount - 1), an integer x is represented by the
347  // unsigned number x + N.
348  //
349  // For instance,
350  //
351  // -N + 1 (the most negative number representable using
352  // sign-and-magnitude) is represented by 1;
353  // 0 is represented by N; and
354  // N - 1 (the biggest number representable using
355  // sign-and-magnitude) is represented by 2N - 1.
356  //
357  // Read http://en.wikipedia.org/wiki/Signed_number_representations
358  // for more details on signed number representations.
359  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
360  if (kSignBitMask & sam) {
361  // sam represents a negative number.
362  return ~sam + 1;
363  } else {
364  // sam represents a positive number.
365  return kSignBitMask | sam;
366  }
367  }
368 
369  // Given two numbers in the sign-and-magnitude representation,
370  // returns the distance between them as an unsigned number.
372  const Bits &sam2) {
373  const Bits biased1 = SignAndMagnitudeToBiased(sam1);
374  const Bits biased2 = SignAndMagnitudeToBiased(sam2);
375  return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
376  }
377 
379 };
380 
381 // We cannot use std::numeric_limits<T>::max() as it clashes with the max()
382 // macro defined by <windows.h>.
383 template <>
384 inline float FloatingPoint<float>::Max() { return FLT_MAX; }
385 template <>
386 inline double FloatingPoint<double>::Max() { return DBL_MAX; }
387 
388 // Typedefs the instances of the FloatingPoint template class that we
389 // care to use.
392 
393 // In order to catch the mistake of putting tests that use different
394 // test fixture classes in the same test case, we need to assign
395 // unique IDs to fixture classes and compare them. The TypeId type is
396 // used to hold such IDs. The user should treat TypeId as an opaque
397 // type: the only operation allowed on TypeId values is to compare
398 // them for equality using the == operator.
399 typedef const void* TypeId;
400 
401 template <typename T>
403  public:
404  // dummy_ must not have a const type. Otherwise an overly eager
405  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
406  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
407  static bool dummy_;
408 };
409 
410 template <typename T>
411 bool TypeIdHelper<T>::dummy_ = false;
412 
413 // GetTypeId<T>() returns the ID of type T. Different values will be
414 // returned for different types. Calling the function twice with the
415 // same type argument is guaranteed to return the same ID.
416 template <typename T>
418  // The compiler is required to allocate a different
419  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
420  // the template. Therefore, the address of dummy_ is guaranteed to
421  // be unique.
422  return &(TypeIdHelper<T>::dummy_);
423 }
424 
425 // Returns the type ID of ::testing::Test. Always call this instead
426 // of GetTypeId< ::testing::Test>() to get the type ID of
427 // ::testing::Test, as the latter may give the wrong result due to a
428 // suspected linker bug when compiling Google Test as a Mac OS X
429 // framework.
431 
432 // Defines the abstract factory interface that creates instances
433 // of a Test object.
435  public:
436  virtual ~TestFactoryBase() {}
437 
438  // Creates a test instance to run. The instance is both created and destroyed
439  // within TestInfoImpl::Run()
440  virtual Test* CreateTest() = 0;
441 
442  protected:
444 
445  private:
447 };
448 
449 // This class provides implementation of TeastFactoryBase interface.
450 // It is used in TEST and TEST_F macros.
451 template <class TestClass>
453  public:
454  virtual Test* CreateTest() { return new TestClass; }
455 };
456 
457 #if GTEST_OS_WINDOWS
458 
459 // Predicate-formatters for implementing the HRESULT checking macros
460 // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
461 // We pass a long instead of HRESULT to avoid causing an
462 // include dependency for the HRESULT type.
463 GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
464  long hr); // NOLINT
465 GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
466  long hr); // NOLINT
467 
468 #endif // GTEST_OS_WINDOWS
469 
470 // Types of SetUpTestCase() and TearDownTestCase() functions.
471 typedef void (*SetUpTestCaseFunc)();
472 typedef void (*TearDownTestCaseFunc)();
473 
474 // Creates a new TestInfo object and registers it with Google Test;
475 // returns the created object.
476 //
477 // Arguments:
478 //
479 // test_case_name: name of the test case
480 // name: name of the test
481 // type_param the name of the test's type parameter, or NULL if
482 // this is not a typed or a type-parameterized test.
483 // value_param text representation of the test's value parameter,
484 // or NULL if this is not a type-parameterized test.
485 // fixture_class_id: ID of the test fixture class
486 // set_up_tc: pointer to the function that sets up the test case
487 // tear_down_tc: pointer to the function that tears down the test case
488 // factory: pointer to the factory that creates a test object.
489 // The newly created TestInfo instance will assume
490 // ownership of the factory object.
492  const char* test_case_name,
493  const char* name,
494  const char* type_param,
495  const char* value_param,
496  TypeId fixture_class_id,
497  SetUpTestCaseFunc set_up_tc,
498  TearDownTestCaseFunc tear_down_tc,
499  TestFactoryBase* factory);
500 
501 // If *pstr starts with the given prefix, modifies *pstr to be right
502 // past the prefix and returns true; otherwise leaves *pstr unchanged
503 // and returns false. None of pstr, *pstr, and prefix can be NULL.
504 GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
505 
506 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
507 
508 // State of the definition of a type-parameterized test case.
509 class GTEST_API_ TypedTestCasePState {
510  public:
511  TypedTestCasePState() : registered_(false) {}
512 
513  // Adds the given test name to defined_test_names_ and return true
514  // if the test case hasn't been registered; otherwise aborts the
515  // program.
516  bool AddTestName(const char* file, int line, const char* case_name,
517  const char* test_name) {
518  if (registered_) {
519  fprintf(stderr, "%s Test %s must be defined before "
520  "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
521  FormatFileLocation(file, line).c_str(), test_name, case_name);
522  fflush(stderr);
523  posix::Abort();
524  }
525  defined_test_names_.insert(test_name);
526  return true;
527  }
528 
529  // Verifies that registered_tests match the test names in
530  // defined_test_names_; returns registered_tests if successful, or
531  // aborts the program otherwise.
532  const char* VerifyRegisteredTestNames(
533  const char* file, int line, const char* registered_tests);
534 
535  private:
536  bool registered_;
537  ::std::set<const char*> defined_test_names_;
538 };
539 
540 // Skips to the first non-space char after the first comma in 'str';
541 // returns NULL if no comma is found in 'str'.
542 inline const char* SkipComma(const char* str) {
543  const char* comma = strchr(str, ',');
544  if (comma == NULL) {
545  return NULL;
546  }
547  while (IsSpace(*(++comma))) {}
548  return comma;
549 }
550 
551 // Returns the prefix of 'str' before the first comma in it; returns
552 // the entire string if it contains no comma.
553 inline std::string GetPrefixUntilComma(const char* str) {
554  const char* comma = strchr(str, ',');
555  return comma == NULL ? str : std::string(str, comma);
556 }
557 
558 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
559 // registers a list of type-parameterized tests with Google Test. The
560 // return value is insignificant - we just need to return something
561 // such that we can call this function in a namespace scope.
562 //
563 // Implementation note: The GTEST_TEMPLATE_ macro declares a template
564 // template parameter. It's defined in gtest-type-util.h.
565 template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
566 class TypeParameterizedTest {
567  public:
568  // 'index' is the index of the test in the type list 'Types'
569  // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
570  // Types). Valid values for 'index' are [0, N - 1] where N is the
571  // length of Types.
572  static bool Register(const char* prefix, const char* case_name,
573  const char* test_names, int index) {
574  typedef typename Types::Head Type;
575  typedef Fixture<Type> FixtureClass;
576  typedef typename GTEST_BIND_(TestSel, Type) TestClass;
577 
578  // First, registers the first type-parameterized test in the type
579  // list.
581  (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
582  + StreamableToString(index)).c_str(),
583  GetPrefixUntilComma(test_names).c_str(),
584  GetTypeName<Type>().c_str(),
585  NULL, // No value parameter.
586  GetTypeId<FixtureClass>(),
587  TestClass::SetUpTestCase,
588  TestClass::TearDownTestCase,
589  new TestFactoryImpl<TestClass>);
590 
591  // Next, recurses (at compile time) with the tail of the type list.
592  return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
593  ::Register(prefix, case_name, test_names, index + 1);
594  }
595 };
596 
597 // The base case for the compile time recursion.
598 template <GTEST_TEMPLATE_ Fixture, class TestSel>
599 class TypeParameterizedTest<Fixture, TestSel, Types0> {
600  public:
601  static bool Register(const char* /*prefix*/, const char* /*case_name*/,
602  const char* /*test_names*/, int /*index*/) {
603  return true;
604  }
605 };
606 
607 // TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
608 // registers *all combinations* of 'Tests' and 'Types' with Google
609 // Test. The return value is insignificant - we just need to return
610 // something such that we can call this function in a namespace scope.
611 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
612 class TypeParameterizedTestCase {
613  public:
614  static bool Register(const char* prefix, const char* case_name,
615  const char* test_names) {
616  typedef typename Tests::Head Head;
617 
618  // First, register the first test in 'Test' for each type in 'Types'.
619  TypeParameterizedTest<Fixture, Head, Types>::Register(
620  prefix, case_name, test_names, 0);
621 
622  // Next, recurses (at compile time) with the tail of the test list.
623  return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
624  ::Register(prefix, case_name, SkipComma(test_names));
625  }
626 };
627 
628 // The base case for the compile time recursion.
629 template <GTEST_TEMPLATE_ Fixture, typename Types>
630 class TypeParameterizedTestCase<Fixture, Templates0, Types> {
631  public:
632  static bool Register(const char* /*prefix*/, const char* /*case_name*/,
633  const char* /*test_names*/) {
634  return true;
635  }
636 };
637 
638 #endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
639 
640 // Returns the current OS stack trace as an std::string.
641 //
642 // The maximum number of stack frames to be included is specified by
643 // the gtest_stack_trace_depth flag. The skip_count parameter
644 // specifies the number of top frames to be skipped, which doesn't
645 // count against the number of frames to be included.
646 //
647 // For example, if Foo() calls Bar(), which in turn calls
648 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
649 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
651  UnitTest* unit_test, int skip_count);
652 
653 // Helpers for suppressing warnings on unreachable code or constant
654 // condition.
655 
656 // Always returns true.
657 GTEST_API_ bool AlwaysTrue();
658 
659 // Always returns false.
660 inline bool AlwaysFalse() { return !AlwaysTrue(); }
661 
662 // Helper for suppressing false warning from Clang on a const char*
663 // variable declared in a conditional expression always being NULL in
664 // the else branch.
666  ConstCharPtr(const char* str) : value(str) {}
667  operator bool() const { return true; }
668  const char* value;
669 };
670 
671 // A simple Linear Congruential Generator for generating random
672 // numbers with a uniform distribution. Unlike rand() and srand(), it
673 // doesn't use global state (and therefore can't interfere with user
674 // code). Unlike rand_r(), it's portable. An LCG isn't very random,
675 // but it's good enough for our purposes.
677  public:
678  static const UInt32 kMaxRange = 1u << 31;
679 
680  explicit Random(UInt32 seed) : state_(seed) {}
681 
682  void Reseed(UInt32 seed) { state_ = seed; }
683 
684  // Generates a random number from [0, range). Crashes if 'range' is
685  // 0 or greater than kMaxRange.
686  UInt32 Generate(UInt32 range);
687 
688  private:
691 };
692 
693 // Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
694 // compiler error iff T1 and T2 are different types.
695 template <typename T1, typename T2>
697 
698 template <typename T>
700 };
701 
702 // Removes the reference from a type if it is a reference type,
703 // otherwise leaves it unchanged. This is the same as
704 // tr1::remove_reference, which is not widely available yet.
705 template <typename T>
706 struct RemoveReference { typedef T type; }; // NOLINT
707 template <typename T>
708 struct RemoveReference<T&> { typedef T type; }; // NOLINT
709 
710 // A handy wrapper around RemoveReference that works when the argument
711 // T depends on template parameters.
712 #define GTEST_REMOVE_REFERENCE_(T) \
713  typename ::testing::internal::RemoveReference<T>::type
714 
715 // Removes const from a type if it is a const type, otherwise leaves
716 // it unchanged. This is the same as tr1::remove_const, which is not
717 // widely available yet.
718 template <typename T>
719 struct RemoveConst { typedef T type; }; // NOLINT
720 template <typename T>
721 struct RemoveConst<const T> { typedef T type; }; // NOLINT
722 
723 // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
724 // definition to fail to remove the const in 'const int[3]' and 'const
725 // char[3][4]'. The following specialization works around the bug.
726 template <typename T, size_t N>
727 struct RemoveConst<const T[N]> {
728  typedef typename RemoveConst<T>::type type[N];
729 };
730 
731 #if defined(_MSC_VER) && _MSC_VER < 1400
732 // This is the only specialization that allows VC++ 7.1 to remove const in
733 // 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC
734 // and thus needs to be conditionally compiled.
735 template <typename T, size_t N>
736 struct RemoveConst<T[N]> {
737  typedef typename RemoveConst<T>::type type[N];
738 };
739 #endif
740 
741 // A handy wrapper around RemoveConst that works when the argument
742 // T depends on template parameters.
743 #define GTEST_REMOVE_CONST_(T) \
744  typename ::testing::internal::RemoveConst<T>::type
745 
746 // Turns const U&, U&, const U, and U all into U.
747 #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
748  GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
749 
750 // Adds reference to a type if it is not a reference type,
751 // otherwise leaves it unchanged. This is the same as
752 // tr1::add_reference, which is not widely available yet.
753 template <typename T>
754 struct AddReference { typedef T& type; }; // NOLINT
755 template <typename T>
756 struct AddReference<T&> { typedef T& type; }; // NOLINT
757 
758 // A handy wrapper around AddReference that works when the argument T
759 // depends on template parameters.
760 #define GTEST_ADD_REFERENCE_(T) \
761  typename ::testing::internal::AddReference<T>::type
762 
763 // Adds a reference to const on top of T as necessary. For example,
764 // it transforms
765 //
766 // char ==> const char&
767 // const char ==> const char&
768 // char& ==> const char&
769 // const char& ==> const char&
770 //
771 // The argument T must depend on some template parameters.
772 #define GTEST_REFERENCE_TO_CONST_(T) \
773  GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
774 
775 // ImplicitlyConvertible<From, To>::value is a compile-time bool
776 // constant that's true iff type From can be implicitly converted to
777 // type To.
778 template <typename From, typename To>
780  private:
781  // We need the following helper functions only for their types.
782  // They have no implementations.
783 
784  // MakeFrom() is an expression whose type is From. We cannot simply
785  // use From(), as the type From may not have a public default
786  // constructor.
787  static From MakeFrom();
788 
789  // These two functions are overloaded. Given an expression
790  // Helper(x), the compiler will pick the first version if x can be
791  // implicitly converted to type To; otherwise it will pick the
792  // second version.
793  //
794  // The first version returns a value of size 1, and the second
795  // version returns a value of size 2. Therefore, by checking the
796  // size of Helper(x), which can be done at compile time, we can tell
797  // which version of Helper() is used, and hence whether x can be
798  // implicitly converted to type To.
799  static char Helper(To);
800  static char (&Helper(...))[2]; // NOLINT
801 
802  // We have to put the 'public' section after the 'private' section,
803  // or MSVC refuses to compile the code.
804  public:
805  // MSVC warns about implicitly converting from double to int for
806  // possible loss of data, so we need to temporarily disable the
807  // warning.
808 #ifdef _MSC_VER
809 # pragma warning(push) // Saves the current warning state.
810 # pragma warning(disable:4244) // Temporarily disables warning 4244.
811 
812  static const bool value =
813  sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
814 # pragma warning(pop) // Restores the warning state.
815 #elif defined(__BORLANDC__)
816  // C++Builder cannot use member overload resolution during template
817  // instantiation. The simplest workaround is to use its C++0x type traits
818  // functions (C++Builder 2009 and above only).
819  static const bool value = __is_convertible(From, To);
820 #else
821  static const bool value =
822  sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
823 #endif // _MSV_VER
824 };
825 template <typename From, typename To>
827 
828 // IsAProtocolMessage<T>::value is a compile-time bool constant that's
829 // true iff T is type ProtocolMessage, proto2::Message, or a subclass
830 // of those.
831 template <typename T>
833  : public bool_constant<
834  ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
835  ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
836 };
837 
838 // When the compiler sees expression IsContainerTest<C>(0), if C is an
839 // STL-style container class, the first overload of IsContainerTest
840 // will be viable (since both C::iterator* and C::const_iterator* are
841 // valid types and NULL can be implicitly converted to them). It will
842 // be picked over the second overload as 'int' is a perfect match for
843 // the type of argument 0. If C::iterator or C::const_iterator is not
844 // a valid type, the first overload is not viable, and the second
845 // overload will be picked. Therefore, we can determine whether C is
846 // a container class by checking the type of IsContainerTest<C>(0).
847 // The value of the expression is insignificant.
848 //
849 // Note that we look for both C::iterator and C::const_iterator. The
850 // reason is that C++ injects the name of a class as a member of the
851 // class itself (e.g. you can refer to class iterator as either
852 // 'iterator' or 'iterator::iterator'). If we look for C::iterator
853 // only, for example, we would mistakenly think that a class named
854 // iterator is an STL container.
855 //
856 // Also note that the simpler approach of overloading
857 // IsContainerTest(typename C::const_iterator*) and
858 // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
859 typedef int IsContainer;
860 template <class C>
861 IsContainer IsContainerTest(int /* dummy */,
862  typename C::iterator* /* it */ = NULL,
863  typename C::const_iterator* /* const_it */ = NULL) {
864  return 0;
865 }
866 
867 typedef char IsNotContainer;
868 template <class C>
869 IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
870 
871 // EnableIf<condition>::type is void when 'Cond' is true, and
872 // undefined when 'Cond' is false. To use SFINAE to make a function
873 // overload only apply when a particular expression is true, add
874 // "typename EnableIf<expression>::type* = 0" as the last parameter.
875 template<bool> struct EnableIf;
876 template<> struct EnableIf<true> { typedef void type; }; // NOLINT
877 
878 // Utilities for native arrays.
879 
880 // ArrayEq() compares two k-dimensional native arrays using the
881 // elements' operator==, where k can be any integer >= 0. When k is
882 // 0, ArrayEq() degenerates into comparing a single pair of values.
883 
884 template <typename T, typename U>
885 bool ArrayEq(const T* lhs, size_t size, const U* rhs);
886 
887 // This generic version is used when k is 0.
888 template <typename T, typename U>
889 inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
890 
891 // This overload is used when k >= 1.
892 template <typename T, typename U, size_t N>
893 inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
894  return internal::ArrayEq(lhs, N, rhs);
895 }
896 
897 // This helper reduces code bloat. If we instead put its logic inside
898 // the previous ArrayEq() function, arrays with different sizes would
899 // lead to different copies of the template code.
900 template <typename T, typename U>
901 bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
902  for (size_t i = 0; i != size; i++) {
903  if (!internal::ArrayEq(lhs[i], rhs[i]))
904  return false;
905  }
906  return true;
907 }
908 
909 // Finds the first element in the iterator range [begin, end) that
910 // equals elem. Element may be a native array type itself.
911 template <typename Iter, typename Element>
912 Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
913  for (Iter it = begin; it != end; ++it) {
914  if (internal::ArrayEq(*it, elem))
915  return it;
916  }
917  return end;
918 }
919 
920 // CopyArray() copies a k-dimensional native array using the elements'
921 // operator=, where k can be any integer >= 0. When k is 0,
922 // CopyArray() degenerates into copying a single value.
923 
924 template <typename T, typename U>
925 void CopyArray(const T* from, size_t size, U* to);
926 
927 // This generic version is used when k is 0.
928 template <typename T, typename U>
929 inline void CopyArray(const T& from, U* to) { *to = from; }
930 
931 // This overload is used when k >= 1.
932 template <typename T, typename U, size_t N>
933 inline void CopyArray(const T(&from)[N], U(*to)[N]) {
934  internal::CopyArray(from, N, *to);
935 }
936 
937 // This helper reduces code bloat. If we instead put its logic inside
938 // the previous CopyArray() function, arrays with different sizes
939 // would lead to different copies of the template code.
940 template <typename T, typename U>
941 void CopyArray(const T* from, size_t size, U* to) {
942  for (size_t i = 0; i != size; i++) {
943  internal::CopyArray(from[i], to + i);
944  }
945 }
946 
947 // The relation between an NativeArray object (see below) and the
948 // native array it represents.
950  kReference, // The NativeArray references the native array.
951  kCopy // The NativeArray makes a copy of the native array and
952  // owns the copy.
953 };
954 
955 // Adapts a native array to a read-only STL-style container. Instead
956 // of the complete STL container concept, this adaptor only implements
957 // members useful for Google Mock's container matchers. New members
958 // should be added as needed. To simplify the implementation, we only
959 // support Element being a raw type (i.e. having no top-level const or
960 // reference modifier). It's the client's responsibility to satisfy
961 // this requirement. Element can be an array type itself (hence
962 // multi-dimensional arrays are supported).
963 template <typename Element>
964 class NativeArray {
965  public:
966  // STL-style container typedefs.
967  typedef Element value_type;
968  typedef Element* iterator;
969  typedef const Element* const_iterator;
970 
971  // Constructs from a native array.
972  NativeArray(const Element* array, size_t count, RelationToSource relation) {
973  Init(array, count, relation);
974  }
975 
976  // Copy constructor.
977  NativeArray(const NativeArray& rhs) {
978  Init(rhs.array_, rhs.size_, rhs.relation_to_source_);
979  }
980 
982  // Ensures that the user doesn't instantiate NativeArray with a
983  // const or reference type.
984  static_cast<void>(StaticAssertTypeEqHelper<Element,
986  if (relation_to_source_ == kCopy)
987  delete[] array_;
988  }
989 
990  // STL-style container methods.
991  size_t size() const { return size_; }
992  const_iterator begin() const { return array_; }
993  const_iterator end() const { return array_ + size_; }
994  bool operator==(const NativeArray& rhs) const {
995  return size() == rhs.size() &&
996  ArrayEq(begin(), size(), rhs.begin());
997  }
998 
999  private:
1000  // Initializes this object; makes a copy of the input array if
1001  // 'relation' is kCopy.
1002  void Init(const Element* array, size_t a_size, RelationToSource relation) {
1003  if (relation == kReference) {
1004  array_ = array;
1005  } else {
1006  Element* const copy = new Element[a_size];
1007  CopyArray(array, a_size, copy);
1008  array_ = copy;
1009  }
1010  size_ = a_size;
1011  relation_to_source_ = relation;
1012  }
1013 
1014  const Element* array_;
1015  size_t size_;
1017 
1019 };
1020 
1021 } // namespace internal
1022 } // namespace testing
1023 
1024 #define GTEST_MESSAGE_AT_(file, line, message, result_type) \
1025  ::testing::internal::AssertHelper(result_type, file, line, message) \
1026  = ::testing::Message()
1027 
1028 #define GTEST_MESSAGE_(message, result_type) \
1029  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
1030 
1031 #define GTEST_FATAL_FAILURE_(message) \
1032  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
1033 
1034 #define GTEST_NONFATAL_FAILURE_(message) \
1035  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
1036 
1037 #define GTEST_SUCCESS_(message) \
1038  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
1039 
1040 // Suppresses MSVC warnings 4072 (unreachable code) for the code following
1041 // statement if it returns or throws (or doesn't return or throw in some
1042 // situations).
1043 #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
1044  if (::testing::internal::AlwaysTrue()) { statement; }
1045 
1046 #define GTEST_TEST_THROW_(statement, expected_exception, fail) \
1047  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1048  if (::testing::internal::ConstCharPtr gtest_msg = "") { \
1049  bool gtest_caught_expected = false; \
1050  try { \
1051  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1052  } \
1053  catch (expected_exception const&) { \
1054  gtest_caught_expected = true; \
1055  } \
1056  catch (...) { \
1057  gtest_msg.value = \
1058  "Expected: " #statement " throws an exception of type " \
1059  #expected_exception ".\n Actual: it throws a different type."; \
1060  goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1061  } \
1062  if (!gtest_caught_expected) { \
1063  gtest_msg.value = \
1064  "Expected: " #statement " throws an exception of type " \
1065  #expected_exception ".\n Actual: it throws nothing."; \
1066  goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
1067  } \
1068  } else \
1069  GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
1070  fail(gtest_msg.value)
1071 
1072 #define GTEST_TEST_NO_THROW_(statement, fail) \
1073  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1074  if (::testing::internal::AlwaysTrue()) { \
1075  try { \
1076  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1077  } \
1078  catch (...) { \
1079  goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
1080  } \
1081  } else \
1082  GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
1083  fail("Expected: " #statement " doesn't throw an exception.\n" \
1084  " Actual: it throws.")
1085 
1086 #define GTEST_TEST_ANY_THROW_(statement, fail) \
1087  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1088  if (::testing::internal::AlwaysTrue()) { \
1089  bool gtest_caught_any = false; \
1090  try { \
1091  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1092  } \
1093  catch (...) { \
1094  gtest_caught_any = true; \
1095  } \
1096  if (!gtest_caught_any) { \
1097  goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
1098  } \
1099  } else \
1100  GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
1101  fail("Expected: " #statement " throws an exception.\n" \
1102  " Actual: it doesn't.")
1103 
1104 
1105 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
1106 // either a boolean expression or an AssertionResult. text is a textual
1107 // represenation of expression as it was passed into the EXPECT_TRUE.
1108 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
1109  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1110  if (const ::testing::AssertionResult gtest_ar_ = \
1111  ::testing::AssertionResult(expression)) \
1112  ; \
1113  else \
1114  fail(::testing::internal::GetBoolAssertionFailureMessage(\
1115  gtest_ar_, text, #actual, #expected).c_str())
1116 
1117 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
1118  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1119  if (::testing::internal::AlwaysTrue()) { \
1120  ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
1121  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
1122  if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
1123  goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
1124  } \
1125  } else \
1126  GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
1127  fail("Expected: " #statement " doesn't generate new fatal " \
1128  "failures in the current thread.\n" \
1129  " Actual: it does.")
1130 
1131 // Expands to the name of the class that implements the given test.
1132 #define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
1133  test_case_name##_##test_name##_Test
1134 
1135 // Helper macro for defining tests.
1136 #define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
1137 class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
1138  public:\
1139  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
1140  private:\
1141  virtual void TestBody();\
1142  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
1143  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
1144  GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
1145 };\
1146 \
1147 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
1148  ::test_info_ =\
1149  ::testing::internal::MakeAndRegisterTestInfo(\
1150  #test_case_name, #test_name, NULL, NULL, \
1151  (parent_id), \
1152  parent_class::SetUpTestCase, \
1153  parent_class::TearDownTestCase, \
1154  new ::testing::internal::TestFactoryImpl<\
1155  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
1156 void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
1157 
1158 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
testing::internal::GetTypeId
TypeId GetTypeId()
Definition: gtest-internal.h:417
gtest-filepath.h
testing
Definition: gtest-death-test.h:43
testing::internal::g_init_gtest_count
GTEST_API_ int g_init_gtest_count
Definition: gtest.cc:318
testing::TestInfo
Definition: gtest.h:621
testing::internal::FloatingPoint
Definition: gtest-internal.h:232
testing::internal::CompileAssertTypesEqual
Definition: gtest-internal.h:696
testing::internal::RelationToSource
RelationToSource
Definition: gtest-internal.h:949
testing::internal::kCopy
@ kCopy
Definition: gtest-internal.h:951
testing::internal::NativeArray::NativeArray
NativeArray(const NativeArray &rhs)
Definition: gtest-internal.h:977
testing::internal::ImplicitlyConvertible::MakeFrom
static From MakeFrom()
testing::internal::FloatingPoint::Max
static RawType Max()
testing::internal::NativeArray::Init
void Init(const Element *array, size_t a_size, RelationToSource relation)
Definition: gtest-internal.h:1002
testing::internal::TypeIdHelper::dummy_
static bool dummy_
Definition: gtest-internal.h:407
testing::internal::NativeArray::begin
const_iterator begin() const
Definition: gtest-internal.h:992
testing::internal::NativeArray::size_
size_t size_
Definition: gtest-internal.h:1015
testing::internal::FormatFileLocation
GTEST_API_ ::std::string FormatFileLocation(const char *file, int line)
Definition: gtest-port.cc:456
testing::internal::FloatingPoint::u_
FloatingPointUnion u_
Definition: gtest-internal.h:378
testing::internal::RemoveReference::type
T type
Definition: gtest-internal.h:706
testing::internal::TestFactoryBase::TestFactoryBase
TestFactoryBase()
Definition: gtest-internal.h:443
testing::internal::NativeArray::operator==
bool operator==(const NativeArray &rhs) const
Definition: gtest-internal.h:994
testing::internal::NativeArray::array_
const Element * array_
Definition: gtest-internal.h:1014
testing::internal::TestFactoryBase::GTEST_DISALLOW_COPY_AND_ASSIGN_
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase)
testing::internal::RemoveConst
Definition: gtest-internal.h:719
testing::internal::GTEST_ATTRIBUTE_UNUSED_
class GTEST_API_ testing::internal::ScopedTrace GTEST_ATTRIBUTE_UNUSED_
gtest-type-util.h
testing::internal::NativeArray::NativeArray
NativeArray(const Element *array, size_t count, RelationToSource relation)
Definition: gtest-internal.h:972
testing::internal::FloatingPoint::bits
const Bits & bits() const
Definition: gtest-internal.h:304
testing::internal::RemoveConst::type
T type
Definition: gtest-internal.h:719
testing::internal::Random::Random
Random(UInt32 seed)
Definition: gtest-internal.h:680
testing::internal::Random::state_
UInt32 state_
Definition: gtest-internal.h:689
testing::internal::GetCurrentOsStackTraceExceptTop
GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(UnitTest *unit_test, int skip_count)
Definition: gtest.cc:4638
testing::internal::FloatingPoint::kFractionBitCount
static const size_t kFractionBitCount
Definition: gtest-internal.h:244
testing::internal::bool_constant
Definition: gtest-port.h:1614
testing::internal::FloatingPoint::is_nan
bool is_nan() const
Definition: gtest-internal.h:316
testing::Message
Definition: gtest-message.h:85
testing::internal::EnableIf
Definition: gtest-internal.h:875
testing::Test
Definition: gtest.h:347
testing::internal::RemoveReference
Definition: gtest-internal.h:706
testing::internal::FloatingPoint::FloatingPoint
FloatingPoint(const RawType &x)
Definition: gtest-internal.h:280
testing::internal::IsContainer
int IsContainer
Definition: gtest-internal.h:859
testing::internal::NativeArray::size
size_t size() const
Definition: gtest-internal.h:991
testing::internal::Double
FloatingPoint< double > Double
Definition: gtest-internal.h:391
testing::internal::StreamableToString
std::string StreamableToString(const T &streamable)
Definition: gtest-message.h:243
testing::internal::TestFactoryImpl::CreateTest
virtual Test * CreateTest()
Definition: gtest-internal.h:454
testing::internal::UInt32
TypeWithSize< 4 >::UInt UInt32
Definition: gtest-port.h:1904
testing::internal::NativeArray::~NativeArray
~NativeArray()
Definition: gtest-internal.h:981
testing::internal::AddReference< T & >::type
T & type
Definition: gtest-internal.h:756
testing::internal::kReference
@ kReference
Definition: gtest-internal.h:950
testing::internal::string
::std::string string
Definition: gtest-port.h:875
testing::internal::MakeAndRegisterTestInfo
GTEST_API_ TestInfo * MakeAndRegisterTestInfo(const char *test_case_name, const char *name, const char *type_param, const char *value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
Definition: gtest.cc:2219
testing::internal::FloatingPoint::fraction_bits
Bits fraction_bits() const
Definition: gtest-internal.h:310
testing::internal::StaticAssertTypeEqHelper
Definition: gtest-port.h:867
testing::internal::AddReference::type
T & type
Definition: gtest-internal.h:754
testing::internal::FloatingPoint::exponent_bits
Bits exponent_bits() const
Definition: gtest-internal.h:307
testing::internal::SkipPrefix
GTEST_API_ bool SkipPrefix(const char *prefix, const char **pstr)
Definition: gtest.cc:4666
testing::internal::Float
FloatingPoint< float > Float
Definition: gtest-internal.h:390
testing::internal::ConstCharPtr::value
const char * value
Definition: gtest-internal.h:668
testing::internal::EnableIf< true >::type
void type
Definition: gtest-internal.h:876
name
std::string name
Definition: test_sphere_box.cpp:167
testing::internal::posix::Abort
void Abort()
Definition: gtest-port.h:1819
gtest-port.h
testing::internal::IsSpace
bool IsSpace(char ch)
Definition: gtest-port.h:1674
testing::internal::ImplicitlyConvertible
Definition: gtest-internal.h:779
testing::AssertionResult
Definition: gtest.h:256
testing::internal::NativeArray
Definition: gtest-internal.h:964
testing::internal::TearDownTestCaseFunc
void(* TearDownTestCaseFunc)()
Definition: gtest-internal.h:472
testing::internal::ImplicitlyConvertible::value
static const bool value
Definition: gtest-internal.h:821
testing::internal::AlwaysTrue
GTEST_API_ bool AlwaysTrue()
Definition: gtest.cc:4653
testing::internal::FloatingPoint::kMaxUlps
static const size_t kMaxUlps
Definition: gtest-internal.h:272
GTEST_API_
#define GTEST_API_
Definition: gtest-port.h:771
testing::internal::AlwaysFalse
bool AlwaysFalse()
Definition: gtest-internal.h:660
testing::internal::FloatingPoint::DistanceBetweenSignAndMagnitudeNumbers
static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, const Bits &sam2)
Definition: gtest-internal.h:371
testing::internal::TestFactoryBase::~TestFactoryBase
virtual ~TestFactoryBase()
Definition: gtest-internal.h:436
testing::internal::Random
Definition: gtest-internal.h:676
testing::internal::ArrayEq
bool ArrayEq(const T *lhs, size_t size, const U *rhs)
Definition: gtest-internal.h:901
testing::internal::ImplicitlyConvertible::Helper
static char Helper(To)
testing::internal::TypeWithSize
Definition: gtest-port.h:1870
testing::internal::TestFactoryImpl
Definition: gtest-internal.h:452
testing::internal::SetUpTestCaseFunc
void(* SetUpTestCaseFunc)()
Definition: gtest-internal.h:471
proto2
Definition: gtest-internal.h:77
testing::internal::GetTestTypeId
GTEST_API_ TypeId GetTestTypeId()
Definition: gtest.cc:601
testing::internal::FloatingPoint::AlmostEquals
bool AlmostEquals(const FloatingPoint &rhs) const
Definition: gtest-internal.h:328
testing::internal::NativeArray::iterator
Element * iterator
Definition: gtest-internal.h:968
testing::internal::TypeId
const typedef void * TypeId
Definition: gtest-internal.h:399
testing::internal::AppendUserMessage
GTEST_API_ std::string AppendUserMessage(const std::string &gtest_msg, const Message &user_msg)
Definition: gtest.cc:1681
testing::internal::NativeArray::const_iterator
const typedef Element * const_iterator
Definition: gtest-internal.h:969
testing::internal::EqFailure
GTEST_API_ AssertionResult EqFailure(const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
Definition: gtest.cc:1003
testing::internal::ConstCharPtr::ConstCharPtr
ConstCharPtr(const char *str)
Definition: gtest-internal.h:666
gtest-string.h
testing::internal::TestFactoryBase::CreateTest
virtual Test * CreateTest()=0
testing::internal::GetBoolAssertionFailureMessage
GTEST_API_ std::string GetBoolAssertionFailureMessage(const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
Definition: gtest.cc:1026
testing::internal::IsAProtocolMessage
Definition: gtest-internal.h:832
testing::internal::NativeArray::end
const_iterator end() const
Definition: gtest-internal.h:993
testing::internal::TypeIdHelper
Definition: gtest-internal.h:402
testing::internal::NativeArray::GTEST_DISALLOW_ASSIGN_
GTEST_DISALLOW_ASSIGN_(NativeArray)
testing::internal::FloatingPoint::FloatingPointUnion::value_
RawType value_
Definition: gtest-internal.h:340
testing::internal::NativeArray::value_type
Element value_type
Definition: gtest-internal.h:967
testing::internal::ArrayAwareFind
Iter ArrayAwareFind(Iter begin, Iter end, const Element &elem)
Definition: gtest-internal.h:912
testing::internal::IsNotContainer
char IsNotContainer
Definition: gtest-internal.h:867
testing::internal::Random::Reseed
void Reseed(UInt32 seed)
Definition: gtest-internal.h:682
testing::internal::FloatingPoint::SignAndMagnitudeToBiased
static Bits SignAndMagnitudeToBiased(const Bits &sam)
Definition: gtest-internal.h:359
gtest-message.h
testing::internal::FloatingPoint::kExponentBitCount
static const size_t kExponentBitCount
Definition: gtest-internal.h:248
testing::internal::CopyArray
void CopyArray(const T *from, size_t size, U *to)
Definition: gtest-internal.h:941
testing::internal::AddReference
Definition: gtest-internal.h:754
testing::internal::FloatingPoint::sign_bit
Bits sign_bit() const
Definition: gtest-internal.h:313
testing::internal::FloatingPoint::Bits
TypeWithSize< sizeof(RawType)>::UInt Bits
Definition: gtest-internal.h:236
GTEST_DISALLOW_COPY_AND_ASSIGN_
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
Definition: gtest-port.h:729
testing::internal::kStackTraceMarker
const GTEST_API_ char kStackTraceMarker[]
Definition: gtest.cc:180
GTEST_REMOVE_REFERENCE_AND_CONST_
#define GTEST_REMOVE_REFERENCE_AND_CONST_(T)
Definition: gtest-internal.h:747
line
static char * line
Definition: svm.cpp:2902
testing::internal::ScopedTrace
Definition: gtest-internal.h:156
testing::internal::FloatingPoint::kSignBitMask
static const Bits kSignBitMask
Definition: gtest-internal.h:251
testing::internal::FloatingPoint::Infinity
static RawType Infinity()
Definition: gtest-internal.h:294
testing::internal::NativeArray::relation_to_source_
RelationToSource relation_to_source_
Definition: gtest-internal.h:1016
testing::internal::FloatingPoint::FloatingPointUnion
Definition: gtest-internal.h:339
testing::internal::RemoveReference< T & >::type
T type
Definition: gtest-internal.h:708
testing::internal::FloatingPoint::FloatingPointUnion::bits_
Bits bits_
Definition: gtest-internal.h:341
testing::internal::RemoveConst< const T >::type
T type
Definition: gtest-internal.h:721
testing::internal::IsContainerTest
IsContainer IsContainerTest(int, typename C::iterator *=NULL, typename C::const_iterator *=NULL)
Definition: gtest-internal.h:861
testing::internal::IsNullLiteralHelper
char IsNullLiteralHelper(Secret *p)
testing::internal::TestFactoryBase
Definition: gtest-internal.h:434
testing::internal::FloatingPoint::ReinterpretBits
static RawType ReinterpretBits(const Bits bits)
Definition: gtest-internal.h:287
testing::internal::FloatingPoint::kFractionBitMask
static const Bits kFractionBitMask
Definition: gtest-internal.h:254
testing::internal::FloatingPoint::kBitCount
static const size_t kBitCount
Definition: gtest-internal.h:241
testing::internal::FloatingPoint::kExponentBitMask
static const Bits kExponentBitMask
Definition: gtest-internal.h:258
testing::internal::ConstCharPtr
Definition: gtest-internal.h:665
testing::PrintToString
::std::string PrintToString(const T &value)
Definition: gtest-printers.h:850


fcl
Author(s):
autogenerated on Fri Apr 2 2021 02:38:00