gtest/internal/gtest-internal.h

15 // contributors may be used to endorse or promote products derived from
35 // Google Test.  They are subject to change without notice.
68 // Due to C++ preprocessor weirdness, we need double indirection to
103 // The text used in failure messages to indicate the start of the
110 // different sizes, so we can use sizeof() to test which version is
115 // version if x can be implicitly converted to Secret*, and pick the
136 // Appends the user-supplied message to the Google-Test-generated message.
147 // frameworks know how to extract and print the message inside it.
164   // Note that the d'tor is not virtual in order to be efficient.
172                             // need to be used otherwise.
175 // Returns the optimal edits to go from 'left' to 'right'.
236 // The purpose of this class is to do more sophisticated number
237 // comparison.  (Due to round-off error, etc, it's very unlikely that
290   // How many ULP's (Units in the Last Place) we want to tolerate when
293   // to be considered equal.
308   // to be also a NAN.  Therefore, don't expect this constructor to
316   // This function is needed to test the AlmostEquals() method.
356   //   - treats really large numbers as almost equal to infinity.
368   // The data type used to store the actual floating-point number.
374   // Converts an integer from the sign-and-magnitude representation to
375   // the biased representation.  More precisely, let N be 2 to the
419 // care to use.
423 // In order to catch the mistake of putting tests that use different
424 // test fixture classes in the same test case, we need to assign
425 // unique IDs to fixture classes and compare them.  The TypeId type is
426 // used to hold such IDs.  The user should treat TypeId as an opaque
427 // type: the only operation allowed on TypeId values is to compare
435   // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
445 // same type argument is guaranteed to return the same ID.
448   // The compiler is required to allocate a different
449   // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
450   // the template.  Therefore, the address of dummy_ is guaranteed to
456 // of GetTypeId< ::testing::Test>() to get the type ID of
457 // ::testing::Test, as the latter may give the wrong result due to a
468   // Creates a test instance to run. The instance is both created and destroyed
491 // We pass a long instead of HRESULT to avoid causing an
524 //   set_up_tc:        pointer to the function that sets up the test case
525 //   tear_down_tc:     pointer to the function that tears down the test case
526 //   factory:          pointer to the factory that creates a test object.
540 // If *pstr starts with the given prefix, modifies *pstr to be right
552   // Adds the given test name to defined_test_names_ and return true
592 // Skips to the first non-space char after the first comma in 'str';
617 // return value is insignificant - we just need to return something
670 // Test.  The return value is insignificant - we just need to return
681       fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
718 // The maximum number of stack frames to be included is specified by
720 // specifies the number of top frames to be skipped, which doesn't
721 // count against the number of frames to be included.
800 // definition to fail to remove the const in 'const int[3]' and 'const
808 // This is the only specialization that allows VC++ 7.1 to remove const in
810 // and thus needs to be conditionally compiled.
826 // Adds reference to a type if it is not a reference type,
839 // Adds a reference to const on top of T as necessary.  For example,
852 // constant that's true iff type From can be implicitly converted to
867   // implicitly converted to type To; otherwise it will pick the
874   // implicitly converted to type To.
878   // We have to put the 'public' section after the 'private' section,
879   // or MSVC refuses to compile the code.
883   // instantiation.  The simplest workaround is to use its C++0x type traits
887   // MSVC warns about implicitly converting from double to int for
888   // possible loss of data, so we need to temporarily disable the
912 // valid types and NULL can be implicitly converted to them).  It will
922 // class itself (e.g. you can refer to class iterator as either
943 // undefined when 'Cond' is false.  To use SFINAE to make a function
970 // lead to different copies of the template code.
996 void CopyArray(const T* from, size_t size, U* to);
1000 inline void CopyArray(const T& from, U* to) { *to = from; }
1004 inline void CopyArray(const T(&from)[N], U(*to)[N]) {
1005   internal::CopyArray(from, N, *to);
1010 // would lead to different copies of the template code.
1012 void CopyArray(const T* from, size_t size, U* to) {
1014     internal::CopyArray(from[i], to + i);
1020 // We use 2 different structs to allow non-copyable types to be used, as long
1025 // Adapts a native array to a read-only STL-style container.  Instead
1030 // reference modifier).  It's the client's responsibility to satisfy
1209 // Expands to the name of the class that implements the given test.