gtest.h File Reference

#include <limits>
#include <memory>
#include <ostream>
#include <vector>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <type_traits>
#include <sys/types.h>
#include <sys/stat.h>
#include <string>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <tuple>
#include <utility>
#include <unistd.h>
#include <strings.h>
#include <regex.h>
#include <typeinfo>
#include <float.h>
#include <iomanip>
#include <map>
#include <set>
#include <functional>
#include <iterator>
#include <assert.h>
#include <iosfwd>

Go to the source code of this file.

Classes
struct	testing::internal::StaticAssertTypeEqHelper< T1, T2 >
struct	testing::internal::StaticAssertTypeEqHelper< T, T >
struct	testing::internal::IsSame< T, U >
struct	testing::internal::IsSame< T, T >
class	testing::internal::RE
class	testing::internal::GTestLog
struct	testing::internal::AddReference< T >
struct	testing::internal::AddReference< T & >
struct	testing::internal::ConstRef< T >
struct	testing::internal::ConstRef< T & >
class	testing::internal::Mutex
class	testing::internal::GTestMutexLock
class	testing::internal::ThreadLocal< T >
struct	testing::internal::bool_constant< bool_value >
struct	testing::internal::is_same< T, U >
struct	testing::internal::is_same< T, T >
struct	testing::internal::IteratorTraits< Iterator >
struct	testing::internal::IteratorTraits< T * >
struct	testing::internal::IteratorTraits< const T * >
class	testing::internal::TypeWithSize< size >
class	testing::internal::TypeWithSize< 4 >
class	testing::internal::TypeWithSize< 8 >
class	testing::Message
class	testing::internal::IgnoredValue
class	testing::internal::FloatingPoint< RawType >
class	testing::internal::TypeIdHelper< T >
class	testing::internal::TestFactoryBase
class	testing::internal::TestFactoryImpl< TestClass >
struct	testing::internal::CodeLocation
struct	testing::internal::SuiteApiResolver< T >
struct	testing::internal::ConstCharPtr
class	testing::internal::Random
struct	testing::internal::CompileAssertTypesEqual< T1, T2 >
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]>
class	testing::internal::ImplicitlyConvertible< From, To >
struct	testing::internal::IsAProtocolMessage< T >
struct	testing::internal::IsHashTable< T >
struct	testing::internal::IsRecursiveContainerImpl< C, bool >
struct	testing::internal::IsRecursiveContainerImpl< C, false >
struct	testing::internal::IsRecursiveContainerImpl< C, true >
struct	testing::internal::IsRecursiveContainer< C >
struct	testing::internal::EnableIf< bool >
struct	testing::internal::EnableIf< true >
struct	testing::internal::RelationToSourceReference
struct	testing::internal::RelationToSourceCopy
class	testing::internal::NativeArray< Element >
struct	testing::internal::IndexSequence< Is >
struct	testing::internal::DoubleSequence< plus_one, T, sizeofT >
struct	testing::internal::DoubleSequence< true, IndexSequence< I... >, sizeofT >
struct	testing::internal::DoubleSequence< false, IndexSequence< I... >, sizeofT >
struct	testing::internal::MakeIndexSequence< N >
struct	testing::internal::MakeIndexSequence< 0 >
struct	testing::internal::ElemFromListImpl< T, size_t, size_t >
struct	testing::internal::ElemFromListImpl< T, I, I >
struct	testing::internal::ElemFromList< N, I, T >
struct	testing::internal::ElemFromList< N, IndexSequence< I... >, T... >
class	testing::internal::FlatTuple< T >
struct	testing::internal::FlatTupleElemBase< Derived, I >
struct	testing::internal::FlatTupleElemBase< FlatTuple< T... >, I >
struct	testing::internal::FlatTupleBase< Derived, Idx >
struct	testing::internal::FlatTupleBase< FlatTuple< T... >, IndexSequence< Idx... > >
class	testing::internal::FlatTuple< T >
class	testing::internal2::TypeWithoutFormatter< T, kTypeKind >
class	testing::internal2::TypeWithoutFormatter< T, kProtobuf >
class	testing::internal2::TypeWithoutFormatter< T, kConvertibleToInteger >
class	testing::internal::FormatForComparison< ToPrint, OtherOperand >
class	testing::internal::FormatForComparison< ToPrint[N], OtherOperand >
class	testing::internal::UniversalPrinter< T >
struct	testing::internal::WrapPrinterType< type >
class	testing::internal::UniversalPrinter< T >
class	testing::internal::UniversalPrinter< T[N]>
class	testing::internal::UniversalPrinter< T & >
class	testing::internal::UniversalTersePrinter< T >
class	testing::internal::UniversalTersePrinter< T & >
class	testing::internal::UniversalTersePrinter< T[N]>
class	testing::internal::UniversalTersePrinter< const char * >
class	testing::internal::UniversalTersePrinter< char * >
class	testing::internal::UniversalTersePrinter< const wchar_t * >
class	testing::internal::UniversalTersePrinter< wchar_t * >
struct	testing::TestParamInfo< ParamType >
struct	testing::PrintToStringParamName
class	testing::internal::ParamGeneratorInterface< T >
class	testing::internal::ParamGenerator< T >
class	testing::internal::ParamIteratorInterface< T >
class	testing::internal::ParamIterator< T >
class	testing::internal::ParamGeneratorInterface< T >
class	testing::internal::ParamGenerator< T >
class	testing::internal::RangeGenerator< T, IncrementT >
class	testing::internal::ValuesInIteratorRangeGenerator< T >
struct	testing::internal::ParamNameGenFunc< ParamType >
class	testing::internal::ParameterizedTestFactory< TestClass >
class	testing::internal::TestMetaFactoryBase< ParamType >
class	testing::internal::TestMetaFactory< TestSuite >
class	testing::internal::ParameterizedTestSuiteInfoBase
class	testing::internal::ParameterizedTestSuiteInfo< TestSuite >
class	testing::internal::ParameterizedTestSuiteRegistry
class	testing::internal::ValueArray< Ts >
class	testing::internal::CartesianProductGenerator2< T1, T2 >
class	testing::internal::CartesianProductGenerator3< T1, T2, T3 >
class	testing::internal::CartesianProductGenerator4< T1, T2, T3, T4 >
class	testing::internal::CartesianProductGenerator5< T1, T2, T3, T4, T5 >
class	testing::internal::CartesianProductGenerator6< T1, T2, T3, T4, T5, T6 >
class	testing::internal::CartesianProductGenerator7< T1, T2, T3, T4, T5, T6, T7 >
class	testing::internal::CartesianProductGenerator8< T1, T2, T3, T4, T5, T6, T7, T8 >
class	testing::internal::CartesianProductGenerator9< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
class	testing::internal::CartesianProductGenerator10< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
class	testing::internal::CartesianProductHolder2< Generator1, Generator2 >
class	testing::internal::CartesianProductHolder3< Generator1, Generator2, Generator3 >
class	testing::internal::CartesianProductHolder4< Generator1, Generator2, Generator3, Generator4 >
class	testing::internal::CartesianProductHolder5< Generator1, Generator2, Generator3, Generator4, Generator5 >
class	testing::internal::CartesianProductHolder6< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6 >
class	testing::internal::CartesianProductHolder7< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7 >
class	testing::internal::CartesianProductHolder8< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8 >
class	testing::internal::CartesianProductHolder9< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8, Generator9 >
class	testing::internal::CartesianProductHolder10< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8, Generator9, Generator10 >
class	testing::Test
class	testing::TestProperty
class	testing::TestResult
class	testing::TestInfo
class	testing::TestSuite
class	testing::Environment
class	testing::TestEventListener
class	testing::EmptyTestEventListener
class	testing::TestEventListeners
class	testing::UnitTest
struct	testing::internal::faketype
class	testing::internal::EqHelper< lhs_is_null_literal >
class	testing::internal::EqHelper< true >
class	testing::internal::AssertHelper
class	testing::WithParamInterface< T >
class	testing::TestWithParam< T >
class	testing::ScopedTrace

Namespaces
	testing
	testing::internal
	testing::internal::posix
	proto2
	testing::internal::edit_distance
	testing::internal2
	testing_internal

