Classes | Namespaces | Macros | Typedefs | Enumerations | Functions | Variables
gtest.h File Reference
#include <cstddef>
#include <limits>
#include <memory>
#include <ostream>
#include <type_traits>
#include <vector>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#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 <cassert>
#include <iosfwd>
Include dependency graph for gtest.h:

Go to the source code of this file.

Classes

class  testing::internal::RE
 
class  testing::internal::GTestLog
 
struct  testing::internal::ConstRef< T >
 
struct  testing::internal::ConstRef< T & >
 
class  testing::internal::Mutex
 
class  testing::internal::GTestMutexLock
 
class  testing::internal::ThreadLocal< 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::IsAProtocolMessage< T >
 
struct  testing::internal::IsHashTable< T >
 
struct  testing::internal::IsRecursiveContainerImpl< C, false >
 
struct  testing::internal::IsRecursiveContainerImpl< C, true >
 
struct  testing::internal::IsRecursiveContainer< C >
 
struct  testing::internal::RelationToSourceReference
 
struct  testing::internal::RelationToSourceCopy
 
class  testing::internal::NativeArray< Element >
 
struct  testing::internal::IndexSequence< Is >
 
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, IndexSequence< I... >, T... >
 
struct  testing::internal::FlatTupleElemBase< FlatTuple< T... >, I >
 
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 >
 
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::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 >
 
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::CartesianProductGenerator< T >
 
class  testing::internal::CartesianProductHolder< Gen >
 
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
 
class  testing::internal::AssertHelper
 
class  testing::WithParamInterface< T >
 
class  testing::TestWithParam< T >
 
class  testing::ScopedTrace
 

Namespaces

namespace  testing
 
namespace  testing::internal
 
namespace  testing::internal::posix
 
namespace  proto2
 
namespace  testing::internal::edit_distance
 
namespace  testing::internal2
 
namespace  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_STD_WSTRING
 
#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_HWADDRESS_
 
#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_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_INTERNAL_DEPRECATED(message)
 
#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_REMOVE_REFERENCE_AND_CONST_(T)    typename std::remove_const<typename std::remove_reference<T>::type>::type
 
#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_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_MAYBE_5046_
 
#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 TEST_P(test_suite_name, test_name)
 
#define GTEST_EXPAND_(arg)   arg
 
#define GTEST_GET_FIRST_(first, ...)   first
 
#define GTEST_GET_SECOND_(first, second, ...)   second
 
#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)
 
#define INSTANTIATE_TEST_CASE_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 GTEST_FAIL_AT(file, line)
 
#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)    EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, 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)    ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, 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 GTestMutexLock testing::internal::MutexLock
 
template<bool B>
using testing::internal::bool_constant = std::integral_constant< bool, B >
 
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)
 
GTEST_API_ void testing::internal::CaptureStdout ()
 
GTEST_API_ std::string testing::internal::GetCapturedStdout ()
 
GTEST_API_ void testing::internal::CaptureStderr ()
 
GTEST_API_ std::string testing::internal::GetCapturedStderr ()
 
GTEST_API_ size_t testing::internal::GetFileSize (FILE *file)
 
GTEST_API_ std::string testing::internal::ReadEntireFile (FILE *file)
 
GTEST_API_ std::vector< std::string > testing::internal::GetArgvs ()
 
GTEST_API_ 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_val)
 
GTEST_API_ Int32 testing::internal::Int32FromGTestEnv (const char *flag, Int32 default_val)
 
std::string testing::internal::OutputFlagAlsoCheckEnvVar ()
 
