gtest-internal.h File Reference

#include "gtest/internal/gtest-port.h"
#include <ctype.h>
#include <float.h>
#include <string.h>
#include <iomanip>
#include <limits>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "gtest/gtest-message.h"
#include "gtest/internal/gtest-string.h"
#include "gtest/internal/gtest-filepath.h"
#include "gtest/internal/gtest-type-util.h"

Include dependency graph for gtest-internal.h:

Go to the source code of this file.

Classes
class	testing::internal::ScopedTrace
class	testing::internal::FloatingPoint< RawType >
union	testing::internal::FloatingPoint< RawType >::FloatingPointUnion
class	testing::internal::TypeIdHelper< T >
class	testing::internal::TestFactoryBase
class	testing::internal::TestFactoryImpl< TestClass >
struct	testing::internal::CodeLocation
struct	testing::internal::ConstCharPtr
class	testing::internal::Random
struct	testing::internal::CompileAssertTypesEqual< T, T >
struct	testing::internal::RemoveReference< T >
struct	testing::internal::RemoveReference< T & >
struct	testing::internal::RemoveConst< T >
struct	testing::internal::RemoveConst< const T >
struct	testing::internal::RemoveConst< const T[N]>
struct	testing::internal::AddReference< T >
struct	testing::internal::AddReference< T & >
class	testing::internal::ImplicitlyConvertible< From, To >
struct	testing::internal::IsAProtocolMessage< T >
struct	testing::internal::EnableIf< true >
struct	testing::internal::RelationToSourceReference
struct	testing::internal::RelationToSourceCopy
class	testing::internal::NativeArray< Element >

Namespaces
namespace	proto2
namespace	testing
namespace	testing::internal
namespace	testing::internal::edit_distance

Macros
#define	GTEST_CONCAT_TOKEN_(foo, bar)
#define	GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
#define	GTEST_IS_NULL_LITERAL_(x)
#define	GTEST_REMOVE_REFERENCE_(T)
#define	GTEST_REMOVE_CONST_(T)
#define	GTEST_REMOVE_REFERENCE_AND_CONST_(T)
#define	GTEST_ADD_REFERENCE_(T)
#define	GTEST_REFERENCE_TO_CONST_(T)
#define	GTEST_MESSAGE_AT_(file, line, message, result_type)
#define	GTEST_MESSAGE_(message, result_type)
#define	GTEST_FATAL_FAILURE_(message)
#define	GTEST_NONFATAL_FAILURE_(message)
#define	GTEST_SUCCESS_(message)
#define	GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
#define	GTEST_TEST_THROW_(statement, expected_exception, fail)
#define	GTEST_TEST_NO_THROW_(statement, fail)
#define	GTEST_TEST_ANY_THROW_(statement, fail)
#define	GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
#define	GTEST_TEST_NO_FATAL_FAILURE_(statement, fail)
#define	GTEST_TEST_CLASS_NAME_(test_case_name, test_name)
#define	GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)

Enumerations
enum	testing::internal::edit_distance::EditType {   testing::internal::edit_distance::kMatch , testing::internal::edit_distance::kAdd , testing::internal::edit_distance::kRemove , testing::internal::edit_distance::kReplace ,   testing::internal::edit_distance::kMatch , testing::internal::edit_distance::kAdd , testing::internal::edit_distance::kRemove , testing::internal::edit_distance::kReplace }

Functions
template<typename T>
::std::string	testing::PrintToString (const T &value)
char	testing::internal::IsNullLiteralHelper (Secret *p)
char(&	testing::internal::IsNullLiteralHelper (...))[2]
GTEST_API_ std::string	testing::internal::AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
GTEST_API_ std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< size_t > &left, const std::vector< size_t > &right)
GTEST_API_ std::vector< EditType >	testing::internal::edit_distance::CalculateOptimalEdits (const std::vector< std::string > &left, const std::vector< std::string > &right)
GTEST_API_ std::string	testing::internal::edit_distance::CreateUnifiedDiff (const std::vector< std::string > &left, const std::vector< std::string > &right, size_t context=2)
GTEST_API_ std::string	testing::internal::DiffStrings (const std::string &left, const std::string &right, size_t *total_line_count)
GTEST_API_ AssertionResult	testing::internal::EqFailure (const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
GTEST_API_ std::string	testing::internal::GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
template<typename T>
TypeId	testing::internal::GetTypeId ()
GTEST_API_ TypeId	testing::internal::GetTestTypeId ()
GTEST_API_ TestInfo *	testing::internal::MakeAndRegisterTestInfo (const char *test_case_name, const char *name, const char *type_param, const char *value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
GTEST_API_ bool	testing::internal::SkipPrefix (const char *prefix, const char **pstr)
GTEST_API_ std::string	testing::internal::GetCurrentOsStackTraceExceptTop (UnitTest *unit_test, int skip_count)
GTEST_API_ bool	testing::internal::AlwaysTrue ()
bool	testing::internal::AlwaysFalse ()
template<class C>
IsContainer	testing::internal::IsContainerTest (int, typename C::iterator *=NULL, typename C::const_iterator *=NULL)
template<class C>
IsNotContainer	testing::internal::IsContainerTest (long)
template<typename T, typename U>
bool	testing::internal::ArrayEq (const T *lhs, size_t size, const U *rhs)
template<typename T, typename U>
bool	testing::internal::ArrayEq (const T &lhs, const U &rhs)
template<typename T, typename U, size_t N>
bool	testing::internal::ArrayEq (const T(&lhs)[N], const U(&rhs)[N])
template<typename Iter, typename Element>
Iter	testing::internal::ArrayAwareFind (Iter begin, Iter end, const Element &elem)
template<typename T, typename U>
void	testing::internal::CopyArray (const T *from, size_t size, U *to)
template<typename T, typename U>
void	testing::internal::CopyArray (const T &from, U *to)
template<typename T, typename U, size_t N>
void	testing::internal::CopyArray (const T(&from)[N], U(*to)[N])

Macro Definition Documentation

GTEST_ADD_REFERENCE_

#define GTEST_ADD_REFERENCE_

(

T

)

Value:

typename ::testing::internal::AddReference<T>::type

GTEST_CONCAT_TOKEN_

#define GTEST_CONCAT_TOKEN_	(		foo,
			bar )

Value:

GTEST_CONCAT_TOKEN_IMPL_(foo, bar)

GTEST_CONCAT_TOKEN_IMPL_

#define GTEST_CONCAT_TOKEN_IMPL_	(		foo,
			bar )