Macros
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
#define	GTEST_DEV_EMAIL_   "googletestframework@@googlegroups.com"
#define	GTEST_FLAG_PREFIX_   "gtest_"
#define	GTEST_FLAG_PREFIX_DASH_   "gtest-"
#define	GTEST_FLAG_PREFIX_UPPER_   "GTEST_"
#define	GTEST_NAME_   "Google Test"
#define	GTEST_PROJECT_URL_   "https://github.com/google/googletest/"
#define	GTEST_INIT_GOOGLE_TEST_NAME_   "testing::InitGoogleTest"
#define	GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
#define	GTEST_DISABLE_MSC_WARNINGS_POP_()
#define	GTEST_DISABLE_MSC_DEPRECATED_PUSH_()   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
#define	GTEST_DISABLE_MSC_DEPRECATED_POP_()   GTEST_DISABLE_MSC_WARNINGS_POP_()
#define	GTEST_HAS_POSIX_RE   (!GTEST_OS_WINDOWS)
#define	GTEST_USES_POSIX_RE   1
#define	GTEST_HAS_EXCEPTIONS   0
#define	GTEST_HAS_STD_STRING   1
#define	GTEST_HAS_GLOBAL_STRING   0
#define	GTEST_HAS_STD_WSTRING   (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
#define	GTEST_HAS_GLOBAL_WSTRING   (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
#define	GTEST_HAS_RTTI   1
#define	GTEST_HAS_PTHREAD
#define	GTEST_HAS_CLONE   0
#define	GTEST_HAS_STREAM_REDIRECTION   1
#define	GTEST_WIDE_STRING_USES_UTF16_   (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
#define	GTEST_AMBIGUOUS_ELSE_BLOCKER_   switch (0) case 0: default:
#define	GTEST_ATTRIBUTE_UNUSED_
#define	GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
#define	GTEST_DISALLOW_ASSIGN_(type)   void operator=(type const &) = delete
#define	GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
#define	GTEST_MUST_USE_RESULT_
#define	GTEST_INTENTIONAL_CONST_COND_PUSH_()   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
#define	GTEST_INTENTIONAL_CONST_COND_POP_()   GTEST_DISABLE_MSC_WARNINGS_POP_()
#define	GTEST_HAS_SEH   0
#define	GTEST_IS_THREADSAFE
#define	GTEST_API_
#define	GTEST_DEFAULT_DEATH_TEST_STYLE   "fast"
#define	GTEST_NO_INLINE_
#define	GTEST_HAS_CXXABI_H_   0
#define	GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
#define	GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
#define	GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
#define	GTEST_COMPILE_ASSERT_(expr, msg)   static_assert(expr, #msg)
#define	GTEST_ARRAY_SIZE_(array)   (sizeof(array) / sizeof(array[0]))
#define	GTEST_LOG_(severity)
#define	GTEST_CHECK_(condition)
#define	GTEST_CHECK_POSIX_SUCCESS_(posix_call)
#define	GTEST_ADD_REFERENCE_(T)   typename ::testing::internal::AddReference<T>::type
#define	GTEST_REFERENCE_TO_CONST_(T)   typename ::testing::internal::ConstRef<T>::type
#define	GTEST_DECLARE_STATIC_MUTEX_(mutex)   extern ::testing::internal::Mutex mutex
#define	GTEST_DEFINE_STATIC_MUTEX_(mutex)   ::testing::internal::Mutex mutex
#define	GTEST_PATH_SEP_   "/"
#define	GTEST_HAS_ALT_PATH_SEP_   0
#define	GTEST_SNPRINTF_   snprintf
#define	GTEST_FLAG(name)   FLAGS_gtest_##name
#define	GTEST_USE_OWN_FLAGFILE_FLAG_   1
#define	GTEST_FLAG_SAVER_   ::testing::internal::GTestFlagSaver
#define	GTEST_DECLARE_bool_(name)   GTEST_API_ extern bool GTEST_FLAG(name)
#define	GTEST_DECLARE_int32_(name)   GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
#define	GTEST_DECLARE_string_(name)   GTEST_API_ extern ::std::string GTEST_FLAG(name)
#define	GTEST_DEFINE_bool_(name, default_val, doc)   GTEST_API_ bool GTEST_FLAG(name) = (default_val)
#define	GTEST_DEFINE_int32_(name, default_val, doc)   GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
#define	GTEST_DEFINE_string_(name, default_val, doc)   GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
#define	GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
#define	GTEST_LOCK_EXCLUDED_(locks)
#define	GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
#define	GTEST_CONCAT_TOKEN_(foo, bar)   GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
#define	GTEST_CONCAT_TOKEN_IMPL_(foo, bar)   foo ## bar
#define	GTEST_STRINGIFY_(name)   #name
#define	GTEST_IS_NULL_LITERAL_(x)   decltype(::testing::internal::IsNullLiteralHelper(x))::value
#define	GTEST_REMOVE_REFERENCE_(T)   typename ::testing::internal::RemoveReference<T>::type
#define	GTEST_REMOVE_CONST_(T)   typename ::testing::internal::RemoveConst<T>::type
#define	GTEST_REMOVE_REFERENCE_AND_CONST_(T)   GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
#define	GTEST_MESSAGE_AT_(file, line, message, result_type)
#define	GTEST_MESSAGE_(message, result_type)   GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
#define	GTEST_FATAL_FAILURE_(message)   return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
#define	GTEST_NONFATAL_FAILURE_(message)   GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
#define	GTEST_SUCCESS_(message)   GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
#define	GTEST_SKIP_(message)   return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
#define	GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)   if (::testing::internal::AlwaysTrue()) { 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_suite_name, test_name)   test_suite_name##_##test_name##_Test
#define	GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)
#define	GTEST_INTERNAL_DEPRECATED(message)
#define	GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
#define	GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
#define	GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#define	GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)
#define	GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType)
#define	GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
#define	GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator)
#define	EXPECT_DEATH_IF_SUPPORTED(statement, regex)   GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
#define	ASSERT_DEATH_IF_SUPPORTED(statement, regex)   GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
#define	GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
#define	GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
#define	TEST_P(test_suite_name, test_name)
#define	INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, generator, ...)
#define	INSTANTIATE_TEST_CASE_P   INSTANTIATE_TEST_SUITE_P
#define	GTEST_INCLUDE_GTEST_GTEST_PROD_H_
#define	FRIEND_TEST(test_case_name, test_name)   friend class test_case_name##_##test_name##_Test
#define	GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
#define	GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
#define	GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
#define	GTEST_ASSERT_(expression, on_failure)
#define	GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)
#define	GTEST_PRED1_(pred, v1, on_failure)
#define	EXPECT_PRED_FORMAT1(pred_format, v1)   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_PRED1(pred, v1)   GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_PRED_FORMAT1(pred_format, v1)   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
#define	ASSERT_PRED1(pred, v1)   GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
#define	GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)
#define	GTEST_PRED2_(pred, v1, v2, on_failure)
#define	EXPECT_PRED_FORMAT2(pred_format, v1, v2)   GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_PRED2(pred, v1, v2)   GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_PRED_FORMAT2(pred_format, v1, v2)   GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
#define	ASSERT_PRED2(pred, v1, v2)   GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
#define	GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)
#define	GTEST_PRED3_(pred, v1, v2, v3, on_failure)
#define	EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3)   GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_PRED3(pred, v1, v2, v3)   GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3)   GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
#define	ASSERT_PRED3(pred, v1, v2, v3)   GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
#define	GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)
#define	GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)
#define	EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4)   GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_PRED4(pred, v1, v2, v3, v4)   GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4)   GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
#define	ASSERT_PRED4(pred, v1, v2, v3, v4)   GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
#define	GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)
#define	GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)
#define	EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5)   GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_PRED5(pred, v1, v2, v3, v4, v5)   GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5)   GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
#define	ASSERT_PRED5(pred, v1, v2, v3, v4, v5)   GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
#define	GTEST_IMPL_CMP_HELPER_(op_name, op)
#define	GTEST_SKIP()   GTEST_SKIP_("Skipped")
#define	ADD_FAILURE()   GTEST_NONFATAL_FAILURE_("Failed")
#define	ADD_FAILURE_AT(file, line)
#define	GTEST_FAIL()   GTEST_FATAL_FAILURE_("Failed")
#define	FAIL()   GTEST_FAIL()
#define	GTEST_SUCCEED()   GTEST_SUCCESS_("Succeeded")
#define	SUCCEED()   GTEST_SUCCEED()
#define	EXPECT_THROW(statement, expected_exception)   GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_NO_THROW(statement)   GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define	EXPECT_ANY_THROW(statement)   GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
#define	ASSERT_THROW(statement, expected_exception)   GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
#define	ASSERT_NO_THROW(statement)   GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
#define	ASSERT_ANY_THROW(statement)   GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
#define	EXPECT_TRUE(condition)
#define	EXPECT_FALSE(condition)
#define	ASSERT_TRUE(condition)
#define	ASSERT_FALSE(condition)
#define	EXPECT_EQ(val1, val2)
#define	EXPECT_NE(val1, val2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
#define	EXPECT_LE(val1, val2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define	EXPECT_LT(val1, val2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define	EXPECT_GE(val1, val2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define	EXPECT_GT(val1, val2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
#define	GTEST_ASSERT_EQ(val1, val2)
#define	GTEST_ASSERT_NE(val1, val2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
#define	GTEST_ASSERT_LE(val1, val2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define	GTEST_ASSERT_LT(val1, val2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define	GTEST_ASSERT_GE(val1, val2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define	GTEST_ASSERT_GT(val1, val2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
#define	ASSERT_EQ(val1, val2)   GTEST_ASSERT_EQ(val1, val2)
#define	ASSERT_NE(val1, val2)   GTEST_ASSERT_NE(val1, val2)
#define	ASSERT_LE(val1, val2)   GTEST_ASSERT_LE(val1, val2)
#define	ASSERT_LT(val1, val2)   GTEST_ASSERT_LT(val1, val2)
#define	ASSERT_GE(val1, val2)   GTEST_ASSERT_GE(val1, val2)
#define	ASSERT_GT(val1, val2)   GTEST_ASSERT_GT(val1, val2)
#define	EXPECT_STREQ(s1, s2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
#define	EXPECT_STRNE(s1, s2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define	EXPECT_STRCASEEQ(s1, s2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
#define	EXPECT_STRCASENE(s1, s2)   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
#define	ASSERT_STREQ(s1, s2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
#define	ASSERT_STRNE(s1, s2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define	ASSERT_STRCASEEQ(s1, s2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
#define	ASSERT_STRCASENE(s1, s2)   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
#define	EXPECT_FLOAT_EQ(val1, val2)
#define	EXPECT_DOUBLE_EQ(val1, val2)
#define	ASSERT_FLOAT_EQ(val1, val2)
#define	ASSERT_DOUBLE_EQ(val1, val2)
#define	EXPECT_NEAR(val1, val2, abs_error)
#define	ASSERT_NEAR(val1, val2, abs_error)
#define	ASSERT_NO_FATAL_FAILURE(statement)   GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
#define	EXPECT_NO_FATAL_FAILURE(statement)   GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
#define	SCOPED_TRACE(message)
#define	GTEST_TEST(test_suite_name, test_name)
#define	TEST(test_suite_name, test_name)   GTEST_TEST(test_suite_name, test_name)
#define	TEST_F(test_fixture, test_name)