const char * testing::internal::StringFromGTestEnv (const char *flag, const char *default_val)
 
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)
 
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])
 
 testing::internal::GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TEST_SUITE_P") const expr bool InstantiateTestCase_P_IsDeprecated()
 
 testing::internal::GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE_P is deprecated, please use " "TYPED_TEST_SUITE_P") const expr bool TypedTestCase_P_IsDeprecated()
 
 testing::internal::GTEST_INTERNAL_DEPRECATED ("TYPED_TEST_CASE is deprecated, please use " "TYPED_TEST_SUITE") const expr bool TypedTestCaseIsDeprecated()
 
 testing::internal::GTEST_INTERNAL_DEPRECATED ("REGISTER_TYPED_TEST_CASE_P is deprecated, please use " "REGISTER_TYPED_TEST_SUITE_P") const expr bool RegisterTypedTestCase_P_IsDeprecated()
 
 testing::internal::GTEST_INTERNAL_DEPRECATED ("INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " "INSTANTIATE_TYPED_TEST_SUITE_P") const expr bool InstantiateTypedTestCase_P_IsDeprecated()
 
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)
 
GTEST_API_ void testing::internal::PrintTo (unsigned char c, ::std::ostream *os)
 
GTEST_API_ void testing::internal::PrintTo (signed char c, ::std::ostream *os)
 
void testing::internal::PrintTo (char c, ::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<typename T = int>
void testing::internal::TestNotEmpty ()
 
template<typename T = int>
void testing::internal::TestNotEmpty (const T &)
 
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 std::iterator_traits< 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... Generator>
internal::CartesianProductHolder< Generator... > testing::Combine (const Generator &... g)
 
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)
 
GTEST_API_ void testing::InitGoogleTest ()
 
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 >
constexpr bool testing::StaticAssertTypeEq () noexcept
 
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")

◆ 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:7595

◆ ASSERT_ANY_THROW

#define ASSERT_ANY_THROW (   statement)     GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)

◆ ASSERT_DEATH_IF_SUPPORTED

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

◆ 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:12518

◆ ASSERT_EQ

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

◆ 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:7602
GTEST_TEST_BOOLEAN_
#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)
Definition: gtest.h:7682

◆ ASSERT_FLOAT_EQ

#define ASSERT_FLOAT_EQ (   val1,
  val2 
)
Value:
ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
val1, val2)

◆ ASSERT_GE

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

◆ ASSERT_GT

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

◆ ASSERT_LE

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

◆ ASSERT_LT

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

◆ ASSERT_NE

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

◆ ASSERT_NEAR

#define ASSERT_NEAR (   val1,
  val2,
  abs_error 
)
Value:
ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
val1, val2, abs_error)
ASSERT_PRED_FORMAT3
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3)
Definition: gtest.h:12573
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_NO_FATAL_FAILURE

#define ASSERT_NO_FATAL_FAILURE (   statement)     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)

◆ ASSERT_NO_THROW

#define ASSERT_NO_THROW (   statement)     GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)

◆ ASSERT_PRED1

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

◆ ASSERT_PRED2

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

◆ ASSERT_PRED3

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

◆ ASSERT_PRED4

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

◆ ASSERT_PRED5

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

◆ ASSERT_PRED_FORMAT1

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

◆ ASSERT_PRED_FORMAT2

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

◆ ASSERT_PRED_FORMAT3

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

◆ 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_)

◆ 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_)

◆ ASSERT_STRCASEEQ

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

◆ ASSERT_STRCASENE

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

◆ ASSERT_STREQ

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

◆ ASSERT_STRNE

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

◆ ASSERT_THROW

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

◆ ASSERT_TRUE

#define ASSERT_TRUE (   condition)
Value:
GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
GTEST_FATAL_FAILURE_)

◆ EXPECT_ANY_THROW

#define EXPECT_ANY_THROW (   statement)     GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)

◆ EXPECT_DEATH_IF_SUPPORTED

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

◆ 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:12514

◆ EXPECT_EQ

#define EXPECT_EQ (   val1,
  val2 
)     EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

◆ 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:7605

◆ EXPECT_FLOAT_EQ

#define EXPECT_FLOAT_EQ (   val1,
  val2 
)
Value:
EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
val1, val2)

◆ EXPECT_GE

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

◆ EXPECT_GT

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

◆ EXPECT_LE

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

◆ EXPECT_LT

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

◆ EXPECT_NE

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

◆ EXPECT_NEAR

