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)
GTEST_MESSAGE_AT_
#define GTEST_MESSAGE_AT_(file, line, message, result_type)
Definition: gtest.h:7753

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)
ASSERT_PRED_FORMAT2
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14795

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_)
GTEST_FATAL_FAILURE_
#define GTEST_FATAL_FAILURE_(message)
Definition: gtest.h:7760
GTEST_TEST_BOOLEAN_
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
Definition: gtest.h:7840

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)
ASSERT_PRED_FORMAT2
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14795

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)
testing::internal::DoubleNearPredFormat
GTEST_API_ AssertionResult DoubleNearPredFormat(const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
ASSERT_PRED_FORMAT3
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3)
Definition: gtest.h:14850

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_)
GTEST_FATAL_FAILURE_
#define GTEST_FATAL_FAILURE_(message)
Definition: gtest.h:7760
GTEST_TEST_BOOLEAN_
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
Definition: gtest.h:7840

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)
EXPECT_PRED_FORMAT2
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14791

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)
GTEST_IS_NULL_LITERAL_
#define GTEST_IS_NULL_LITERAL_(x)
Definition: gtest.h:6572
EXPECT_PRED_FORMAT2
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14791
testing::internal
Definition: gtest-all.cc:7652

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_)
GTEST_NONFATAL_FAILURE_
#define GTEST_NONFATAL_FAILURE_(message)
Definition: gtest.h:7763
GTEST_TEST_BOOLEAN_
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
Definition: gtest.h:7840

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)
EXPECT_PRED_FORMAT2
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14791

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)
testing::internal::DoubleNearPredFormat
GTEST_API_ AssertionResult DoubleNearPredFormat(const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
EXPECT_PRED_FORMAT3
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3)
Definition: gtest.h:14846

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_)
GTEST_NONFATAL_FAILURE_
#define GTEST_NONFATAL_FAILURE_(message)
Definition: gtest.h:7763
GTEST_TEST_BOOLEAN_
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
Definition: gtest.h:7840

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)
ASSERT_PRED_FORMAT2
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2)
Definition: gtest.h:14795
GTEST_IS_NULL_LITERAL_
#define GTEST_IS_NULL_LITERAL_(x)
Definition: gtest.h:6572
testing::internal
Definition: gtest-all.cc:7652

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. "
testing::internal::IsTrue
GTEST_API_ bool IsTrue(bool condition)
GTEST_LOG_
#define GTEST_LOG_(severity)
Definition: gtest.h:1246

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)
testing::internal::CmpHelperOpFailure
AssertionResult CmpHelperOpFailure(const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
Definition: gtest.h:16206
testing::internal::BiggestInt
long long BiggestInt
Definition: gtest.h:2223

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)); \
} \
}
testing::PrintToString
::std::string PrintToString(const T &value)
Definition: gtest.h:8969
testing::internal::string
::std::string string
Definition: gtest.h:1115

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); \
} \
}
testing::PrintToString
::std::string PrintToString(const T &value)
Definition: gtest.h:8969
testing::internal::string
::std::string string
Definition: gtest.h:1115

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)
GTEST_HAS_PTHREAD
#define GTEST_HAS_PTHREAD
Definition: gtest.h:780

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()
testing::internal::GTestLog
Definition: gtest.h:1229
testing::internal::GTestLog::GetStream
::std::ostream & GetStream()
Definition: gtest.h:1236

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()
testing::internal::AssertHelper
Definition: gtest.h:16388
testing::Message
Definition: gtest.h:2644

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)
testing::AssertPred1Helper
AssertionResult AssertPred1Helper(const char *pred_text, const char *e1, Pred pred, const T1 &v1)
Definition: gtest.h:14715
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
testing::AssertPred2Helper
AssertionResult AssertPred2Helper(const char *pred_text, const char *e1, const char *e2, Pred pred, const T1 &v1, const T2 &v2)
Definition: gtest.h:14758
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
testing::AssertPred3Helper
AssertionResult 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)
Definition: gtest.h:14808
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703
testing::AssertPred4Helper
AssertionResult 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)
Definition: gtest.h:14864

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)
testing::AssertPred5Helper
AssertionResult 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)
Definition: gtest.h:14926
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:14703

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())
GTEST_TEST_
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)
Definition: gtest.h:7868
testing::Test
Definition: gtest.h:15014
testing::internal::GetTestTypeId
GTEST_API_ TypeId 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()
testing
Definition: gtest-all.cc:7620
testing::TestInfo
Definition: gtest.h:15294
GTEST_TEST_CLASS_NAME_
#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)
Definition: gtest.h:7864
testing::internal::MakeAndRegisterTestInfo
GTEST_API_ TestInfo * 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_ATTRIBUTE_UNUSED_
#define GTEST_ATTRIBUTE_UNUSED_
Definition: gtest.h:899

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.")
testing::internal::AlwaysTrue
GTEST_API_ bool AlwaysTrue()
GTEST_CONCAT_TOKEN_
#define GTEST_CONCAT_TOKEN_(foo, bar)
Definition: gtest.h:6510

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())
testing::internal::GetBoolAssertionFailureMessage
GTEST_API_ std::string GetBoolAssertionFailureMessage(const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)

Definition 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.")
testing::internal::AlwaysTrue
GTEST_API_ bool AlwaysTrue()
GTEST_CONCAT_TOKEN_
#define GTEST_CONCAT_TOKEN_(foo, bar)
Definition: gtest.h:6510

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.")
testing::internal::AlwaysTrue
GTEST_API_ bool AlwaysTrue()
GTEST_CONCAT_TOKEN_
#define GTEST_CONCAT_TOKEN_(foo, bar)
Definition: gtest.h:6510

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)
testing::internal::ConstCharPtr
Definition: gtest.h:7265

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()
testing::internal::AlwaysTrue
GTEST_API_ bool AlwaysTrue()
testing::internal::RE::PartialMatch
static bool PartialMatch(const ::std::string &str, const RE &re)
Definition: gtest.h:1164
testing::internal::AlwaysFalse
bool AlwaysFalse()
Definition: gtest.h:7260

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__)
testing::internal::string
::std::string string
Definition: gtest.h:1115
testing::UnitTest::parameterized_test_registry
internal::ParameterizedTestSuiteRegistry & parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_)
testing::internal::ParameterizedTestSuiteRegistry::GetTestSuitePatternHolder
ParameterizedTestSuiteInfo< TestSuite > * GetTestSuitePatternHolder(const char *test_suite_name, CodeLocation code_location)
Definition: gtest.h:11217
testing::UnitTest::GetInstance
static UnitTest * GetInstance()

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))
testing::ScopedTrace
Definition: gtest.h:16835
GTEST_CONCAT_TOKEN_
#define GTEST_CONCAT_TOKEN_(foo, bar)
Definition: gtest.h:6510

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>())
GTEST_TEST_
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)
Definition: gtest.h:7868

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()
GTEST_TEST_CLASS_NAME_
#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)
Definition: gtest.h:7864
testing::UnitTest::parameterized_test_registry
internal::ParameterizedTestSuiteRegistry & parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_)
testing::internal::ParameterizedTestSuiteRegistry::GetTestSuitePatternHolder
ParameterizedTestSuiteInfo< TestSuite > * GetTestSuitePatternHolder(const char *test_suite_name, CodeLocation code_location)
Definition: gtest.h:11217
testing::UnitTest::GetInstance
static UnitTest * GetInstance()

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.