Typedefs
typedef ::std::string	testing::internal::string
typedef ::std::wstring	testing::internal::wstring
typedef GTestMutexLock	testing::internal::MutexLock
typedef bool_constant< false >	testing::internal::false_type
typedef bool_constant< true >	testing::internal::true_type
typedef long long	testing::internal::BiggestInt
typedef struct stat	testing::internal::posix::StatStruct
typedef TypeWithSize< 4 >::Int	testing::internal::Int32
typedef TypeWithSize< 4 >::UInt	testing::internal::UInt32
typedef TypeWithSize< 8 >::Int	testing::internal::Int64
typedef TypeWithSize< 8 >::UInt	testing::internal::UInt64
typedef TypeWithSize< 8 >::Int	testing::internal::TimeInMillis
typedef FloatingPoint< float >	testing::internal::Float
typedef FloatingPoint< double >	testing::internal::Double
typedef const void *	testing::internal::TypeId
using	testing::internal::SetUpTestSuiteFunc = void(*)()
using	testing::internal::TearDownTestSuiteFunc = void(*)()
using	testing::internal::SetUpTearDownSuiteFuncType = void(*)()
typedef int	testing::internal::IsContainer
typedef char	testing::internal::IsNotContainer
typedef ::std::vector< ::std::string >	testing::internal::Strings
template<class TestCase >
using	testing::internal::ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo< TestCase >
typedef internal::TimeInMillis	testing::TimeInMillis

Enumerations
enum	testing::internal::GTestLogSeverity { testing::internal::GTEST_INFO, testing::internal::GTEST_WARNING, testing::internal::GTEST_ERROR, testing::internal::GTEST_FATAL }
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 }
enum	testing::internal2::TypeKind { testing::internal2::kProtobuf, testing::internal2::kConvertibleToInteger, testing::internal2::kOtherType }
enum	testing::internal::DefaultPrinterType { testing::internal::kPrintContainer, testing::internal::kPrintPointer, testing::internal::kPrintFunctionPointer, testing::internal::kPrintOther }
enum	testing::internal::GTestColor { testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW }

Functions
GTEST_API_ bool	testing::internal::IsTrue (bool condition)
GTEST_API_ ::std::string	testing::internal::FormatFileLocation (const char *file, int line)
GTEST_API_ ::std::string	testing::internal::FormatCompilerIndependentFileLocation (const char *file, int line)
void	testing::internal::LogToStderr ()
void	testing::internal::FlushInfoLog ()
template<typename To >
To	testing::internal::ImplicitCast_ (To x)
template<typename To , typename From >
To	testing::internal::DownCast_ (From *f)
template<class Derived , class Base >
Derived *	testing::internal::CheckedDowncastToActualType (Base *base)
void	testing::internal::CaptureStdout ()
std::string	testing::internal::GetCapturedStdout ()
void	testing::internal::CaptureStderr ()
std::string	testing::internal::GetCapturedStderr ()
size_t	testing::internal::GetFileSize (FILE *file)
std::string	testing::internal::ReadEntireFile (FILE *file)
GTEST_API_ std::vector< std::string >	testing::internal::GetArgvs ()
size_t	testing::internal::GetThreadCount ()
bool	testing::internal::IsAlpha (char ch)
bool	testing::internal::IsAlNum (char ch)
bool	testing::internal::IsDigit (char ch)
bool	testing::internal::IsLower (char ch)
bool	testing::internal::IsSpace (char ch)
bool	testing::internal::IsUpper (char ch)
bool	testing::internal::IsXDigit (char ch)
bool	testing::internal::IsXDigit (wchar_t ch)
char	testing::internal::ToLower (char ch)
char	testing::internal::ToUpper (char ch)
std::string	testing::internal::StripTrailingSpaces (std::string str)
int	testing::internal::posix::FileNo (FILE *file)
int	testing::internal::posix::IsATTY (int fd)
int	testing::internal::posix::Stat (const char *path, StatStruct *buf)
int	testing::internal::posix::StrCaseCmp (const char *s1, const char *s2)
char *	testing::internal::posix::StrDup (const char *src)
int	testing::internal::posix::RmDir (const char *dir)
bool	testing::internal::posix::IsDir (const StatStruct &st)
const char *	testing::internal::posix::StrNCpy (char *dest, const char *src, size_t n)
int	testing::internal::posix::ChDir (const char *dir)
FILE *	testing::internal::posix::FOpen (const char *path, const char *mode)
FILE *	testing::internal::posix::FReopen (const char *path, const char *mode, FILE *stream)
FILE *	testing::internal::posix::FDOpen (int fd, const char *mode)
int	testing::internal::posix::FClose (FILE *fp)
int	testing::internal::posix::Read (int fd, void *buf, unsigned int count)
int	testing::internal::posix::Write (int fd, const void *buf, unsigned int count)
int	testing::internal::posix::Close (int fd)
const char *	testing::internal::posix::StrError (int errnum)
const char *	testing::internal::posix::GetEnv (const char *name)
void	testing::internal::posix::Abort ()
bool	testing::internal::ParseInt32 (const Message &src_text, const char *str, Int32 *value)
bool	testing::internal::BoolFromGTestEnv (const char *flag, bool default_value)
Int32	testing::internal::Int32FromGTestEnv (const char *flag, Int32 default_value)
std::string	testing::internal::OutputFlagAlsoCheckEnvVar ()
const char *	testing::internal::StringFromGTestEnv (const char *flag, const char *default_value)
std::ostream &	testing::operator<< (std::ostream &os, const Message &sb)
template<typename T >
std::string	testing::internal::StreamableToString (const T &streamable)
	GTEST_DISABLE_MSC_WARNINGS_PUSH_ (4251) namespace testing
template<typename T >
::std::string	testing::PrintToString (const T &value)
std::true_type	testing::internal::IsNullLiteralHelper (Secret *)
std::false_type	testing::internal::IsNullLiteralHelper (IgnoredValue)
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 ()
SetUpTearDownSuiteFuncType	testing::internal::GetNotDefaultOrNull (SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def)
GTEST_API_ TestInfo *	testing::internal::MakeAndRegisterTestInfo (const char *test_suite_name, const char *name, const char *type_param, const char *value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, TearDownTestSuiteFunc 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 , class Iterator = decltype(::std::declval<const C&>().begin()), class = decltype(::std::declval<const C&>().end()), class = decltype(++::std::declval<Iterator&>()), class = decltype(*::std::declval<Iterator>()), class = typename C::const_iterator>
IsContainer	testing::internal::IsContainerTest (int)
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])
GTEST_API_ void	testing::internal2::PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ::std::ostream *os)
template<typename Char , typename CharTraits , typename T >
::std::basic_ostream< Char, CharTraits > &	testing::internal2::operator<< (::std::basic_ostream< Char, CharTraits > &os, const T &x)
template<typename T >
void	testing_internal::DefaultPrintNonContainerTo (const T &value, ::std::ostream *os)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)
	testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (wchar_t, ::std::wstring)