#define EXPECT_NEAR (   val1,
  val2,
  abs_error 
)
Value:
EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
val1, val2, abs_error)
EXPECT_PRED_FORMAT3
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3)
Definition: gtest.h:12569

◆ EXPECT_NO_FATAL_FAILURE

#define EXPECT_NO_FATAL_FAILURE (   statement)     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)

◆ EXPECT_NO_THROW

#define EXPECT_NO_THROW (   statement)     GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)

◆ EXPECT_PRED1

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

◆ EXPECT_PRED2

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

◆ EXPECT_PRED3

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

◆ EXPECT_PRED4

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

◆ EXPECT_PRED5

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

◆ EXPECT_PRED_FORMAT1

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

◆ EXPECT_PRED_FORMAT2

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

◆ EXPECT_PRED_FORMAT3

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

◆ 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_)

◆ 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_)

◆ EXPECT_STRCASEEQ

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

◆ EXPECT_STRCASENE

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

◆ EXPECT_STREQ

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

◆ EXPECT_STRNE

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

◆ EXPECT_THROW

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

◆ EXPECT_TRUE

#define EXPECT_TRUE (   condition)
Value:
GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
GTEST_NONFATAL_FAILURE_)

◆ FAIL

#define FAIL ( )    GTEST_FAIL()

◆ FRIEND_TEST

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

◆ GTEST_AMBIGUOUS_ELSE_BLOCKER_

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

◆ GTEST_API_

#define GTEST_API_

◆ GTEST_ARRAY_SIZE_

#define GTEST_ARRAY_SIZE_ (   array)    (sizeof(array) / sizeof(array[0]))

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

◆ GTEST_ASSERT_EQ

#define GTEST_ASSERT_EQ (   val1,
  val2 
)     ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

◆ GTEST_ASSERT_GE

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

◆ GTEST_ASSERT_GT

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

◆ GTEST_ASSERT_LE

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

◆ GTEST_ASSERT_LT

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

◆ GTEST_ASSERT_NE

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

◆ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

◆ GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_

#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_

◆ GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

◆ GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

◆ GTEST_ATTRIBUTE_PRINTF_

#define GTEST_ATTRIBUTE_PRINTF_ (   string_index,
  first_to_check 
)

◆ GTEST_ATTRIBUTE_UNUSED_

#define GTEST_ATTRIBUTE_UNUSED_

◆ GTEST_CHECK_

#define GTEST_CHECK_ (   condition)
Value:
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::IsTrue(condition)) \
; \
else \
GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
GTEST_LOG_
#define GTEST_LOG_(severity)
Definition: gtest.h:1209
testing::internal::IsTrue
GTEST_API_ bool IsTrue(bool condition)

◆ 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

◆ GTEST_COMPILE_ASSERT_

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

◆ GTEST_CONCAT_TOKEN_

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

◆ GTEST_CONCAT_TOKEN_IMPL_

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

◆ GTEST_DECLARE_bool_

#define GTEST_DECLARE_bool_ (   name)    GTEST_API_ extern bool GTEST_FLAG(name)

◆ GTEST_DECLARE_int32_

#define GTEST_DECLARE_int32_ (   name)     GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)

◆ GTEST_DECLARE_STATIC_MUTEX_

#define GTEST_DECLARE_STATIC_MUTEX_ (   mutex)     extern ::testing::internal::Mutex mutex

◆ GTEST_DECLARE_string_

#define GTEST_DECLARE_string_ (   name)     GTEST_API_ extern ::std::string GTEST_FLAG(name)

◆ GTEST_DEFAULT_DEATH_TEST_STYLE

#define GTEST_DEFAULT_DEATH_TEST_STYLE   "fast"

◆ GTEST_DEFINE_bool_

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

◆ GTEST_DEFINE_int32_

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

◆ GTEST_DEFINE_STATIC_MUTEX_

#define GTEST_DEFINE_STATIC_MUTEX_ (   mutex)    ::testing::internal::Mutex mutex

◆ GTEST_DEFINE_string_

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