Value:

foo ## bar

GTEST_FATAL_FAILURE_

#define GTEST_FATAL_FAILURE_

(

message

)

Value:

return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)

GTEST_IS_NULL_LITERAL_

#define GTEST_IS_NULL_LITERAL_

(

x

)

Value:

(sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)

GTEST_MESSAGE_

#define GTEST_MESSAGE_	(		message,
			result_type )

Value:

GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

GTEST_MESSAGE_AT_

#define GTEST_MESSAGE_AT_	(		file,
			line,
			message,
			result_type )

Value:

::testing::internal::AssertHelper(result_type, file, line, message) \
  = ::testing::Message()

GTEST_NONFATAL_FAILURE_

#define GTEST_NONFATAL_FAILURE_

(

message

)

Value:

GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)

GTEST_REFERENCE_TO_CONST_

#define GTEST_REFERENCE_TO_CONST_

(

T

)

Value:

GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))

GTEST_REMOVE_CONST_

#define GTEST_REMOVE_CONST_

(

T

)

Value:

typename ::testing::internal::RemoveConst<T>::type

GTEST_REMOVE_REFERENCE_

#define GTEST_REMOVE_REFERENCE_

(

T

)

Value:

typename ::testing::internal::RemoveReference<T>::type

GTEST_REMOVE_REFERENCE_AND_CONST_

#define GTEST_REMOVE_REFERENCE_AND_CONST_

(

T

)

Value:

GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))

GTEST_SUCCESS_

#define GTEST_SUCCESS_

(

message

)

Value:

GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)

GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_

#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_

(

statement

)

Value:

if (::testing::internal::AlwaysTrue()) { statement; }

GTEST_TEST_

#define GTEST_TEST_	(		test_case_name,
			test_name,
			parent_class,
			parent_id )

Value:

class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
 public:\
  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
 private:\
  virtual void TestBody();\
  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
};\
\
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
  ::test_info_ =\
    ::testing::internal::MakeAndRegisterTestInfo(\
        #test_case_name, #test_name, NULL, NULL, \
        ::testing::internal::CodeLocation(__FILE__, __LINE__), \
        (parent_id), \
        parent_class::SetUpTestCase, \
        parent_class::TearDownTestCase, \
        new ::testing::internal::TestFactoryImpl<\
            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()

GTEST_TEST_ANY_THROW_

#define GTEST_TEST_ANY_THROW_	(		statement,
			fail )

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::AlwaysTrue()) { \
  bool gtest_caught_any = false; \
  try { \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  } \
  catch (...) { \
    gtest_caught_any = true; \
  } \
  if (!gtest_caught_any) { \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
  } \
} else \
  GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
    fail("Expected: " #statement " throws an exception.\n" \
         "  Actual: it doesn't.")

GTEST_TEST_BOOLEAN_

#define GTEST_TEST_BOOLEAN_	(		expression,
			text,
			actual,
			expected,
			fail )

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (const ::testing::AssertionResult gtest_ar_ = \
    ::testing::AssertionResult(expression)) \
  ; \
else \
  fail(::testing::internal::GetBoolAssertionFailureMessage(\
      gtest_ar_, text, #actual, #expected).c_str())

GTEST_TEST_CLASS_NAME_

#define GTEST_TEST_CLASS_NAME_	(		test_case_name,
			test_name )

Value:

test_case_name##_##test_name##_Test

GTEST_TEST_NO_FATAL_FAILURE_

#define GTEST_TEST_NO_FATAL_FAILURE_	(		statement,
			fail )

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::AlwaysTrue()) { \
  ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
  } \
} else \
  GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
    fail("Expected: " #statement " doesn't generate new fatal " \
         "failures in the current thread.\n" \
         "  Actual: it does.")

GTEST_TEST_NO_THROW_

#define GTEST_TEST_NO_THROW_	(		statement,
			fail )

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::AlwaysTrue()) { \
  try { \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  } \
  catch (...) { \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
  } \
} else \
  GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
    fail("Expected: " #statement " doesn't throw an exception.\n" \
         "  Actual: it throws.")

GTEST_TEST_THROW_

#define GTEST_TEST_THROW_	(		statement,
			expected_exception,
			fail )

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::ConstCharPtr gtest_msg = "") { \
  bool gtest_caught_expected = false; \
  try { \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
  } \
  catch (expected_exception const&) { \
    gtest_caught_expected = true; \
  } \
  catch (...) { \
    gtest_msg.value = \
        "Expected: " #statement " throws an exception of type " \
        #expected_exception ".\n  Actual: it throws a different type."; \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
  } \
  if (!gtest_caught_expected) { \
    gtest_msg.value = \
        "Expected: " #statement " throws an exception of type " \
        #expected_exception ".\n  Actual: it throws nothing."; \
    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
  } \
} else \
  GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
    fail(gtest_msg.value)