template<typename T1 , typename T2 >
std::string	testing::internal::FormatForComparisonFailureMessage (const T1 &value, const T2 &)
template<typename T >
void	testing::internal::UniversalPrint (const T &value, ::std::ostream *os)
template<typename C >
void	testing::internal::DefaultPrintTo (WrapPrinterType< kPrintContainer >, const C &container, ::std::ostream *os)
template<typename T >
void	testing::internal::DefaultPrintTo (WrapPrinterType< kPrintPointer >, T *p, ::std::ostream *os)
template<typename T >
void	testing::internal::DefaultPrintTo (WrapPrinterType< kPrintFunctionPointer >, T *p, ::std::ostream *os)
template<typename T >
void	testing::internal::DefaultPrintTo (WrapPrinterType< kPrintOther >, const T &value, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintTo (const T &value, ::std::ostream *os)
void	testing::internal::PrintTo (unsigned char c, ::std::ostream *os)
void	testing::internal::PrintTo (signed char c, ::std::ostream *os)
void	testing::internal::PrintTo (char c, ::std::ostream *os)
void	testing::internal::PrintTo (bool x, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (wchar_t wc, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (const char *s, ::std::ostream *os)
void	testing::internal::PrintTo (char *s, ::std::ostream *os)
void	testing::internal::PrintTo (const signed char *s, ::std::ostream *os)
void	testing::internal::PrintTo (signed char *s, ::std::ostream *os)
void	testing::internal::PrintTo (const unsigned char *s, ::std::ostream *os)
void	testing::internal::PrintTo (unsigned char *s, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintTo (const wchar_t *s, ::std::ostream *os)
void	testing::internal::PrintTo (wchar_t *s, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintRawArrayTo (const T a[], size_t count, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintStringTo (const ::std::string &s, ::std::ostream *os)
void	testing::internal::PrintTo (const ::std::string &s, ::std::ostream *os)
GTEST_API_ void	testing::internal::PrintWideStringTo (const ::std::wstring &s, ::std::ostream *os)
void	testing::internal::PrintTo (const ::std::wstring &s, ::std::ostream *os)
void	testing::internal::PrintTo (std::nullptr_t, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintTo (std::reference_wrapper< T > ref, ::std::ostream *os)
template<typename T >
void	testing::internal::PrintTupleTo (const T &, std::integral_constant< size_t, 0 >, ::std::ostream *)
template<typename T , size_t I>
void	testing::internal::PrintTupleTo (const T &t, std::integral_constant< size_t, I >, ::std::ostream *os)
template<typename... Types>
void	testing::internal::PrintTo (const ::std::tuple< Types... > &t, ::std::ostream *os)
template<typename T1 , typename T2 >
void	testing::internal::PrintTo (const ::std::pair< T1, T2 > &value, ::std::ostream *os)
template<typename T >
void	testing::internal::UniversalPrintArray (const T *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	testing::internal::UniversalPrintArray (const char *begin, size_t len, ::std::ostream *os)
GTEST_API_ void	testing::internal::UniversalPrintArray (const wchar_t *begin, size_t len, ::std::ostream *os)
template<typename T >
void	testing::internal::UniversalTersePrint (const T &value, ::std::ostream *os)
template<typename Tuple >
void	testing::internal::TersePrintPrefixToStrings (const Tuple &, std::integral_constant< size_t, 0 >, Strings *)
template<typename Tuple , size_t I>
void	testing::internal::TersePrintPrefixToStrings (const Tuple &t, std::integral_constant< size_t, I >, Strings *strings)
template<typename Tuple >
Strings	testing::internal::UniversalTersePrintTupleFieldsToStrings (const Tuple &value)
	testing::GTEST_DECLARE_string_ (death_test_style)
GTEST_API_ void	testing::internal::ReportInvalidTestSuiteType (const char *test_suite_name, CodeLocation code_location)
template<class ParamType >
std::string	testing::internal::DefaultParamName (const TestParamInfo< ParamType > &info)
template<class ParamType , class ParamNameGenFunctor >
ParamNameGenFunctor	testing::internal::GetParamNameGen (ParamNameGenFunctor func)
template<class ParamType >
ParamNameGenFunc< ParamType >::Type *	testing::internal::GetParamNameGen ()
template<class Container >
internal::ParamGenerator< typename Container::value_type >	testing::ValuesIn (const Container &container)
template<typename T , typename IncrementT >
internal::ParamGenerator< T >	testing::Range (T start, T end, IncrementT step)
template<typename T >
internal::ParamGenerator< T >	testing::Range (T start, T end)
template<typename ForwardIterator >
internal::ParamGenerator< typename ::testing::internal::IteratorTraits< ForwardIterator >::value_type >	testing::ValuesIn (ForwardIterator begin, ForwardIterator end)
template<typename T , size_t N>
internal::ParamGenerator< T >	testing::ValuesIn (const T(&array)[N])
template<typename... T>
internal::ValueArray< T... >	testing::Values (T... v)
internal::ParamGenerator< bool >	testing::Bool ()
template<typename Generator1 , typename Generator2 >
internal::CartesianProductHolder2< Generator1, Generator2 >	testing::Combine (const Generator1 &g1, const Generator2 &g2)
template<typename Generator1 , typename Generator2 , typename Generator3 >
internal::CartesianProductHolder3< Generator1, Generator2, Generator3 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 >
internal::CartesianProductHolder4< Generator1, Generator2, Generator3, Generator4 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 >
internal::CartesianProductHolder5< Generator1, Generator2, Generator3, Generator4, Generator5 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 , typename Generator6 >
internal::CartesianProductHolder6< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5, const Generator6 &g6)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 , typename Generator6 , typename Generator7 >
internal::CartesianProductHolder7< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5, const Generator6 &g6, const Generator7 &g7)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 , typename Generator6 , typename Generator7 , typename Generator8 >
internal::CartesianProductHolder8< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5, const Generator6 &g6, const Generator7 &g7, const Generator8 &g8)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 , typename Generator6 , typename Generator7 , typename Generator8 , typename Generator9 >
internal::CartesianProductHolder9< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8, Generator9 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5, const Generator6 &g6, const Generator7 &g7, const Generator8 &g8, const Generator9 &g9)
template<typename Generator1 , typename Generator2 , typename Generator3 , typename Generator4 , typename Generator5 , typename Generator6 , typename Generator7 , typename Generator8 , typename Generator9 , typename Generator10 >
internal::CartesianProductHolder10< Generator1, Generator2, Generator3, Generator4, Generator5, Generator6, Generator7, Generator8, Generator9, Generator10 >	testing::Combine (const Generator1 &g1, const Generator2 &g2, const Generator3 &g3, const Generator4 &g4, const Generator5 &g5, const Generator6 &g6, const Generator7 &g7, const Generator8 &g8, const Generator9 &g9, const Generator10 &g10)
template<typename Pred , typename T1 >
AssertionResult	testing::AssertPred1Helper (const char *pred_text, const char *e1, Pred pred, const T1 &v1)
template<typename Pred , typename T1 , typename T2 >
AssertionResult	testing::AssertPred2Helper (const char *pred_text, const char *e1, const char *e2, Pred pred, const T1 &v1, const T2 &v2)
template<typename Pred , typename T1 , typename T2 , typename T3 >
AssertionResult	testing::AssertPred3Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3)
template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 >
AssertionResult	testing::AssertPred4Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, const char *e4, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4)
template<typename Pred , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
AssertionResult	testing::AssertPred5Helper (const char *pred_text, const char *e1, const char *e2, const char *e3, const char *e4, const char *e5, Pred pred, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5)
Environment *	testing::AddGlobalTestEnvironment (Environment *env)
GTEST_API_ void	testing::InitGoogleTest (int *argc, char **argv)
GTEST_API_ void	testing::InitGoogleTest (int *argc, wchar_t **argv)
template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperEQFailure (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
bool	testing::internal::operator== (faketype, faketype)
bool	testing::internal::operator!= (faketype, faketype)
template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
GTEST_API_ AssertionResult	testing::internal::CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, BiggestInt lhs, BiggestInt rhs)
template<typename T1 , typename T2 >
AssertionResult	testing::internal::CmpHelperOpFailure (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
	testing::internal::GTEST_IMPL_CMP_HELPER_ (NE, !=)
	testing::internal::GTEST_IMPL_CMP_HELPER_ (LE,<=)
	testing::internal::GTEST_IMPL_CMP_HELPER_ (LT,<)
	testing::internal::GTEST_IMPL_CMP_HELPER_ (GE, >=)
	testing::internal::GTEST_IMPL_CMP_HELPER_ (GT, >)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASEEQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ AssertionResult	testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
GTEST_API_ AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
GTEST_API_ AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
GTEST_API_ AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
GTEST_API_ AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
GTEST_API_ AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
GTEST_API_ AssertionResult	testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::wstring &needle, const ::std::wstring &haystack)
GTEST_API_ AssertionResult	testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::wstring &needle, const ::std::wstring &haystack)
template<typename RawType >
AssertionResult	testing::internal::CmpHelperFloatingPointEQ (const char *lhs_expression, const char *rhs_expression, RawType lhs_value, RawType rhs_value)
GTEST_API_ AssertionResult	testing::internal::DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
GTEST_API_	testing::internal::GTEST_ATTRIBUTE_PRINTF_ (2, 3) void ColoredPrintf(GTestColor color
GTEST_API_ AssertionResult	testing::FloatLE (const char *expr1, const char *expr2, float val1, float val2)
GTEST_API_ AssertionResult	testing::DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
template<typename T1 , typename T2 >
bool	testing::StaticAssertTypeEq ()
GTEST_API_ std::string	testing::TempDir ()
template<int &... ExplicitParameterBarrier, typename Factory >
TestInfo *	testing::RegisterTest (const char *test_suite_name, const char *test_name, const char *type_param, const char *value_param, const char *file, int line, Factory factory)
int	RUN_ALL_TESTS () GTEST_MUST_USE_RESULT_

Variables
const BiggestInt	testing::internal::kMaxBiggestInt
GTEST_API_ const char	testing::internal::kStackTraceMarker []
const size_t	testing::internal2::kProtobufOneLinerMaxLength = 50
GTEST_API_ const char *	testing::internal::fmt
class GTEST_API_ testing::ScopedTrace	testing::GTEST_ATTRIBUTE_UNUSED_

Macro Definition Documentation

ADD_FAILURE

#define ADD_FAILURE

(

)

GTEST_NONFATAL_FAILURE_("Failed")

Definition at line 16533 of file gtest.h.

ADD_FAILURE_AT

#define ADD_FAILURE_AT	(		file,
			line
	)

Value:

GTEST_MESSAGE_AT_(file, line, "Failed", \
                    ::testing::TestPartResult::kNonFatalFailure)

Definition at line 16537 of file gtest.h.

ASSERT_ANY_THROW

#define ASSERT_ANY_THROW

(

statement

)

GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

Definition at line 16578 of file gtest.h.

ASSERT_DEATH_IF_SUPPORTED

#define ASSERT_DEATH_IF_SUPPORTED	(		statement,
			regex
	)		GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)