◆ GTEST_DEV_EMAIL_

#define GTEST_DEV_EMAIL_   "googletestframework@@googlegroups.com"

◆ GTEST_DISABLE_MSC_DEPRECATED_POP_

#define GTEST_DISABLE_MSC_DEPRECATED_POP_ ( )     GTEST_DISABLE_MSC_WARNINGS_POP_()

◆ GTEST_DISABLE_MSC_DEPRECATED_PUSH_

#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_ ( )     GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)

◆ GTEST_DISABLE_MSC_WARNINGS_POP_

GTEST_DISABLE_MSC_WARNINGS_POP_ ( )

◆ GTEST_DISABLE_MSC_WARNINGS_PUSH_

#define GTEST_DISABLE_MSC_WARNINGS_PUSH_ (   warnings)

◆ GTEST_DISALLOW_ASSIGN_

#define GTEST_DISALLOW_ASSIGN_ (   type)     void operator=(type const &) = delete

◆ GTEST_DISALLOW_COPY_AND_ASSIGN_

#define GTEST_DISALLOW_COPY_AND_ASSIGN_ (   type)
Value:
type(type const &) = delete; \
GTEST_DISALLOW_ASSIGN_(type)

◆ GTEST_EXCLUSIVE_LOCK_REQUIRED_

#define GTEST_EXCLUSIVE_LOCK_REQUIRED_ (   locks)

◆ GTEST_EXPAND_

#define GTEST_EXPAND_ (   arg)    arg

◆ GTEST_FAIL

#define GTEST_FAIL ( )    GTEST_FATAL_FAILURE_("Failed")

◆ GTEST_FAIL_AT

#define GTEST_FAIL_AT (   file,
  line 
)
Value:
GTEST_MESSAGE_AT_(file, line, "Failed", \
::testing::TestPartResult::kFatalFailure)

◆ GTEST_FATAL_FAILURE_

#define GTEST_FATAL_FAILURE_ (   message)     return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)

◆ GTEST_FLAG

#define GTEST_FLAG (   name)    FLAGS_gtest_##name

◆ GTEST_FLAG_PREFIX_

#define GTEST_FLAG_PREFIX_   "gtest_"

◆ GTEST_FLAG_PREFIX_DASH_

#define GTEST_FLAG_PREFIX_DASH_   "gtest-"

◆ GTEST_FLAG_PREFIX_UPPER_

#define GTEST_FLAG_PREFIX_UPPER_   "GTEST_"

◆ GTEST_FLAG_SAVER_

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

◆ GTEST_GET_FIRST_

#define GTEST_GET_FIRST_ (   first,
  ... 
)    first

◆ GTEST_GET_SECOND_

#define GTEST_GET_SECOND_ (   first,
  second,
  ... 
)    second

◆ GTEST_HAS_ALT_PATH_SEP_

#define GTEST_HAS_ALT_PATH_SEP_   0

◆ GTEST_HAS_CLONE

#define GTEST_HAS_CLONE   0

◆ GTEST_HAS_CXXABI_H_

#define GTEST_HAS_CXXABI_H_   0

◆ GTEST_HAS_EXCEPTIONS

#define GTEST_HAS_EXCEPTIONS   0

◆ GTEST_HAS_POSIX_RE

#define GTEST_HAS_POSIX_RE   (!GTEST_OS_WINDOWS)

◆ 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 || \
GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \
GTEST_OS_HAIKU)

◆ GTEST_HAS_RTTI

#define GTEST_HAS_RTTI   1

◆ GTEST_HAS_SEH

#define GTEST_HAS_SEH   0

◆ GTEST_HAS_STD_STRING

#define GTEST_HAS_STD_STRING   1

◆ GTEST_HAS_STD_WSTRING

#define GTEST_HAS_STD_WSTRING
Value:
(!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
GTEST_OS_HAIKU))

◆ GTEST_HAS_STREAM_REDIRECTION

#define GTEST_HAS_STREAM_REDIRECTION   1