Definition at line 10354 of file gtest.h.

ASSERT_DOUBLE_EQ

#define ASSERT_DOUBLE_EQ	(		val1,
			val2
	)

Value:

ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      val1, val2)

Definition at line 16760 of file gtest.h.

ASSERT_EQ

#define ASSERT_EQ	(		val1,
			val2
	)		GTEST_ASSERT_EQ(val1, val2)

Definition at line 16677 of file gtest.h.

ASSERT_FALSE

#define ASSERT_FALSE

(

condition

)

Value:

GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_FATAL_FAILURE_)

Definition at line 16593 of file gtest.h.

ASSERT_FLOAT_EQ

#define ASSERT_FLOAT_EQ	(		val1,
			val2
	)

Value:

ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      val1, val2)

Definition at line 16756 of file gtest.h.

ASSERT_GE

#define ASSERT_GE	(		val1,
			val2
	)		GTEST_ASSERT_GE(val1, val2)

Definition at line 16693 of file gtest.h.

ASSERT_GT

#define ASSERT_GT	(		val1,
			val2
	)		GTEST_ASSERT_GT(val1, val2)

Definition at line 16697 of file gtest.h.

ASSERT_LE

#define ASSERT_LE	(		val1,
			val2
	)		GTEST_ASSERT_LE(val1, val2)

Definition at line 16685 of file gtest.h.

ASSERT_LT

#define ASSERT_LT	(		val1,
			val2
	)		GTEST_ASSERT_LT(val1, val2)

Definition at line 16689 of file gtest.h.

ASSERT_NE

#define ASSERT_NE	(		val1,
			val2
	)		GTEST_ASSERT_NE(val1, val2)

Definition at line 16681 of file gtest.h.

ASSERT_NEAR

#define ASSERT_NEAR	(		val1,
			val2,
			abs_error
	)

Value:

ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

Definition at line 16768 of file gtest.h.

ASSERT_NO_FATAL_FAILURE

#define ASSERT_NO_FATAL_FAILURE

(

statement

)

GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)

Definition at line 16820 of file gtest.h.

ASSERT_NO_THROW

#define ASSERT_NO_THROW

(

statement

)

GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)

Definition at line 16576 of file gtest.h.

ASSERT_PRED1

#define ASSERT_PRED1	(		pred,
			v1
	)		GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)

Definition at line 14748 of file gtest.h.

ASSERT_PRED2

#define ASSERT_PRED2	(		pred,
			v1,
			v2
	)		GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)

Definition at line 14797 of file gtest.h.

ASSERT_PRED3

#define ASSERT_PRED3	(		pred,
			v1,
			v2,
			v3
	)		GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)

Definition at line 14852 of file gtest.h.

ASSERT_PRED4

#define ASSERT_PRED4	(		pred,
			v1,
			v2,
			v3,
			v4
	)		GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)

Definition at line 14913 of file gtest.h.

ASSERT_PRED5

#define ASSERT_PRED5	(		pred,
			v1,
			v2,
			v3,
			v4,
			v5
	)		GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)

Definition at line 14980 of file gtest.h.

ASSERT_PRED_FORMAT1

#define ASSERT_PRED_FORMAT1	(		pred_format,
			v1
	)		GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)

Definition at line 14746 of file gtest.h.

ASSERT_PRED_FORMAT2

#define ASSERT_PRED_FORMAT2	(		pred_format,
			v1,
			v2
	)		GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)

Definition at line 14795 of file gtest.h.

ASSERT_PRED_FORMAT3

#define ASSERT_PRED_FORMAT3	(		pred_format,
			v1,
			v2,
			v3
	)		GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)

Definition at line 14850 of file gtest.h.

ASSERT_PRED_FORMAT4

#define ASSERT_PRED_FORMAT4	(		pred_format,
			v1,
			v2,
			v3,
			v4
	)		GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)

Definition at line 14911 of file gtest.h.

ASSERT_PRED_FORMAT5

#define ASSERT_PRED_FORMAT5	(		pred_format,
			v1,
			v2,
			v3,
			v4,
			v5
	)		GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)

Definition at line 14978 of file gtest.h.

ASSERT_STRCASEEQ

#define ASSERT_STRCASEEQ	(		s1,
			s2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)

Definition at line 16729 of file gtest.h.

ASSERT_STRCASENE

#define ASSERT_STRCASENE	(		s1,
			s2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

Definition at line 16731 of file gtest.h.

ASSERT_STREQ

#define ASSERT_STREQ	(		s1,
			s2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

Definition at line 16725 of file gtest.h.

ASSERT_STRNE

#define ASSERT_STRNE	(		s1,
			s2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)

Definition at line 16727 of file gtest.h.

ASSERT_THROW

#define ASSERT_THROW	(		statement,
			expected_exception
	)		GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)

Definition at line 16574 of file gtest.h.

ASSERT_TRUE

#define ASSERT_TRUE

(

condition

)

Value:

GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_FATAL_FAILURE_)

Definition at line 16590 of file gtest.h.

EXPECT_ANY_THROW

#define EXPECT_ANY_THROW

(

statement

)

GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 16572 of file gtest.h.

EXPECT_DEATH_IF_SUPPORTED

#define EXPECT_DEATH_IF_SUPPORTED	(		statement,
			regex
	)		GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )

Definition at line 10352 of file gtest.h.

EXPECT_DOUBLE_EQ

#define EXPECT_DOUBLE_EQ	(		val1,
			val2
	)

Value:

EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      val1, val2)

Definition at line 16752 of file gtest.h.

EXPECT_EQ

#define EXPECT_EQ	(		val1,
			val2
	)

Value:

EXPECT_PRED_FORMAT2(::testing::internal:: \
                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
                      val1, val2)

Definition at line 16643 of file gtest.h.

EXPECT_FALSE

#define EXPECT_FALSE

(

condition

)

Value:

GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_NONFATAL_FAILURE_)

Definition at line 16587 of file gtest.h.

EXPECT_FLOAT_EQ

#define EXPECT_FLOAT_EQ	(		val1,
			val2
	)

Value:

EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      val1, val2)

Definition at line 16748 of file gtest.h.

EXPECT_GE

#define EXPECT_GE	(		val1,
			val2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)

Definition at line 16653 of file gtest.h.

EXPECT_GT

#define EXPECT_GT	(		val1,
			val2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

Definition at line 16655 of file gtest.h.

EXPECT_LE

#define EXPECT_LE	(		val1,
			val2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)

Definition at line 16649 of file gtest.h.

EXPECT_LT

#define EXPECT_LT	(		val1,
			val2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)

Definition at line 16651 of file gtest.h.

EXPECT_NE

#define EXPECT_NE	(		val1,
			val2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)

Definition at line 16647 of file gtest.h.

EXPECT_NEAR

#define EXPECT_NEAR	(		val1,
			val2,
			abs_error
	)

Value:

EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

Definition at line 16764 of file gtest.h.

EXPECT_NO_FATAL_FAILURE

#define EXPECT_NO_FATAL_FAILURE

(

statement

)

GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 16822 of file gtest.h.

EXPECT_NO_THROW

#define EXPECT_NO_THROW

(

statement

)

GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)

Definition at line 16570 of file gtest.h.

EXPECT_PRED1

#define EXPECT_PRED1	(		pred,
			v1
	)		GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)

Definition at line 14744 of file gtest.h.

EXPECT_PRED2

#define EXPECT_PRED2	(		pred,
			v1,
			v2
	)		GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)

Definition at line 14793 of file gtest.h.

EXPECT_PRED3

#define EXPECT_PRED3	(		pred,
			v1,
			v2,
			v3
	)		GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)

Definition at line 14848 of file gtest.h.

EXPECT_PRED4

#define EXPECT_PRED4	(		pred,
			v1,
			v2,
			v3,
			v4
	)		GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)

Definition at line 14909 of file gtest.h.

EXPECT_PRED5

#define EXPECT_PRED5	(		pred,
			v1,
			v2,
			v3,
			v4,
			v5
	)		GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)

Definition at line 14976 of file gtest.h.

EXPECT_PRED_FORMAT1

#define EXPECT_PRED_FORMAT1	(		pred_format,
			v1
	)		GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)

Definition at line 14742 of file gtest.h.

EXPECT_PRED_FORMAT2

#define EXPECT_PRED_FORMAT2	(		pred_format,
			v1,
			v2
	)		GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)

Definition at line 14791 of file gtest.h.

EXPECT_PRED_FORMAT3

#define EXPECT_PRED_FORMAT3	(		pred_format,
			v1,
			v2,
			v3
	)		GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)

Definition at line 14846 of file gtest.h.

EXPECT_PRED_FORMAT4

#define EXPECT_PRED_FORMAT4	(		pred_format,
			v1,
			v2,
			v3,
			v4
	)		GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)

Definition at line 14907 of file gtest.h.

EXPECT_PRED_FORMAT5

#define EXPECT_PRED_FORMAT5	(		pred_format,
			v1,
			v2,
			v3,
			v4,
			v5
	)		GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)

Definition at line 14974 of file gtest.h.

EXPECT_STRCASEEQ

#define EXPECT_STRCASEEQ	(		s1,
			s2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)

Definition at line 16720 of file gtest.h.

EXPECT_STRCASENE

#define EXPECT_STRCASENE	(		s1,
			s2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

Definition at line 16722 of file gtest.h.

EXPECT_STREQ

#define EXPECT_STREQ	(		s1,
			s2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)

Definition at line 16716 of file gtest.h.

EXPECT_STRNE

#define EXPECT_STRNE	(		s1,
			s2
	)		EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)

Definition at line 16718 of file gtest.h.

EXPECT_THROW

#define EXPECT_THROW	(		statement,
			expected_exception
	)		GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)

Definition at line 16568 of file gtest.h.

EXPECT_TRUE

#define EXPECT_TRUE

(

condition

)

Value:

GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_NONFATAL_FAILURE_)

Definition at line 16584 of file gtest.h.

FAIL

#define FAIL

(

)

GTEST_FAIL()

Definition at line 16547 of file gtest.h.

FRIEND_TEST

#define FRIEND_TEST	(		test_case_name,
			test_name
	)		friend class test_case_name##_##test_name##_Test

Definition at line 13802 of file gtest.h.

GTEST_ADD_REFERENCE_

#define GTEST_ADD_REFERENCE_

(

T

)

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

Definition at line 1298 of file gtest.h.

GTEST_AMBIGUOUS_ELSE_BLOCKER_

#define GTEST_AMBIGUOUS_ELSE_BLOCKER_   switch (0) case 0: default:

Definition at line 877 of file gtest.h.

GTEST_API_

#define GTEST_API_

Definition at line 998 of file gtest.h.

GTEST_ARRAY_SIZE_

#define GTEST_ARRAY_SIZE_

(

array

)

(sizeof(array) / sizeof(array[0]))

Definition at line 1110 of file gtest.h.

GTEST_ASSERT_

#define GTEST_ASSERT_	(		expression,
			on_failure
	)

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  if (const ::testing::AssertionResult gtest_ar = (expression)) \
    ; \
  else \
    on_failure(gtest_ar.failure_message())

Definition at line 14703 of file gtest.h.

GTEST_ASSERT_EQ

#define GTEST_ASSERT_EQ	(		val1,
			val2
	)

Value:

ASSERT_PRED_FORMAT2(::testing::internal:: \
                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
                      val1, val2)

Definition at line 16658 of file gtest.h.

GTEST_ASSERT_GE

#define GTEST_ASSERT_GE	(		val1,
			val2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)

Definition at line 16668 of file gtest.h.

GTEST_ASSERT_GT

#define GTEST_ASSERT_GT	(		val1,
			val2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

Definition at line 16670 of file gtest.h.

GTEST_ASSERT_LE

#define GTEST_ASSERT_LE	(		val1,
			val2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)

Definition at line 16664 of file gtest.h.

GTEST_ASSERT_LT

#define GTEST_ASSERT_LT	(		val1,
			val2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)

Definition at line 16666 of file gtest.h.

GTEST_ASSERT_NE

#define GTEST_ASSERT_NE	(		val1,
			val2
	)		ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)

Definition at line 16662 of file gtest.h.

GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

Definition at line 1043 of file gtest.h.

GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

Definition at line 1031 of file gtest.h.

GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

Definition at line 1055 of file gtest.h.

GTEST_ATTRIBUTE_PRINTF_

#define GTEST_ATTRIBUTE_PRINTF_	(		string_index,
			first_to_check
	)

Definition at line 916 of file gtest.h.

GTEST_ATTRIBUTE_UNUSED_

#define GTEST_ATTRIBUTE_UNUSED_

Definition at line 899 of file gtest.h.

GTEST_CHECK_

#define GTEST_CHECK_

(

condition

)

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::IsTrue(condition)) \
      ; \
    else \
      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "

Definition at line 1270 of file gtest.h.

GTEST_CHECK_POSIX_SUCCESS_

#define GTEST_CHECK_POSIX_SUCCESS_

(

posix_call

)

Value:

if (const int gtest_error = (posix_call)) \
    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
                      << gtest_error

Definition at line 1283 of file gtest.h.

GTEST_COMPILE_ASSERT_

#define GTEST_COMPILE_ASSERT_	(		expr,
			msg
	)		static_assert(expr, #msg)

Definition at line 1086 of file gtest.h.

GTEST_CONCAT_TOKEN_

#define GTEST_CONCAT_TOKEN_	(		foo,
			bar
	)		GTEST_CONCAT_TOKEN_IMPL_(foo, bar)

Definition at line 6510 of file gtest.h.

GTEST_CONCAT_TOKEN_IMPL_

#define GTEST_CONCAT_TOKEN_IMPL_	(		foo,
			bar
	)		foo ## bar

Definition at line 6511 of file gtest.h.

GTEST_DECLARE_bool_

#define GTEST_DECLARE_bool_

(

name

)

GTEST_API_ extern bool GTEST_FLAG(name)

Definition at line 2496 of file gtest.h.

GTEST_DECLARE_int32_

#define GTEST_DECLARE_int32_

(

name

)

GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)

Definition at line 2497 of file gtest.h.

GTEST_DECLARE_STATIC_MUTEX_

#define GTEST_DECLARE_STATIC_MUTEX_

(

mutex

)

extern ::testing::internal::Mutex mutex

Definition at line 2147 of file gtest.h.

GTEST_DECLARE_string_

#define GTEST_DECLARE_string_

(

name

)

GTEST_API_ extern ::std::string GTEST_FLAG(name)

Definition at line 2499 of file gtest.h.

GTEST_DEFAULT_DEATH_TEST_STYLE

#define GTEST_DEFAULT_DEATH_TEST_STYLE   "fast"

Definition at line 1002 of file gtest.h.

GTEST_DEFINE_bool_

#define GTEST_DEFINE_bool_	(		name,
			default_val,
			doc
	)		GTEST_API_ bool GTEST_FLAG(name) = (default_val)

Definition at line 2503 of file gtest.h.

GTEST_DEFINE_int32_

#define GTEST_DEFINE_int32_	(		name,
			default_val,
			doc
	)		GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)

Definition at line 2505 of file gtest.h.

GTEST_DEFINE_STATIC_MUTEX_

#define GTEST_DEFINE_STATIC_MUTEX_

(

mutex

)

::testing::internal::Mutex mutex

Definition at line 2150 of file gtest.h.

GTEST_DEFINE_string_

#define GTEST_DEFINE_string_	(		name,
			default_val,
			doc
	)		GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)

Definition at line 2507 of file gtest.h.

GTEST_DEV_EMAIL_

#define GTEST_DEV_EMAIL_   "googletestframework@@googlegroups.com"

Definition at line 513 of file gtest.h.

GTEST_DISABLE_MSC_DEPRECATED_POP_

#define GTEST_DISABLE_MSC_DEPRECATED_POP_

(

)

GTEST_DISABLE_MSC_WARNINGS_POP_()

Definition at line 561 of file gtest.h.

GTEST_DISABLE_MSC_DEPRECATED_PUSH_

#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_

(

)

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)

Definition at line 559 of file gtest.h.

GTEST_DISABLE_MSC_WARNINGS_POP_

GTEST_DISABLE_MSC_WARNINGS_POP_

(

)

Definition at line 546 of file gtest.h.

GTEST_DISABLE_MSC_WARNINGS_PUSH_

#define GTEST_DISABLE_MSC_WARNINGS_PUSH_