◆ 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)
exprtk::details::T1
const T1
Definition: exprtk.hpp:14380
exprtk::details::T2
const T1 const T2
Definition: exprtk.hpp:14402
testing::internal::BiggestInt
long long BiggestInt
Definition: gtest.h:2143
testing::internal::CmpHelperOpFailure
AssertionResult CmpHelperOpFailure(const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
Definition: gtest.h:13920

◆ 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)); \
} \
}
string
const char *const string
Definition: cJSON.h:170
exprtk::details::value
T value(details::expression_node< T > *n)
Definition: exprtk.hpp:12955
testing::PrintToString
::std::string PrintToString(const T &value)
Definition: gtest.h:8777

◆ 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); \
} \
}

◆ GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

◆ GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

#define GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_

◆ GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_

◆ GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

◆ GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_

#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_

◆ GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_

◆ GTEST_INCLUDE_GTEST_GTEST_PROD_H_

#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_

◆ GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_

#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_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_

◆ GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_

◆ GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_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_

◆ GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

◆ GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_

◆ GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_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"

◆ GTEST_INTENTIONAL_CONST_COND_POP_

#define GTEST_INTENTIONAL_CONST_COND_POP_ ( )     GTEST_DISABLE_MSC_WARNINGS_POP_()

◆ GTEST_INTENTIONAL_CONST_COND_PUSH_

#define GTEST_INTENTIONAL_CONST_COND_PUSH_ ( )     GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)

◆ GTEST_INTERNAL_DEPRECATED

#define GTEST_INTERNAL_DEPRECATED (   message)

◆ 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:778

◆ GTEST_LOCK_EXCLUDED_

#define GTEST_LOCK_EXCLUDED_ (   locks)

◆ GTEST_LOG_

#define GTEST_LOG_ (   severity)
Value:
::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
__FILE__, __LINE__).GetStream()
testing::internal::GTestLog
Definition: gtest.h:1192
testing::internal::GTestLog::GetStream
::std::ostream & GetStream()
Definition: gtest.h:1199

◆ GTEST_MAYBE_5046_

#define GTEST_MAYBE_5046_

◆ GTEST_MESSAGE_

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

◆ GTEST_MESSAGE_AT_

#define GTEST_MESSAGE_AT_ (   file,
  line,
  message,
  result_type 
)
Value:
::testing::internal::AssertHelper(result_type, file, line, message) \
= ::testing::Message()
testing::Message
Definition: gtest.h:2585
testing::internal::AssertHelper
Definition: gtest.h:14102

◆ GTEST_MUST_USE_RESULT_

#define GTEST_MUST_USE_RESULT_

◆ GTEST_NAME_

#define GTEST_NAME_   "Google Test"

◆ GTEST_NO_INLINE_

#define GTEST_NO_INLINE_

◆ GTEST_NONFATAL_FAILURE_

#define GTEST_NONFATAL_FAILURE_ (   message)     GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)

◆ GTEST_PATH_SEP_

#define GTEST_PATH_SEP_   "/"

◆ GTEST_PRED1_

#define GTEST_PRED1_ (   pred,
  v1,
  on_failure 
)
Value:
GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
#v1, \
pred, \
v1), on_failure)
GTEST_ASSERT_
#define GTEST_ASSERT_(expression, on_failure)
Definition: gtest.h:12426
testing::AssertPred1Helper
AssertionResult AssertPred1Helper(const char *pred_text, const char *e1, Pred pred, const T1 &v1)
Definition: gtest.h:12438

◆ 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:12481

◆ 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:12531

◆ 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)
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:12587

◆ 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:12649

◆ GTEST_PRED_FORMAT1_