(

warnings

)

Definition at line 545 of file gtest.h.

GTEST_DISALLOW_ASSIGN_

#define GTEST_DISALLOW_ASSIGN_

(

type

)

void operator=(type const &) = delete

Definition at line 922 of file gtest.h.

GTEST_DISALLOW_COPY_AND_ASSIGN_

#define GTEST_DISALLOW_COPY_AND_ASSIGN_

(

type

)

Value:

type(type const &) = delete; \
  GTEST_DISALLOW_ASSIGN_(type)

Definition at line 927 of file gtest.h.

GTEST_EXCLUSIVE_LOCK_REQUIRED_

#define GTEST_EXCLUSIVE_LOCK_REQUIRED_

(

locks

)

Definition at line 2514 of file gtest.h.

GTEST_FAIL

#define GTEST_FAIL

(

)

GTEST_FATAL_FAILURE_("Failed")

Definition at line 16542 of file gtest.h.

GTEST_FATAL_FAILURE_

#define GTEST_FATAL_FAILURE_

(

message

)

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

Definition at line 7760 of file gtest.h.

GTEST_FLAG

#define GTEST_FLAG

(

name

)

FLAGS_gtest_##name

Definition at line 2485 of file gtest.h.

GTEST_FLAG_PREFIX_

#define GTEST_FLAG_PREFIX_   "gtest_"

Definition at line 514 of file gtest.h.

GTEST_FLAG_PREFIX_DASH_

#define GTEST_FLAG_PREFIX_DASH_   "gtest-"

Definition at line 515 of file gtest.h.

GTEST_FLAG_PREFIX_UPPER_

#define GTEST_FLAG_PREFIX_UPPER_   "GTEST_"

Definition at line 516 of file gtest.h.

GTEST_FLAG_SAVER_

#define GTEST_FLAG_SAVER_   ::testing::internal::GTestFlagSaver

Definition at line 2493 of file gtest.h.

GTEST_HAS_ALT_PATH_SEP_

#define GTEST_HAS_ALT_PATH_SEP_   0

Definition at line 2222 of file gtest.h.

GTEST_HAS_CLONE

#define GTEST_HAS_CLONE   0

Definition at line 817 of file gtest.h.

GTEST_HAS_CXXABI_H_

#define GTEST_HAS_CXXABI_H_   0

Definition at line 1017 of file gtest.h.

GTEST_HAS_EXCEPTIONS

#define GTEST_HAS_EXCEPTIONS   0

Definition at line 675 of file gtest.h.

GTEST_HAS_GLOBAL_STRING

#define GTEST_HAS_GLOBAL_STRING   0

Definition at line 689 of file gtest.h.

GTEST_HAS_GLOBAL_WSTRING

#define GTEST_HAS_GLOBAL_WSTRING   (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)

Definition at line 706 of file gtest.h.

GTEST_HAS_POSIX_RE

#define GTEST_HAS_POSIX_RE   (!GTEST_OS_WINDOWS)

Definition at line 603 of file gtest.h.

GTEST_HAS_PTHREAD

#define GTEST_HAS_PTHREAD

Value:

(GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)

Definition at line 780 of file gtest.h.

GTEST_HAS_RTTI

#define GTEST_HAS_RTTI   1

Definition at line 761 of file gtest.h.

GTEST_HAS_SEH

#define GTEST_HAS_SEH   0

Definition at line 966 of file gtest.h.

GTEST_HAS_STD_STRING

#define GTEST_HAS_STD_STRING   1

Definition at line 682 of file gtest.h.

GTEST_HAS_STD_WSTRING

#define GTEST_HAS_STD_WSTRING   (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))

Definition at line 698 of file gtest.h.

GTEST_HAS_STREAM_REDIRECTION

#define GTEST_HAS_STREAM_REDIRECTION   1

Definition at line 830 of file gtest.h.

GTEST_IMPL_CMP_HELPER_

#define GTEST_IMPL_CMP_HELPER_	(		op_name,
			op
	)

Value:

template <typename T1, typename T2>\
AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                   const T1& val1, const T2& val2) {\
  if (val1 op val2) {\
    return AssertionSuccess();\
  } else {\
    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
  }\
}\
GTEST_API_ AssertionResult CmpHelper##op_name(\
    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)

Definition at line 16226 of file gtest.h.

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

(

CharType

)

Value:

template <typename OtherOperand>                                      \
  class FormatForComparison<CharType*, OtherOperand> {                  \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(static_cast<const void*>(value)); \
    }                                                                   \
  }

Definition at line 8359 of file gtest.h.

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_

#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_	(		CharType,
			OtherStringType
	)

Value:

template <>                                                           \
  class FormatForComparison<CharType*, OtherStringType> {               \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(value);                           \
    }                                                                   \
  }

Definition at line 8378 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

Definition at line 7948 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

#define GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

Definition at line 8027 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

Definition at line 2603 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

Definition at line 10401 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_

#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_

Definition at line 14666 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

Definition at line 8133 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_PROD_H_

#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_

Definition at line 13779 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_

#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_

Definition at line 13838 of file gtest.h.

GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_

GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_

Definition at line 508 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

Definition at line 9019 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

Definition at line 7986 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_

Definition at line 97 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_

Definition at line 11353 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

Definition at line 10578 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

Definition at line 408 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

Definition at line 142 of file gtest.h.

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_

GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_

GTEST_INIT_GOOGLE_TEST_NAME_

#define GTEST_INIT_GOOGLE_TEST_NAME_   "testing::InitGoogleTest"

Definition at line 522 of file gtest.h.

GTEST_INTENTIONAL_CONST_COND_POP_

#define GTEST_INTENTIONAL_CONST_COND_POP_

(

)

GTEST_DISABLE_MSC_WARNINGS_POP_()

Definition at line 952 of file gtest.h.

GTEST_INTENTIONAL_CONST_COND_PUSH_

#define GTEST_INTENTIONAL_CONST_COND_PUSH_

(

)

GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)

Definition at line 950 of file gtest.h.

GTEST_INTERNAL_DEPRECATED

#define GTEST_INTERNAL_DEPRECATED

(

message

)

Definition at line 7907 of file gtest.h.

GTEST_IS_NULL_LITERAL_

#define GTEST_IS_NULL_LITERAL_

(

x

)

decltype(::testing::internal::IsNullLiteralHelper(x))::value

Definition at line 6572 of file gtest.h.

GTEST_IS_THREADSAFE

#define GTEST_IS_THREADSAFE

Value:

(GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
   GTEST_HAS_PTHREAD)

Definition at line 973 of file gtest.h.

GTEST_LOCK_EXCLUDED_

#define GTEST_LOCK_EXCLUDED_

(

locks

)

Definition at line 2515 of file gtest.h.

GTEST_LOG_

#define GTEST_LOG_

(

severity

)

Value:

::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
                                  __FILE__, __LINE__).GetStream()

Definition at line 1246 of file gtest.h.

GTEST_MESSAGE_

#define GTEST_MESSAGE_	(		message,
			result_type
	)		GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)

Definition at line 7757 of file gtest.h.

GTEST_MESSAGE_AT_

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

Value:

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

Definition at line 7753 of file gtest.h.

GTEST_MUST_USE_RESULT_

#define GTEST_MUST_USE_RESULT_

Definition at line 939 of file gtest.h.

GTEST_NAME_

#define GTEST_NAME_   "Google Test"

Definition at line 517 of file gtest.h.

GTEST_NO_INLINE_

#define GTEST_NO_INLINE_

Definition at line 1009 of file gtest.h.

GTEST_NONFATAL_FAILURE_

#define GTEST_NONFATAL_FAILURE_

(

message

)

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

Definition at line 7763 of file gtest.h.

GTEST_PATH_SEP_

#define GTEST_PATH_SEP_   "/"

Definition at line 2221 of file gtest.h.

GTEST_PRED1_

#define GTEST_PRED1_	(		pred,
			v1,
			on_failure
	)

Value:

GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
                                             #v1, \
                                             pred, \
                                             v1), on_failure)

Definition at line 14735 of file gtest.h.

GTEST_PRED2_

#define GTEST_PRED2_	(		pred,
			v1,
			v2,
			on_failure
	)

Value:

GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             pred, \
                                             v1, \
                                             v2), on_failure)

Definition at line 14782 of file gtest.h.

GTEST_PRED3_

#define GTEST_PRED3_	(		pred,
			v1,
			v2,
			v3,
			on_failure
	)

Value:

GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3), on_failure)

Definition at line 14835 of file gtest.h.

GTEST_PRED4_

#define GTEST_PRED4_	(		pred,
			v1,
			v2,
			v3,
			v4,
			on_failure
	)

Value:

GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             #v4, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3, \
                                             v4), on_failure)

Definition at line 14894 of file gtest.h.

GTEST_PRED5_

#define GTEST_PRED5_	(		pred,
			v1,
			v2,
			v3,
			v4,
			v5,
			on_failure
	)

Value:

GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
                                             #v1, \
                                             #v2, \
                                             #v3, \
                                             #v4, \
                                             #v5, \
                                             pred, \
                                             v1, \
                                             v2, \
                                             v3, \
                                             v4, \
                                             v5), on_failure)

Definition at line 14959 of file gtest.h.

GTEST_PRED_FORMAT1_

#define GTEST_PRED_FORMAT1_	(		pred_format,
			v1,
			on_failure
	)

Value:

GTEST_ASSERT_(pred_format(#v1, v1), \
                on_failure)

Definition at line 14729 of file gtest.h.

GTEST_PRED_FORMAT2_

#define GTEST_PRED_FORMAT2_	(		pred_format,
			v1,
			v2,
			on_failure
	)

Value:

GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
                on_failure)

Definition at line 14776 of file gtest.h.

GTEST_PRED_FORMAT3_

#define GTEST_PRED_FORMAT3_	(		pred_format,
			v1,
			v2,
			v3,
			on_failure
	)

Value:

GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
                on_failure)

Definition at line 14829 of file gtest.h.

GTEST_PRED_FORMAT4_

#define GTEST_PRED_FORMAT4_	(		pred_format,
			v1,
			v2,
			v3,
			v4,
			on_failure
	)

Value:

GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
                on_failure)

Definition at line 14888 of file gtest.h.

GTEST_PRED_FORMAT5_

#define GTEST_PRED_FORMAT5_	(		pred_format,
			v1,
			v2,
			v3,
			v4,
			v5,
			on_failure
	)

Value:

GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
                on_failure)

Definition at line 14953 of file gtest.h.

GTEST_PROJECT_URL_

#define GTEST_PROJECT_URL_   "https://github.com/google/googletest/"

Definition at line 518 of file gtest.h.

GTEST_REFERENCE_TO_CONST_

#define GTEST_REFERENCE_TO_CONST_

(

T

)

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

Definition at line 1318 of file gtest.h.

GTEST_REMOVE_CONST_

#define GTEST_REMOVE_CONST_

(

T

)

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

Definition at line 7333 of file gtest.h.

GTEST_REMOVE_REFERENCE_

#define GTEST_REMOVE_REFERENCE_

(

T

)

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

Definition at line 7312 of file gtest.h.

GTEST_REMOVE_REFERENCE_AND_CONST_

#define GTEST_REMOVE_REFERENCE_AND_CONST_

(

T

)

GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))

Definition at line 7337 of file gtest.h.

GTEST_SKIP

#define GTEST_SKIP

(

)

GTEST_SKIP_("Skipped")

Definition at line 16513 of file gtest.h.

GTEST_SKIP_

#define GTEST_SKIP_

(

message

)

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

Definition at line 7769 of file gtest.h.

GTEST_SNPRINTF_

#define GTEST_SNPRINTF_   snprintf

Definition at line 2410 of file gtest.h.

GTEST_STRINGIFY_

#define GTEST_STRINGIFY_

(

name

)

#name

Definition at line 6514 of file gtest.h.

GTEST_SUCCEED

#define GTEST_SUCCEED

(

)

GTEST_SUCCESS_("Succeeded")

Definition at line 16551 of file gtest.h.

GTEST_SUCCESS_

#define GTEST_SUCCESS_

(

message

)

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

Definition at line 7766 of file gtest.h.

GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_

#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_

(

statement

)

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

Definition at line 7775 of file gtest.h.

GTEST_TEST

#define GTEST_TEST	(		test_suite_name,
			test_name
	)

Value:

GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
              ::testing::internal::GetTestTypeId())

Definition at line 16957 of file gtest.h.

GTEST_TEST_

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

Value:

class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
      : public parent_class {                                                 \
   public:                                                                    \
    GTEST_TEST_CLASS_NAME_(test_suite_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_suite_name,   \
                                                           test_name));       \
  };                                                                          \
                                                                              \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
                                                    test_name)::test_info_ =  \
      ::testing::internal::MakeAndRegisterTestInfo(                           \
          #test_suite_name, #test_name, nullptr, nullptr,                     \
          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
          ::testing::internal::SuiteApiResolver<                              \
              parent_class>::GetSetUpCaseOrSuite(),                           \
          ::testing::internal::SuiteApiResolver<                              \
              parent_class>::GetTearDownCaseOrSuite(),                        \
          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
              test_suite_name, test_name)>);                                  \
  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

Definition at line 7868 of file gtest.h.

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.")

Definition at line 7818 of file gtest.h.

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())

Definition at line 7840 of file gtest.h.

GTEST_TEST_CLASS_NAME_

#define GTEST_TEST_CLASS_NAME_	(		test_suite_name,
			test_name
	)		test_suite_name##_##test_name##_Test

Definition at line 7864 of file gtest.h.

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.")

Definition at line 7849 of file gtest.h.

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.")

Definition at line 7804 of file gtest.h.

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)

Definition at line 7778 of file gtest.h.

GTEST_UNSUPPORTED_DEATH_TEST

#define GTEST_UNSUPPORTED_DEATH_TEST	(		statement,
			regex,
			terminator
	)

Value:

GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
    if (::testing::internal::AlwaysTrue()) { \
      GTEST_LOG_(WARNING) \
          << "Death tests are not supported on this platform.\n" \
          << "Statement '" #statement "' cannot be verified."; \
    } else if (::testing::internal::AlwaysFalse()) { \
      ::testing::internal::RE::PartialMatch(".*", (regex)); \
      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
      terminator; \
    } else \
      ::testing::Message()

Definition at line 10328 of file gtest.h.

GTEST_USE_OWN_FLAGFILE_FLAG_

#define GTEST_USE_OWN_FLAGFILE_FLAG_   1

Definition at line 2489 of file gtest.h.

GTEST_USES_POSIX_RE

#define GTEST_USES_POSIX_RE   1

Definition at line 618 of file gtest.h.

GTEST_WIDE_STRING_USES_UTF16_

#define GTEST_WIDE_STRING_USES_UTF16_   (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)

Definition at line 856 of file gtest.h.

INSTANTIATE_TEST_CASE_P

#define INSTANTIATE_TEST_CASE_P   INSTANTIATE_TEST_SUITE_P

Definition at line 13739 of file gtest.h.

INSTANTIATE_TEST_SUITE_P

#define INSTANTIATE_TEST_SUITE_P	(		prefix,
			test_suite_name,
			generator,
			...
	)

Value:

static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
    return generator;                                                         \
  }                                                                           \
  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
    return ::testing::internal::GetParamNameGen<test_suite_name::ParamType>(  \
        __VA_ARGS__)(info);                                                   \
  }                                                                           \
  static int gtest_##prefix##test_suite_name##_dummy_                         \
      GTEST_ATTRIBUTE_UNUSED_ =                                               \
          ::testing::UnitTest::GetInstance()                                  \
              ->parameterized_test_registry()                                 \
              .GetTestSuitePatternHolder<test_suite_name>(                    \
                  #test_suite_name,                                           \
                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
              ->AddTestSuiteInstantiation(                                    \
                  #prefix, &gtest_##prefix##test_suite_name##_EvalGenerator_, \
                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
                  __FILE__, __LINE__)

Definition at line 13715 of file gtest.h.

SCOPED_TRACE

#define SCOPED_TRACE

(

message

)

Value:

::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
    __FILE__, __LINE__, (message))

Definition at line 16891 of file gtest.h.

SUCCEED

#define SUCCEED

(

)

GTEST_SUCCEED()

Definition at line 16556 of file gtest.h.

TEST

#define TEST	(		test_suite_name,
			test_name
	)		GTEST_TEST(test_suite_name, test_name)

Definition at line 16964 of file gtest.h.

TEST_F

#define TEST_F	(		test_fixture,
			test_name
	)

Value:

GTEST_TEST_(test_fixture, test_name, test_fixture, \
              ::testing::internal::GetTypeId<test_fixture>())

Definition at line 16993 of file gtest.h.

TEST_P

#define TEST_P	(		test_suite_name,
			test_name
	)

Value:

class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
      : public test_suite_name {                                               \
   public:                                                                     \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
    virtual void TestBody();                                                   \
                                                                               \
   private:                                                                    \
    static int AddToRegistry() {                                               \
      ::testing::UnitTest::GetInstance()                                       \
          ->parameterized_test_registry()                                      \
          .GetTestSuitePatternHolder<test_suite_name>(                         \
              #test_suite_name,                                                \
              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
          ->AddTestPattern(                                                    \
              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
                  test_suite_name, test_name)>());                             \
      return 0;                                                                \
    }                                                                          \
    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
                                                           test_name));        \
  };                                                                           \
  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                             test_name)::gtest_registering_dummy_ =            \
      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

Definition at line 13674 of file gtest.h.

Function Documentation

GTEST_DISABLE_MSC_WARNINGS_PUSH_()

GTEST_DISABLE_MSC_WARNINGS_PUSH_

(

4251

5046

)

Definition at line 2988 of file gtest.h.

RUN_ALL_TESTS()

int RUN_ALL_TESTS ( )

inline

Definition at line 17097 of file gtest.h.