#define GTEST_PRED_FORMAT1_ (   pred_format,
  v1,
  on_failure 
)
Value:
GTEST_ASSERT_(pred_format(#v1, v1), \
on_failure)

◆ 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_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_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_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_PROJECT_URL_

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

◆ GTEST_REFERENCE_TO_CONST_

#define GTEST_REFERENCE_TO_CONST_ (   T)     typename ::testing::internal::ConstRef<T>::type

◆ GTEST_REMOVE_REFERENCE_AND_CONST_

#define GTEST_REMOVE_REFERENCE_AND_CONST_ (   T)     typename std::remove_const<typename std::remove_reference<T>::type>::type

◆ GTEST_SKIP

#define GTEST_SKIP ( )    GTEST_SKIP_("Skipped")

◆ GTEST_SKIP_

#define GTEST_SKIP_ (   message)     return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)

◆ GTEST_SNPRINTF_

#define GTEST_SNPRINTF_   snprintf

◆ GTEST_STRINGIFY_

#define GTEST_STRINGIFY_ (   name)    #name

◆ GTEST_SUCCEED

#define GTEST_SUCCEED ( )    GTEST_SUCCESS_("Succeeded")

◆ GTEST_SUCCESS_

#define GTEST_SUCCESS_ (   message)     GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)

◆ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_

#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ (   statement)     if (::testing::internal::AlwaysTrue()) { statement; }

◆ GTEST_TEST

#define GTEST_TEST (   test_suite_name,
  test_name 
)
Value:
GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
::testing::internal::GetTestTypeId())
testing::Test
Definition: gtest.h:12737
GTEST_TEST_
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)
Definition: gtest.h:7710
testing::internal::GetTestTypeId
GTEST_API_ TypeId GetTestTypeId()

◆ GTEST_TEST_

#define GTEST_TEST_ (   test_suite_name,
  test_name,
  parent_class,
  parent_id 
)
Value:
static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \
"test_suite_name must not be empty"); \
static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \
"test_name must not be empty"); \
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(__FILE__, __LINE__), \
::testing::internal::SuiteApiResolver< \
parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
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::TestInfo
Definition: gtest.h:13030
GTEST_ATTRIBUTE_UNUSED_
#define GTEST_ATTRIBUTE_UNUSED_
Definition: gtest.h:900
GTEST_TEST_CLASS_NAME_
#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)
Definition: gtest.h:7706
GTEST_STRINGIFY_
#define GTEST_STRINGIFY_(name)
Definition: gtest.h:6441
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)
testing
Definition: gtest.h:1071

◆ GTEST_TEST_ANY_THROW_

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

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

◆ GTEST_TEST_CLASS_NAME_

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

◆ GTEST_TEST_NO_FATAL_FAILURE_

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

◆ GTEST_TEST_NO_THROW_

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

◆ GTEST_TEST_THROW_

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

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

◆ GTEST_USE_OWN_FLAGFILE_FLAG_

#define GTEST_USE_OWN_FLAGFILE_FLAG_   1

◆ GTEST_USES_POSIX_RE

#define GTEST_USES_POSIX_RE   1

◆ GTEST_WIDE_STRING_USES_UTF16_

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

◆ INSTANTIATE_TEST_CASE_P

#define INSTANTIATE_TEST_CASE_P
Value:
static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
""); \
INSTANTIATE_TEST_SUITE_P

◆ INSTANTIATE_TEST_SUITE_P

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

◆ SCOPED_TRACE

#define SCOPED_TRACE (   message)
Value:
::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
__FILE__, __LINE__, (message))
testing::ScopedTrace
Definition: gtest.h:14550

◆ SUCCEED

#define SUCCEED ( )    GTEST_SUCCEED()

◆ TEST

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

◆ TEST_F

#define TEST_F (   test_fixture,
  test_name 
)
Value:
GTEST_TEST_(test_fixture, test_name, test_fixture, \
::testing::internal::GetTypeId<test_fixture>())

◆ 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()
testing::UnitTest::GetInstance
static UnitTest * GetInstance()
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:10943

Function Documentation

◆ GTEST_DISABLE_MSC_WARNINGS_PUSH_()

GTEST_DISABLE_MSC_WARNINGS_PUSH_ ( 4251  GTEST_MAYBE_5046_)

References ecl::util::path::extension(), GTEST_API_, number, and string.

◆ RUN_ALL_TESTS()

int RUN_ALL_TESTS ( )
inline