Assimp  v4.1. (December 2018)
testing::internal Namespace Reference

Namespaces

 edit_distance
 
 posix
 

Classes

struct  AddReference
 
struct  AddReference< T & >
 
class  AssertHelper
 
class  Base
 
struct  bool_constant
 
class  Castable
 
struct  CodeLocation
 
struct  CompileAssert
 
struct  CompileAssertTypesEqual
 
struct  CompileAssertTypesEqual< T, T >
 
class  ConstAndNonConstCastable
 
class  ConstCastable
 
struct  ConstCharPtr
 
class  DefaultGlobalTestPartResultReporter
 
class  DefaultPerThreadTestPartResultReporter
 
class  Derived
 
struct  EnableIf
 
struct  EnableIf< true >
 
class  EnvironmentInvocationCatcher
 
class  EqHelper
 
class  EqHelper< true >
 
class  EventRecordingListener
 
class  FilePath
 
class  FinalSuccessChecker
 
class  FloatingPoint
 
class  FormatForComparison
 
class  FormatForComparison< ToPrint[N], OtherOperand >
 
class  GTestFlagSaver
 
class  GTestLog
 
class  GTestMutexLock
 
class  HasNewFatalFailureHelper
 
class  ImplicitlyConvertible
 
struct  is_pointer
 
struct  is_pointer< T * >
 
struct  IsAProtocolMessage
 
struct  IteratorTraits
 
struct  IteratorTraits< const T * >
 
struct  IteratorTraits< T * >
 
struct  LessByName
 
class  linked_ptr
 
class  linked_ptr_internal
 
class  ListenerTest
 
class  Mutex
 
class  NativeArray
 
class  NoDefaultContructor
 
class  OsStackTraceGetter
 
class  OsStackTraceGetterInterface
 
class  PrettyUnitTestResultPrinter
 
class  Random
 
class  RE
 
struct  RelationToSourceCopy
 
struct  RelationToSourceReference
 
struct  RemoveConst
 
struct  RemoveConst< const T >
 
struct  RemoveConst< const T[N]>
 
struct  RemoveReference
 
struct  RemoveReference< T & >
 
class  scoped_ptr
 
class  ScopedPrematureExitFile
 
class  ScopedTrace
 
class  SingleFailureChecker
 
struct  StaticAssertTypeEqHelper
 
struct  StaticAssertTypeEqHelper< T, T >
 
class  String
 
class  TestCaseNameIs
 
class  TestEventListenersAccessor
 
class  TestEventRepeater
 
class  TestFactoryBase
 
class  TestFactoryImpl
 
class  TestPropertyKeyIs
 
class  TestResultAccessor
 
class  ThreadLocal
 
class  To
 
struct  TraceInfo
 
struct  TuplePolicy
 
class  TypeIdHelper
 
class  TypeWithSize
 
class  TypeWithSize< 4 >
 
class  TypeWithSize< 8 >
 
class  UnitTestHelper
 
class  UnitTestImpl
 
class  UnitTestOptions
 
class  UnitTestRecordPropertyTestHelper
 
class  UniversalPrinter
 
class  UniversalPrinter< T & >
 
class  UniversalPrinter< T[N]>
 
class  UniversalTersePrinter
 
class  UniversalTersePrinter< char * >
 
class  UniversalTersePrinter< const char * >
 
class  UniversalTersePrinter< T & >
 
class  UniversalTersePrinter< T[N]>
 
class  UniversalTersePrinter< wchar_t * >
 
class  XmlUnitTestResultPrinter
 

Typedefs

typedef long long BiggestInt
 
typedef FloatingPoint< double > Double
 
typedef bool_constant< false > false_type
 
typedef FloatingPoint< float > Float
 
typedef TypeWithSize< 4 >::Int Int32
 
typedef TypeWithSize< 8 >::Int Int64
 
typedef int IsContainer
 
typedef char IsNotContainer
 
typedef GTestMutexLock MutexLock
 
typedef void(* SetUpTestCaseFunc) ()
 
typedef ::std::string string
 
typedef ::std::vector< stringStrings
 
typedef void(* TearDownTestCaseFunc) ()
 
typedef TypeWithSize< 8 >::Int TimeInMillis
 
typedef bool_constant< true > true_type
 
typedef const void * TypeId
 
typedef TypeWithSize< 4 >::UInt UInt32
 
typedef TypeWithSize< 8 >::UInt UInt64
 
typedef ::std::wstring wstring
 

Enumerations

enum  CharFormat { kAsIs, kHexEscape, kSpecialEscape }
 
enum  GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }
 
enum  GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }
 

Functions

bool AlwaysFalse ()
 
GTEST_API_ bool AlwaysTrue ()
 
GTEST_API_ std::string AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
 
template<typename Iter , typename Element >
Iter ArrayAwareFind (Iter begin, Iter end, const Element &elem)
 
template<typename T , typename U >
bool ArrayEq (const T *lhs, size_t size, const U *rhs)
 
template<typename T , typename U >
bool ArrayEq (const T &lhs, const U &rhs)
 
template<typename T , typename U , size_t N>
bool ArrayEq (const T(&lhs)[N], const U(&rhs)[N])
 
bool BoolFromGTestEnv (const char *flag, bool default_val)
 
GTEST_API_ void CaptureStderr ()
 
GTEST_API_ void CaptureStdout ()
 
template<class Derived , class Base >
DerivedCheckedDowncastToActualType (Base *base)
 
UInt32 ChopLowBits (UInt32 *bits, int n)
 
template<typename T1 , typename T2 >
AssertionResult CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
 
GTEST_API_ AssertionResult CmpHelperEQ (const char *lhs_expression, const char *rhs_expression, BiggestInt lhs, BiggestInt rhs)
 
template<typename T1 , typename T2 >
AssertionResult CmpHelperEQFailure (const char *lhs_expression, const char *rhs_expression, const T1 &lhs, const T2 &rhs)
 
template<typename RawType >
AssertionResult CmpHelperFloatingPointEQ (const char *lhs_expression, const char *rhs_expression, RawType lhs_value, RawType rhs_value)
 
template<typename T1 , typename T2 >
AssertionResult CmpHelperOpFailure (const char *expr1, const char *expr2, const T1 &val1, const T2 &val2, const char *op)
 
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
 
GTEST_API_ AssertionResult CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
 
GTEST_API_ AssertionResult CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
 
GTEST_API_ AssertionResult CmpHelperSTREQ (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
 
GTEST_API_ AssertionResult CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
 
GTEST_API_ AssertionResult CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
 
GTEST_API_ std::string CodePointToUtf8 (UInt32 code_point)
 
void ColoredPrintf (GTestColor color, const char *fmt,...)
 
template<typename T , typename U >
void CopyArray (const T *from, size_t size, U *to)
 
template<typename T , typename U >
void CopyArray (const T &from, U *to)
 
template<typename T , typename U , size_t N>
void CopyArray (const T(&from)[N], U(*to)[N])
 
template<class Container , typename Predicate >
int CountIf (const Container &c, Predicate predicate)
 
UInt32 CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
 
template<typename C >
void DefaultPrintTo (IsContainer, false_type, const C &container, ::std::ostream *os)
 
template<typename T >
void DefaultPrintTo (IsNotContainer, true_type, T *p, ::std::ostream *os)
 
template<typename T >
void DefaultPrintTo (IsNotContainer, false_type, const T &value, ::std::ostream *os)
 
template<typename T >
static void Delete (T *x)
 
GTEST_API_ std::string DiffStrings (const std::string &left, const std::string &right, size_t *total_line_count)
 
GTEST_API_ AssertionResult DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
 
template<typename To , typename From >
To DownCast_ (From *f)
 
GTEST_API_ AssertionResult EqFailure (const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
 
static std::string FlagToEnvVar (const char *flag)
 
template<typename RawType >
AssertionResult FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
 
void FlushInfoLog ()
 
template<class Container , typename Functor >
void ForEach (const Container &c, Functor functor)
 
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation (const char *file, int line)
 
GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
 
GTEST_API_ ::std::string FormatFileLocation (const char *file, int line)
 
template<typename T1 , typename T2 >
std::string FormatForComparisonFailureMessage (const T1 &value, const T2 &)
 
GTEST_API_ std::string FormatTimeInMillisAsSeconds (TimeInMillis ms)
 
const char * GetAnsiColorCode (GTestColor color)
 
GTEST_API_ const ::std::vector< testing::internal::string > & GetArgvs ()
 
GTEST_API_ std::string GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
 
GTEST_API_ std::string GetCapturedStderr ()
 
GTEST_API_ std::string GetCapturedStdout ()
 
GTEST_API_ FilePath GetCurrentExecutableName ()
 
GTEST_API_ std::string GetCurrentOsStackTraceExceptTop (UnitTest *unit_test, int skip_count)
 
template<typename E >
GetElementOr (const std::vector< E > &v, int i, E default_value)
 
GTEST_API_ size_t GetFileSize (FILE *file)
 
int GetNextRandomSeed (int seed)
 
int GetRandomSeedFromFlag (Int32 random_seed_flag)
 
GTEST_API_ TypeId GetTestTypeId ()
 
GTEST_API_ size_t GetThreadCount ()
 
GTEST_API_ TimeInMillis GetTimeInMillis ()
 
template<typename T >
TypeId GetTypeId ()
 
template<typename T >
std::string GetTypeName ()
 
class UnitTestImplGetUnitTestImpl ()
 
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_ (g_linked_ptr_mutex)
 
 GTEST_DECLARE_string_ (internal_run_death_test)
 
GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)
 
 GTEST_DEFINE_string_ (internal_run_death_test, "", "Indicates the file, line number, temporal index of " "the single death test to run, and a file descriptor to " "which a success code may be sent, all separated by " "the '|' characters. This flag is specified if and only if the current " "process is a sub-process launched for running a thread-safe " "death test. FOR INTERNAL USE ONLY.")
 
 GTEST_IMPL_CMP_HELPER_ (NE, !=)
 
 GTEST_IMPL_CMP_HELPER_ (LE,<=)
 
 GTEST_IMPL_CMP_HELPER_ (LT,<)
 
 GTEST_IMPL_CMP_HELPER_ (GE, >=)
 
 GTEST_IMPL_CMP_HELPER_ (GT, >)
 
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (char)
 
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ (wchar_t)
 
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ (char, ::std::string)
 
static bool GTestIsInitialized ()
 
template<class T , typename Result >
Result HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
 
template<class T , typename Result >
Result HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
 
static bool HasGoogleTestFlagPrefix (const char *str)
 
AssertionResult HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const string &substr)
 
template<typename To >
To ImplicitCast_ (To x)
 
template<typename CharType >
void InitGoogleTestImpl (int *argc, CharType **argv)
 
GTEST_API_ Int32 Int32FromEnvOrDie (const char *env_var, Int32 default_val)
 
GTEST_API_ Int32 Int32FromGTestEnv (const char *flag, Int32 default_val)
 
bool IsAlNum (char ch)
 
bool IsAlpha (char ch)
 
template<class C >
IsContainer IsContainerTest (int, typename C::iterator *=NULL, typename C::const_iterator *=NULL)
 
template<class C >
IsNotContainer IsContainerTest (long)
 
bool IsDigit (char ch)
 
bool IsLower (char ch)
 
AssertionResult IsNull (const char *str)
 
char IsNullLiteralHelper (Secret *p)
 
char(& IsNullLiteralHelper (...))[2]
 
static bool IsPathSeparator (char c)
 
bool IsPrintableAscii (wchar_t c)
 
bool IsSpace (char ch)
 
GTEST_API_ bool IsTrue (bool condition)
 
bool IsUpper (char ch)
 
bool IsUtf16SurrogatePair (wchar_t first, wchar_t second)
 
bool IsXDigit (char ch)
 
bool IsXDigit (wchar_t ch)
 
void LogToStderr ()
 
template<typename T >
linked_ptr< T > make_linked_ptr (T *ptr)
 
GTEST_API_ TestInfoMakeAndRegisterTestInfo (const char *test_case_name, const char *name, const char *type_param, const char *value_param, CodeLocation code_location, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
 
template<typename T >
const T & move (const T &t)
 
template<typename T >
bool operator!= (T *ptr, const linked_ptr< T > &x)
 
template<typename T >
bool operator== (T *ptr, const linked_ptr< T > &x)
 
bool ParseBoolFlag (const char *str, const char *flag, bool *value)
 
const char * ParseFlagValue (const char *str, const char *flag, bool def_optional)
 
bool ParseGoogleTestFlag (const char *const arg)
 
GTEST_API_ void ParseGoogleTestFlagsOnly (int *argc, char **argv)
 
GTEST_API_ void ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
 
template<typename CharType >
void ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
 
bool ParseInt32 (const Message &src_text, const char *str, Int32 *value)
 
GTEST_API_ bool ParseInt32Flag (const char *str, const char *flag, Int32 *value)
 
bool ParseStringFlag (const char *str, const char *flag, std::string *value)
 
static bool PortableLocaltime (time_t seconds, struct tm *out)
 
template<typename UnsignedChar , typename Char >
static CharFormat PrintAsCharLiteralTo (Char c, ostream *os)
 
static CharFormat PrintAsStringLiteralTo (wchar_t c, ostream *os)
 
static CharFormat PrintAsStringLiteralTo (char c, ostream *os)
 
template<typename UnsignedChar , typename Char >
void PrintCharAndCodeTo (Char c, ostream *os)
 
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
 
static void PrintColorEncoded (const char *str)
 
void PrintFullTestCommentIfPresent (const TestInfo &test_info)
 
static void PrintOnOneLine (const char *str, int max_length)
 
template<typename T >
void PrintRawArrayTo (const T a[], size_t count, ::std::ostream *os)
 
void PrintStringTo (const ::std::string &s, ostream *os)
 
GTEST_API_ void PrintStringTo (const ::std::string &s, ::std::ostream *os)
 
static void PrintTestPartResult (const TestPartResult &test_part_result)
 
static std::string PrintTestPartResultToString (const TestPartResult &test_part_result)
 
void PrintTo (wchar_t wc, ostream *os)
 
void PrintTo (const char *s, ostream *os)
 
void PrintTo (const wchar_t *s, ostream *os)
 
template<typename T >
void PrintTo (const T &value, ::std::ostream *os)
 
GTEST_API_ void PrintTo (unsigned char c, ::std::ostream *os)
 
GTEST_API_ void PrintTo (signed char c, ::std::ostream *os)
 
void PrintTo (char c, ::std::ostream *os)
 
void PrintTo (bool x, ::std::ostream *os)
 
GTEST_API_ void PrintTo (wchar_t wc, ::std::ostream *os)
 
GTEST_API_ void PrintTo (const char *s, ::std::ostream *os)
 
void PrintTo (char *s, ::std::ostream *os)
 
void PrintTo (const signed char *s, ::std::ostream *os)
 
void PrintTo (signed char *s, ::std::ostream *os)
 
void PrintTo (const unsigned char *s, ::std::ostream *os)
 
void PrintTo (unsigned char *s, ::std::ostream *os)
 
GTEST_API_ void PrintTo (const wchar_t *s, ::std::ostream *os)
 
void PrintTo (wchar_t *s, ::std::ostream *os)
 
void PrintTo (const ::std::string &s, ::std::ostream *os)
 
template<typename T1 , typename T2 >
void PrintTo (const ::std::pair< T1, T2 > &value, ::std::ostream *os)
 
GTEST_API_ std::string ReadEntireFile (FILE *file)
 
void ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
 
static void SetUpEnvironment (Environment *env)
 
static bool ShouldRunTestCase (const TestCase *test_case)
 
GTEST_API_ bool ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
 
GTEST_API_ bool ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
 
GTEST_API_ bool ShouldUseColor (bool stdout_is_tty)
 
template<typename E >
void Shuffle (internal::Random *random, std::vector< E > *v)
 
template<typename E >
void ShuffleRange (internal::Random *random, int begin, int end, std::vector< E > *v)
 
GTEST_API_ bool SkipPrefix (const char *prefix, const char **pstr)
 
void SplitString (const ::std::string &str, char delimiter, ::std::vector< ::std::string > *dest)
 
template<typename T >
std::string StreamableToString (const T &streamable)
 
std::string StringFromGTestEnv (const char *flag, const char *default_val)
 
GTEST_API_ std::string StringStreamToString (::std::stringstream *stream)
 
std::string StripTrailingSpaces (std::string str)
 
static int SumOverTestCaseList (const std::vector< TestCase *> &case_list, int(TestCase::*method)() const)
 
static void TearDownEnvironment (Environment *env)
 
GTEST_API_ std::string TempDir ()
 
 TEST (IsXDigitTest, WorksForNarrowAscii)
 
 TEST (IsXDigitTest, ReturnsFalseForNarrowNonAscii)
 
 TEST (IsXDigitTest, WorksForWideAscii)
 
 TEST (IsXDigitTest, ReturnsFalseForWideNonAscii)
 
 TEST (ApiTest, UnitTestImmutableAccessorsWork)
 
 TEST (ImplicitCastTest, ConvertsPointers)
 
 TEST (ImplicitCastTest, CanUseInheritance)
 
 TEST (ImplicitCastTest, CanUseNonConstCastOperator)
 
 TEST (ApiTest, TestCaseImmutableAccessorsWork)
 
 TEST (ImplicitCastTest, CanUseConstCastOperatorOnConstValues)
 
 TEST (ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately)
 
 TEST (ImplicitCastTest, CanUseImplicitConstructor)
 
 TEST (ApiTest, TestCaseDisabledAccessorsWork)
 
 TEST (IteratorTraitsTest, WorksForSTLContainerIterators)
 
 TEST (IteratorTraitsTest, WorksForPointerToNonConst)
 
 TEST (IteratorTraitsTest, WorksForPointerToConst)
 
 TEST (ApiTest, DISABLED_Dummy1)
 
 TEST (DISABLED_Test, Dummy2)
 
 TEST (ScopedPtrTest, DefinesElementType)
 
 TEST (GtestCheckSyntaxTest, BehavesLikeASingleStatement)
 
 TEST (GtestCheckSyntaxTest, WorksWithSwitch)
 
 TEST (FormatFileLocationTest, FormatsFileLocation)
 
 TEST (FormatFileLocationTest, FormatsUnknownFile)
 
 TEST (FormatFileLocationTest, FormatsUknownLine)
 
 TEST (FormatFileLocationTest, FormatsUknownFileAndLine)
 
 TEST (FormatCompilerIndependentFileLocationTest, FormatsFileLocation)
 
 TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFile)
 
 TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownLine)
 
 TEST (FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine)
 
 TEST (GetThreadCountTest, ReturnsZeroWhenUnableToCountThreads)
 
 TEST (GtestCheckDeathTest, DiesWithCorrectOutputOnFailure)
 
 TEST (RegexEngineSelectionTest, SelectsCorrectRegexEngine)
 
 TEST (CaptureTest, CapturesStdout)
 
 TEST (CaptureTest, CapturesStderr)
 
 TEST (CaptureTest, CapturesStdoutAndStderr)
 
 TEST (CaptureDeathTest, CannotReenterStdoutCapture)
 
 TEST (ThreadLocalTest, DefaultConstructorInitializesToDefaultValues)
 
 TEST (ThreadLocalTest, SingleParamConstructorInitializesToParam)
 
 TEST (ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion)
 
 TEST (ThreadLocalTest, GetAndPointerReturnSameValue)
 
 TEST (ThreadLocalTest, PointerAndConstPointerReturnSameValue)
 
 TEST_F (ListenerTest, DoesFoo)
 
 TEST_F (ListenerTest, DoesBar)
 
static bool TestCaseFailed (const TestCase *test_case)
 
static bool TestCasePassed (const TestCase *test_case)
 
char ToLower (char ch)
 
char ToUpper (char ch)
 
template<typename T >
void UniversalPrint (const T &value, ::std::ostream *os)
 
void UniversalPrintArray (const char *begin, size_t len, ostream *os)
 
void UniversalPrintArray (const wchar_t *begin, size_t len, ostream *os)
 
template<typename T >
void UniversalPrintArray (const T *begin, size_t len, ::std::ostream *os)
 
GTEST_API_ void UniversalPrintArray (const char *begin, size_t len, ::std::ostream *os)
 
GTEST_API_ void UniversalPrintArray (const wchar_t *begin, size_t len, ::std::ostream *os)
 
template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
 
template<typename T >
void UniversalTersePrint (const T &value, ::std::ostream *os)
 
GTEST_API_ std::string WideStringToUtf8 (const wchar_t *str, int num_chars)
 
void WriteToShardStatusFileIfNeeded ()
 

Variables

::std::vector< testing::internal::stringg_argvs
 
GTEST_API_ bool g_help_flag = false
 
class GTEST_API_ testing::internal::ScopedTrace GTEST_ATTRIBUTE_UNUSED_
 
const char kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"
 
const char kBreakOnFailureFlag [] = "break_on_failure"
 
const char kCatchExceptionsFlag [] = "catch_exceptions"
 
static const char kColorEncodedHelpMessage []
 
const char kColorFlag [] = "color"
 
const char kCurrentDirectoryString [] = "./"
 
const char kDeathTestStyleFlag [] = "death_test_style"
 
const char kDeathTestUseFork [] = "death_test_use_fork"
 
const char kFilterFlag [] = "filter"
 
const char kFlagfileFlag [] = "flagfile"
 
const char kInternalRunDeathTestFlag [] = "internal_run_death_test"
 
const char kListTestsFlag [] = "list_tests"
 
const BiggestInt kMaxBiggestInt
 
const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1
 
const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1
 
const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1
 
const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1
 
const int kMaxRandomSeed = 99999
 
const char kOutputFlag [] = "output"
 
const char kPathSeparator = '/'
 
const char kPrintTimeFlag [] = "print_time"
 
const char kRandomSeedFlag [] = "random_seed"
 
const char kRepeatFlag [] = "repeat"
 
const char kShuffleFlag [] = "shuffle"
 
const char kStackTraceDepthFlag [] = "stack_trace_depth"
 
GTEST_API_ const char kStackTraceMarker [] = "\nStack trace:\n"
 
const int kStdErrFileno = STDERR_FILENO
 
const int kStdOutFileno = STDOUT_FILENO
 
const char kStreamResultToFlag [] = "stream_result_to"
 
GTEST_API_ const TypeId kTestTypeIdInGoogleTest = GetTestTypeId()
 
const char kThrowOnFailureFlag [] = "throw_on_failure"
 
const int kTypedTestCases = 0
 
const int kTypedTests = 0
 
static const char kTypeParamLabel [] = "TypeParam"
 
const char kUnknownFile [] = "unknown file"
 
static const char kValueParamLabel [] = "GetParam()"
 

Typedef Documentation

◆ BiggestInt

typedef long long testing::internal::BiggestInt

◆ Double

◆ false_type

◆ Float

◆ Int32

◆ Int64

◆ IsContainer

◆ IsNotContainer

◆ MutexLock

◆ SetUpTestCaseFunc

typedef void(* testing::internal::SetUpTestCaseFunc) ()

◆ string

◆ Strings

typedef ::std::vector<string> testing::internal::Strings

◆ TearDownTestCaseFunc

typedef void(* testing::internal::TearDownTestCaseFunc) ()

◆ TimeInMillis

◆ true_type

◆ TypeId

typedef const void* testing::internal::TypeId

◆ UInt32

◆ UInt64

◆ wstring

typedef ::std::wstring testing::internal::wstring

Enumeration Type Documentation

◆ CharFormat

Enumerator
kAsIs 
kHexEscape 
kSpecialEscape 

◆ GTestColor

Enumerator
COLOR_DEFAULT 
COLOR_RED 
COLOR_GREEN 
COLOR_YELLOW 

◆ GTestLogSeverity

Enumerator
GTEST_INFO 
GTEST_WARNING 
GTEST_ERROR 
GTEST_FATAL 

Function Documentation

◆ AlwaysFalse()

bool testing::internal::AlwaysFalse ( )
inline

◆ AlwaysTrue()

bool testing::internal::AlwaysTrue ( )

◆ AppendUserMessage()

std::string testing::internal::AppendUserMessage ( const std::string &  gtest_msg,
const Message user_msg 
)

◆ ArrayAwareFind()

template<typename Iter , typename Element >
Iter testing::internal::ArrayAwareFind ( Iter  begin,
Iter  end,
const Element &  elem 
)

◆ ArrayEq() [1/3]

template<typename T , typename U >
bool testing::internal::ArrayEq ( const T *  lhs,
size_t  size,
const U *  rhs 
)

◆ ArrayEq() [2/3]

template<typename T , typename U >
bool testing::internal::ArrayEq ( const T &  lhs,
const U &  rhs 
)
inline

◆ ArrayEq() [3/3]

template<typename T , typename U , size_t N>
bool testing::internal::ArrayEq ( const T(&)  lhs[N],
const U(&)  rhs[N] 
)
inline

◆ BoolFromGTestEnv()

bool testing::internal::BoolFromGTestEnv ( const char *  flag,
bool  default_val 
)

◆ CaptureStderr()

GTEST_API_ void testing::internal::CaptureStderr ( )

◆ CaptureStdout()

GTEST_API_ void testing::internal::CaptureStdout ( )

◆ CheckedDowncastToActualType()

template<class Derived , class Base >
Derived* testing::internal::CheckedDowncastToActualType ( Base base)

◆ ChopLowBits()

UInt32 testing::internal::ChopLowBits ( UInt32 bits,
int  n 
)
inline

◆ CmpHelperEQ() [1/2]

template<typename T1 , typename T2 >
AssertionResult testing::internal::CmpHelperEQ ( const char *  lhs_expression,
const char *  rhs_expression,
const T1 &  lhs,
const T2 &  rhs 
)

◆ CmpHelperEQ() [2/2]

AssertionResult testing::internal::CmpHelperEQ ( const char *  lhs_expression,
const char *  rhs_expression,
BiggestInt  lhs,
BiggestInt  rhs 
)

◆ CmpHelperEQFailure()

template<typename T1 , typename T2 >
AssertionResult testing::internal::CmpHelperEQFailure ( const char *  lhs_expression,
const char *  rhs_expression,
const T1 &  lhs,
const T2 &  rhs 
)

◆ CmpHelperFloatingPointEQ()

template<typename RawType >
AssertionResult testing::internal::CmpHelperFloatingPointEQ ( const char *  lhs_expression,
const char *  rhs_expression,
RawType  lhs_value,
RawType  rhs_value 
)

◆ CmpHelperOpFailure()

template<typename T1 , typename T2 >
AssertionResult testing::internal::CmpHelperOpFailure ( const char *  expr1,
const char *  expr2,
const T1 &  val1,
const T2 &  val2,
const char *  op 
)

◆ CmpHelperSTRCASEEQ()

AssertionResult testing::internal::CmpHelperSTRCASEEQ ( const char *  s1_expression,
const char *  s2_expression,
const char *  s1,
const char *  s2 
)

◆ CmpHelperSTRCASENE()

AssertionResult testing::internal::CmpHelperSTRCASENE ( const char *  s1_expression,
const char *  s2_expression,
const char *  s1,
const char *  s2 
)

◆ CmpHelperSTREQ() [1/2]

AssertionResult testing::internal::CmpHelperSTREQ ( const char *  s1_expression,
const char *  s2_expression,
const char *  s1,
const char *  s2 
)

◆ CmpHelperSTREQ() [2/2]

AssertionResult testing::internal::CmpHelperSTREQ ( const char *  s1_expression,
const char *  s2_expression,
const wchar_t *  s1,
const wchar_t *  s2 
)

◆ CmpHelperSTRNE() [1/2]

AssertionResult testing::internal::CmpHelperSTRNE ( const char *  s1_expression,
const char *  s2_expression,
const char *  s1,
const char *  s2 
)

◆ CmpHelperSTRNE() [2/2]

AssertionResult testing::internal::CmpHelperSTRNE ( const char *  s1_expression,
const char *  s2_expression,
const wchar_t *  s1,
const wchar_t *  s2 
)

◆ CodePointToUtf8()

std::string testing::internal::CodePointToUtf8 ( UInt32  code_point)

◆ ColoredPrintf()

void testing::internal::ColoredPrintf ( GTestColor  color,
const char *  fmt,
  ... 
)

◆ CopyArray() [1/3]

template<typename T , typename U >
void testing::internal::CopyArray ( const T *  from,
size_t  size,
U *  to 
)

◆ CopyArray() [2/3]

template<typename T , typename U >
void testing::internal::CopyArray ( const T &  from,
U *  to 
)
inline

◆ CopyArray() [3/3]

template<typename T , typename U , size_t N>
void testing::internal::CopyArray ( const T(&)  from[N],
U(*)  to[N] 
)
inline

◆ CountIf()

template<class Container , typename Predicate >
int testing::internal::CountIf ( const Container &  c,
Predicate  predicate 
)
inline

◆ CreateCodePointFromUtf16SurrogatePair()

UInt32 testing::internal::CreateCodePointFromUtf16SurrogatePair ( wchar_t  first,
wchar_t  second 
)
inline

◆ DefaultPrintTo() [1/3]

template<typename C >
void testing::internal::DefaultPrintTo ( IsContainer  ,
false_type  ,
const C &  container,
::std::ostream *  os 
)

◆ DefaultPrintTo() [2/3]

template<typename T >
void testing::internal::DefaultPrintTo ( IsNotContainer  ,
true_type  ,
T *  p,
::std::ostream *  os 
)

◆ DefaultPrintTo() [3/3]

template<typename T >
void testing::internal::DefaultPrintTo ( IsNotContainer  ,
false_type  ,
const T &  value,
::std::ostream *  os 
)

◆ Delete()

template<typename T >
static void testing::internal::Delete ( T *  x)
static

◆ DiffStrings()

GTEST_API_ std::string testing::internal::DiffStrings ( const std::string &  left,
const std::string &  right,
size_t *  total_line_count 
)

◆ DoubleNearPredFormat()

AssertionResult testing::internal::DoubleNearPredFormat ( const char *  expr1,
const char *  expr2,
const char *  abs_error_expr,
double  val1,
double  val2,
double  abs_error 
)

◆ DownCast_()

template<typename To , typename From >
To testing::internal::DownCast_ ( From *  f)
inline

◆ EqFailure()

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 
)

◆ FlagToEnvVar()

static std::string testing::internal::FlagToEnvVar ( const char *  flag)
static

◆ FloatingPointLE()

template<typename RawType >
AssertionResult testing::internal::FloatingPointLE ( const char *  expr1,
const char *  expr2,
RawType  val1,
RawType  val2 
)

◆ FlushInfoLog()

void testing::internal::FlushInfoLog ( )
inline

◆ ForEach()

template<class Container , typename Functor >
void testing::internal::ForEach ( const Container &  c,
Functor  functor 
)

◆ FormatCompilerIndependentFileLocation()

GTEST_API_::std::string testing::internal::FormatCompilerIndependentFileLocation ( const char *  file,
int  line 
)

◆ FormatEpochTimeInMillisAsIso8601()

std::string testing::internal::FormatEpochTimeInMillisAsIso8601 ( TimeInMillis  ms)

◆ FormatFileLocation()

GTEST_API_::std::string testing::internal::FormatFileLocation ( const char *  file,
int  line 
)

◆ FormatForComparisonFailureMessage()

template<typename T1 , typename T2 >
std::string testing::internal::FormatForComparisonFailureMessage ( const T1 &  value,
const T2 &   
)

◆ FormatTimeInMillisAsSeconds()

std::string testing::internal::FormatTimeInMillisAsSeconds ( TimeInMillis  ms)

◆ GetAnsiColorCode()

const char* testing::internal::GetAnsiColorCode ( GTestColor  color)

◆ GetArgvs()

const ::std::vector< testing::internal::string > & testing::internal::GetArgvs ( )

◆ GetBoolAssertionFailureMessage()

std::string testing::internal::GetBoolAssertionFailureMessage ( const AssertionResult assertion_result,
const char *  expression_text,
const char *  actual_predicate_value,
const char *  expected_predicate_value 
)

◆ GetCapturedStderr()

GTEST_API_ std::string testing::internal::GetCapturedStderr ( )

◆ GetCapturedStdout()

GTEST_API_ std::string testing::internal::GetCapturedStdout ( )

◆ GetCurrentExecutableName()

FilePath testing::internal::GetCurrentExecutableName ( )

◆ GetCurrentOsStackTraceExceptTop()

std::string testing::internal::GetCurrentOsStackTraceExceptTop ( UnitTest unit_test,
int  skip_count 
)

◆ GetElementOr()

template<typename E >
E testing::internal::GetElementOr ( const std::vector< E > &  v,
int  i,
default_value 
)
inline

◆ GetFileSize()

size_t testing::internal::GetFileSize ( FILE *  file)

◆ GetNextRandomSeed()

int testing::internal::GetNextRandomSeed ( int  seed)
inline

◆ GetRandomSeedFromFlag()

int testing::internal::GetRandomSeedFromFlag ( Int32  random_seed_flag)
inline

◆ GetTestTypeId()

TypeId testing::internal::GetTestTypeId ( )

◆ GetThreadCount()

size_t testing::internal::GetThreadCount ( )

◆ GetTimeInMillis()

TimeInMillis testing::internal::GetTimeInMillis ( )

◆ GetTypeId()

template<typename T >
TypeId testing::internal::GetTypeId ( )

◆ GetTypeName()

template<typename T >
std::string testing::internal::GetTypeName ( )

◆ GetUnitTestImpl()

UnitTestImpl * testing::internal::GetUnitTestImpl ( )
inline

◆ GTEST_DECLARE_STATIC_MUTEX_()

GTEST_API_ testing::internal::GTEST_DECLARE_STATIC_MUTEX_ ( g_linked_ptr_mutex  )

◆ GTEST_DECLARE_string_()

testing::internal::GTEST_DECLARE_string_ ( internal_run_death_test  )

◆ GTEST_DEFINE_STATIC_MUTEX_()

GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_ ( g_linked_ptr_mutex  )

◆ GTEST_DEFINE_string_()

testing::internal::GTEST_DEFINE_string_ ( internal_run_death_test  ,
""  ,
"Indicates the  file,
line  number,
temporal index of " "the single death test to  run,
and a file descriptor to " "which a success code may be  sent,
all separated by " "the '|' characters. This flag is specified if and only if the current " "process is a sub-process launched for running a thread-safe " "death test. FOR INTERNAL USE ONLY."   
)

◆ GTEST_IMPL_CMP_HELPER_() [1/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( NE  ,
 
)

◆ GTEST_IMPL_CMP_HELPER_() [2/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( LE  ,
<=   
)

◆ GTEST_IMPL_CMP_HELPER_() [3/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( LT  )

◆ GTEST_IMPL_CMP_HELPER_() [4/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( GE  ,
>=   
)

◆ GTEST_IMPL_CMP_HELPER_() [5/5]

testing::internal::GTEST_IMPL_CMP_HELPER_ ( GT  )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [1/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( char  )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_() [2/2]

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ ( wchar_t  )

◆ GTEST_IMPL_FORMAT_C_STRING_AS_STRING_()

testing::internal::GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ ( char  ,
::std::string   
)

◆ GTestIsInitialized()

static bool testing::internal::GTestIsInitialized ( )
static

◆ HandleExceptionsInMethodIfSupported()

template<class T , typename Result >
Result testing::internal::HandleExceptionsInMethodIfSupported ( T *  object,
Result(T::*)()  method,
const char *  location 
)

◆ HandleSehExceptionsInMethodIfSupported()

template<class T , typename Result >
Result testing::internal::HandleSehExceptionsInMethodIfSupported ( T *  object,
Result(T::*)()  method,
const char *  location 
)

◆ HasGoogleTestFlagPrefix()

static bool testing::internal::HasGoogleTestFlagPrefix ( const char *  str)
static

◆ HasOneFailure()

AssertionResult testing::internal::HasOneFailure ( const char *  ,
const char *  ,
const char *  ,
const TestPartResultArray results,
TestPartResult::Type  type,
const string substr 
)

◆ ImplicitCast_()

template<typename To >
To testing::internal::ImplicitCast_ ( To  x)
inline

◆ InitGoogleTestImpl()

template<typename CharType >
void testing::internal::InitGoogleTestImpl ( int *  argc,
CharType **  argv 
)

◆ Int32FromEnvOrDie()

Int32 testing::internal::Int32FromEnvOrDie ( const char *  env_var,
Int32  default_val 
)

◆ Int32FromGTestEnv()

Int32 testing::internal::Int32FromGTestEnv ( const char *  flag,
Int32  default_val 
)

◆ IsAlNum()

bool testing::internal::IsAlNum ( char  ch)
inline

◆ IsAlpha()

bool testing::internal::IsAlpha ( char  ch)
inline

◆ IsContainerTest() [1/2]

template<class C >
IsContainer testing::internal::IsContainerTest ( int  ,
typename C::iterator *  = NULL,
typename C::const_iterator *  = NULL 
)

◆ IsContainerTest() [2/2]

template<class C >
IsNotContainer testing::internal::IsContainerTest ( long  )

◆ IsDigit()

bool testing::internal::IsDigit ( char  ch)
inline

◆ IsLower()

bool testing::internal::IsLower ( char  ch)
inline

◆ IsNull()

AssertionResult testing::internal::IsNull ( const char *  str)

◆ IsNullLiteralHelper() [1/2]

char testing::internal::IsNullLiteralHelper ( Secret *  p)

◆ IsNullLiteralHelper() [2/2]

char(& testing::internal::IsNullLiteralHelper (   ...) )[2]

◆ IsPathSeparator()

static bool testing::internal::IsPathSeparator ( char  c)
static

◆ IsPrintableAscii()

bool testing::internal::IsPrintableAscii ( wchar_t  c)
inline

◆ IsSpace()

bool testing::internal::IsSpace ( char  ch)
inline

◆ IsTrue()

bool testing::internal::IsTrue ( bool  condition)

◆ IsUpper()

bool testing::internal::IsUpper ( char  ch)
inline

◆ IsUtf16SurrogatePair()

bool testing::internal::IsUtf16SurrogatePair ( wchar_t  first,
wchar_t  second 
)
inline

◆ IsXDigit() [1/2]

bool testing::internal::IsXDigit ( char  ch)
inline

◆ IsXDigit() [2/2]

bool testing::internal::IsXDigit ( wchar_t  ch)
inline

◆ LogToStderr()

void testing::internal::LogToStderr ( )
inline

◆ make_linked_ptr()

template<typename T >
linked_ptr<T> testing::internal::make_linked_ptr ( T *  ptr)

◆ MakeAndRegisterTestInfo()

TestInfo * testing::internal::MakeAndRegisterTestInfo ( const char *  test_case_name,
const char *  name,
const char *  type_param,
const char *  value_param,
CodeLocation  code_location,
TypeId  fixture_class_id,
SetUpTestCaseFunc  set_up_tc,
TearDownTestCaseFunc  tear_down_tc,
TestFactoryBase factory 
)

◆ move()

template<typename T >
const T& testing::internal::move ( const T &  t)

◆ operator!=()

template<typename T >
bool testing::internal::operator!= ( T *  ptr,
const linked_ptr< T > &  x 
)
inline

◆ operator==()

template<typename T >
bool testing::internal::operator== ( T *  ptr,
const linked_ptr< T > &  x 
)
inline

◆ ParseBoolFlag()

bool testing::internal::ParseBoolFlag ( const char *  str,
const char *  flag,
bool *  value 
)

◆ ParseFlagValue()

const char* testing::internal::ParseFlagValue ( const char *  str,
const char *  flag,
bool  def_optional 
)

◆ ParseGoogleTestFlag()

bool testing::internal::ParseGoogleTestFlag ( const char *const  arg)

◆ ParseGoogleTestFlagsOnly() [1/2]

void testing::internal::ParseGoogleTestFlagsOnly ( int *  argc,
char **  argv 
)

◆ ParseGoogleTestFlagsOnly() [2/2]

void testing::internal::ParseGoogleTestFlagsOnly ( int *  argc,
wchar_t **  argv 
)

◆ ParseGoogleTestFlagsOnlyImpl()

template<typename CharType >
void testing::internal::ParseGoogleTestFlagsOnlyImpl ( int *  argc,
CharType **  argv 
)

◆ ParseInt32()

bool testing::internal::ParseInt32 ( const Message src_text,
const char *  str,
Int32 value 
)

◆ ParseInt32Flag()

bool testing::internal::ParseInt32Flag ( const char *  str,
const char *  flag,
Int32 value 
)

◆ ParseStringFlag()

bool testing::internal::ParseStringFlag ( const char *  str,
const char *  flag,
std::string *  value 
)

◆ PortableLocaltime()

static bool testing::internal::PortableLocaltime ( time_t  seconds,
struct tm *  out 
)
static

◆ PrintAsCharLiteralTo()

template<typename UnsignedChar , typename Char >
static CharFormat testing::internal::PrintAsCharLiteralTo ( Char  c,
ostream *  os 
)
static

◆ PrintAsStringLiteralTo() [1/2]

static CharFormat testing::internal::PrintAsStringLiteralTo ( wchar_t  c,
ostream *  os 
)
static

◆ PrintAsStringLiteralTo() [2/2]

static CharFormat testing::internal::PrintAsStringLiteralTo ( char  c,
ostream *  os 
)
static

◆ PrintCharAndCodeTo()

template<typename UnsignedChar , typename Char >
void testing::internal::PrintCharAndCodeTo ( Char  c,
ostream *  os 
)

◆ PrintCharsAsStringTo()

template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void testing::internal::PrintCharsAsStringTo ( const CharType *  begin,
size_t  len,
ostream *  os 
)
static

◆ PrintColorEncoded()

static void testing::internal::PrintColorEncoded ( const char *  str)
static

◆ PrintFullTestCommentIfPresent()

void testing::internal::PrintFullTestCommentIfPresent ( const TestInfo test_info)

◆ PrintOnOneLine()

static void testing::internal::PrintOnOneLine ( const char *  str,
int  max_length 
)
static

◆ PrintRawArrayTo()

template<typename T >
void testing::internal::PrintRawArrayTo ( const T  a[],
size_t  count,
::std::ostream *  os 
)

◆ PrintStringTo() [1/2]

void testing::internal::PrintStringTo ( const ::std::string &  s,
ostream *  os 
)

◆ PrintStringTo() [2/2]

GTEST_API_ void testing::internal::PrintStringTo ( const ::std::string &  s,
::std::ostream *  os 
)

◆ PrintTestPartResult()

static void testing::internal::PrintTestPartResult ( const TestPartResult test_part_result)
static

◆ PrintTestPartResultToString()

static std::string testing::internal::PrintTestPartResultToString ( const TestPartResult test_part_result)
static

◆ PrintTo() [1/19]

void testing::internal::PrintTo ( wchar_t  wc,
ostream *  os 
)

◆ PrintTo() [2/19]

void testing::internal::PrintTo ( const char *  s,
ostream *  os 
)

◆ PrintTo() [3/19]

void testing::internal::PrintTo ( const wchar_t *  s,
ostream *  os 
)

◆ PrintTo() [4/19]

template<typename T >
void testing::internal::PrintTo ( const T &  value,
::std::ostream *  os 
)

◆ PrintTo() [5/19]

void testing::internal::PrintTo ( unsigned char  c,
::std::ostream *  os 
)

◆ PrintTo() [6/19]

void testing::internal::PrintTo ( signed char  c,
::std::ostream *  os 
)

◆ PrintTo() [7/19]

void testing::internal::PrintTo ( char  c,
::std::ostream *  os 
)
inline

◆ PrintTo() [8/19]

void testing::internal::PrintTo ( bool  x,
::std::ostream *  os 
)
inline

◆ PrintTo() [9/19]

GTEST_API_ void testing::internal::PrintTo ( wchar_t  wc,
::std::ostream *  os 
)

◆ PrintTo() [10/19]

GTEST_API_ void testing::internal::PrintTo ( const char *  s,
::std::ostream *  os 
)

◆ PrintTo() [11/19]

void testing::internal::PrintTo ( char *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [12/19]

void testing::internal::PrintTo ( const signed char *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [13/19]

void testing::internal::PrintTo ( signed char *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [14/19]

void testing::internal::PrintTo ( const unsigned char *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [15/19]

void testing::internal::PrintTo ( unsigned char *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [16/19]

GTEST_API_ void testing::internal::PrintTo ( const wchar_t *  s,
::std::ostream *  os 
)

◆ PrintTo() [17/19]

void testing::internal::PrintTo ( wchar_t *  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [18/19]

void testing::internal::PrintTo ( const ::std::string &  s,
::std::ostream *  os 
)
inline

◆ PrintTo() [19/19]

template<typename T1 , typename T2 >
void testing::internal::PrintTo ( const ::std::pair< T1, T2 > &  value,
::std::ostream *  os 
)

◆ ReadEntireFile()

std::string testing::internal::ReadEntireFile ( FILE *  file)

◆ ReportFailureInUnknownLocation()

void testing::internal::ReportFailureInUnknownLocation ( TestPartResult::Type  result_type,
const std::string &  message 
)

◆ SetUpEnvironment()

static void testing::internal::SetUpEnvironment ( Environment env)
static

◆ ShouldRunTestCase()

static bool testing::internal::ShouldRunTestCase ( const TestCase test_case)
static

◆ ShouldRunTestOnShard()

bool testing::internal::ShouldRunTestOnShard ( int  total_shards,
int  shard_index,
int  test_id 
)

◆ ShouldShard()

bool testing::internal::ShouldShard ( const char *  total_shards_str,
const char *  shard_index_str,
bool  in_subprocess_for_death_test 
)

◆ ShouldUseColor()

bool testing::internal::ShouldUseColor ( bool  stdout_is_tty)

◆ Shuffle()

template<typename E >
void testing::internal::Shuffle ( internal::Random random,
std::vector< E > *  v 
)
inline

◆ ShuffleRange()

template<typename E >
void testing::internal::ShuffleRange ( internal::Random random,
int  begin,
int  end,
std::vector< E > *  v 
)

◆ SkipPrefix()

bool testing::internal::SkipPrefix ( const char *  prefix,
const char **  pstr 
)

◆ SplitString()

void testing::internal::SplitString ( const ::std::string &  str,
char  delimiter,
::std::vector< ::std::string > *  dest 
)

◆ StreamableToString()

template<typename T >
std::string testing::internal::StreamableToString ( const T &  streamable)

◆ StringFromGTestEnv()

std::string testing::internal::StringFromGTestEnv ( const char *  flag,
const char *  default_val 
)

◆ StringStreamToString()

std::string testing::internal::StringStreamToString ( ::std::stringstream *  stream)

◆ StripTrailingSpaces()

std::string testing::internal::StripTrailingSpaces ( std::string  str)
inline

◆ SumOverTestCaseList()

static int testing::internal::SumOverTestCaseList ( const std::vector< TestCase *> &  case_list,
int(TestCase::*)() const  method 
)
static

◆ TearDownEnvironment()

static void testing::internal::TearDownEnvironment ( Environment env)
static

◆ TempDir()

std::string testing::internal::TempDir ( )

◆ TEST() [1/41]

testing::internal::TEST ( IsXDigitTest  ,
WorksForNarrowAscii   
)

◆ TEST() [2/41]

testing::internal::TEST ( IsXDigitTest  ,
ReturnsFalseForNarrowNonAscii   
)

◆ TEST() [3/41]

testing::internal::TEST ( IsXDigitTest  ,
WorksForWideAscii   
)

◆ TEST() [4/41]

testing::internal::TEST ( IsXDigitTest  ,
ReturnsFalseForWideNonAscii   
)

◆ TEST() [5/41]

testing::internal::TEST ( ApiTest  ,
UnitTestImmutableAccessorsWork   
)

◆ TEST() [6/41]

testing::internal::TEST ( ImplicitCastTest  ,
ConvertsPointers   
)

◆ TEST() [7/41]

testing::internal::TEST ( ImplicitCastTest  ,
CanUseInheritance   
)

◆ TEST() [8/41]

testing::internal::TEST ( ImplicitCastTest  ,
CanUseNonConstCastOperator   
)

◆ TEST() [9/41]

testing::internal::TEST ( ApiTest  ,
TestCaseImmutableAccessorsWork   
)

◆ TEST() [10/41]

testing::internal::TEST ( ImplicitCastTest  ,
CanUseConstCastOperatorOnConstValues   
)

◆ TEST() [11/41]

testing::internal::TEST ( ImplicitCastTest  ,
CanSelectBetweenConstAndNonConstCasrAppropriately   
)

◆ TEST() [12/41]

testing::internal::TEST ( ImplicitCastTest  ,
CanUseImplicitConstructor   
)

◆ TEST() [13/41]

testing::internal::TEST ( ApiTest  ,
TestCaseDisabledAccessorsWork   
)

◆ TEST() [14/41]

testing::internal::TEST ( IteratorTraitsTest  ,
WorksForSTLContainerIterators   
)

◆ TEST() [15/41]

testing::internal::TEST ( IteratorTraitsTest  ,
WorksForPointerToNonConst   
)

◆ TEST() [16/41]

testing::internal::TEST ( IteratorTraitsTest  ,
WorksForPointerToConst   
)

◆ TEST() [17/41]

testing::internal::TEST ( ApiTest  ,
DISABLED_Dummy1   
)

◆ TEST() [18/41]

testing::internal::TEST ( DISABLED_Test  ,
Dummy2   
)

◆ TEST() [19/41]

testing::internal::TEST ( ScopedPtrTest  ,
DefinesElementType   
)

◆ TEST() [20/41]

testing::internal::TEST ( GtestCheckSyntaxTest  ,
BehavesLikeASingleStatement   
)

◆ TEST() [21/41]

testing::internal::TEST ( GtestCheckSyntaxTest  ,
WorksWithSwitch   
)

◆ TEST() [22/41]

testing::internal::TEST ( FormatFileLocationTest  ,
FormatsFileLocation   
)

◆ TEST() [23/41]

testing::internal::TEST ( FormatFileLocationTest  ,
FormatsUnknownFile   
)

◆ TEST() [24/41]

testing::internal::TEST ( FormatFileLocationTest  ,
FormatsUknownLine   
)

◆ TEST() [25/41]

testing::internal::TEST ( FormatFileLocationTest  ,
FormatsUknownFileAndLine   
)

◆ TEST() [26/41]

testing::internal::TEST ( FormatCompilerIndependentFileLocationTest  ,
FormatsFileLocation   
)

◆ TEST() [27/41]

testing::internal::TEST ( FormatCompilerIndependentFileLocationTest  ,
FormatsUknownFile   
)

◆ TEST() [28/41]

testing::internal::TEST ( FormatCompilerIndependentFileLocationTest  ,
FormatsUknownLine   
)

◆ TEST() [29/41]

testing::internal::TEST ( FormatCompilerIndependentFileLocationTest  ,
FormatsUknownFileAndLine   
)

◆ TEST() [30/41]

testing::internal::TEST ( GetThreadCountTest  ,
ReturnsZeroWhenUnableToCountThreads   
)

◆ TEST() [31/41]

testing::internal::TEST ( GtestCheckDeathTest  ,
DiesWithCorrectOutputOnFailure   
)

◆ TEST() [32/41]

testing::internal::TEST ( RegexEngineSelectionTest  ,
SelectsCorrectRegexEngine   
)

◆ TEST() [33/41]

testing::internal::TEST ( CaptureTest  ,
CapturesStdout   
)

◆ TEST() [34/41]

testing::internal::TEST ( CaptureTest  ,
CapturesStderr   
)

◆ TEST() [35/41]

testing::internal::TEST ( CaptureTest  ,
CapturesStdoutAndStderr   
)

◆ TEST() [36/41]

testing::internal::TEST ( CaptureDeathTest  ,
CannotReenterStdoutCapture   
)

◆ TEST() [37/41]

testing::internal::TEST ( ThreadLocalTest  ,
DefaultConstructorInitializesToDefaultValues   
)

◆ TEST() [38/41]

testing::internal::TEST ( ThreadLocalTest  ,
SingleParamConstructorInitializesToParam   
)

◆ TEST() [39/41]

testing::internal::TEST ( ThreadLocalTest  ,
ValueDefaultContructorIsNotRequiredForParamVersion   
)

◆ TEST() [40/41]

testing::internal::TEST ( ThreadLocalTest  ,
GetAndPointerReturnSameValue   
)

◆ TEST() [41/41]

testing::internal::TEST ( ThreadLocalTest  ,
PointerAndConstPointerReturnSameValue   
)

◆ TEST_F() [1/2]

testing::internal::TEST_F ( ListenerTest  ,
DoesFoo   
)

◆ TEST_F() [2/2]

testing::internal::TEST_F ( ListenerTest  ,
DoesBar   
)

◆ TestCaseFailed()

static bool testing::internal::TestCaseFailed ( const TestCase test_case)
static

◆ TestCasePassed()

static bool testing::internal::TestCasePassed ( const TestCase test_case)
static

◆ ToLower()

char testing::internal::ToLower ( char  ch)
inline

◆ ToUpper()

char testing::internal::ToUpper ( char  ch)
inline

◆ UniversalPrint()

template<typename T >
void testing::internal::UniversalPrint ( const T &  value,
::std::ostream *  os 
)

◆ UniversalPrintArray() [1/5]

void testing::internal::UniversalPrintArray ( const char *  begin,
size_t  len,
ostream *  os 
)

◆ UniversalPrintArray() [2/5]

void testing::internal::UniversalPrintArray ( const wchar_t *  begin,
size_t  len,
ostream *  os 
)

◆ UniversalPrintArray() [3/5]

template<typename T >
void testing::internal::UniversalPrintArray ( const T *  begin,
size_t  len,
::std::ostream *  os 
)

◆ UniversalPrintArray() [4/5]

GTEST_API_ void testing::internal::UniversalPrintArray ( const char *  begin,
size_t  len,
::std::ostream *  os 
)

◆ UniversalPrintArray() [5/5]

GTEST_API_ void testing::internal::UniversalPrintArray ( const wchar_t *  begin,
size_t  len,
::std::ostream *  os 
)

◆ UniversalPrintCharArray()

template<typename CharType >
GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ static GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ void testing::internal::UniversalPrintCharArray ( const CharType *  begin,
size_t  len,
ostream *  os 
)
static

◆ UniversalTersePrint()

template<typename T >
void testing::internal::UniversalTersePrint ( const T &  value,
::std::ostream *  os 
)

◆ WideStringToUtf8()

std::string testing::internal::WideStringToUtf8 ( const wchar_t *  str,
int  num_chars 
)

◆ WriteToShardStatusFileIfNeeded()

void testing::internal::WriteToShardStatusFileIfNeeded ( )

Variable Documentation

◆ g_argvs

::std::vector<testing::internal::string> testing::internal::g_argvs

◆ g_help_flag

bool testing::internal::g_help_flag = false

◆ GTEST_ATTRIBUTE_UNUSED_

class testing::internal::GTestFlagSaver testing::internal::GTEST_ATTRIBUTE_UNUSED_

◆ kAlsoRunDisabledTestsFlag

const char testing::internal::kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"

◆ kBreakOnFailureFlag

const char testing::internal::kBreakOnFailureFlag[] = "break_on_failure"

◆ kCatchExceptionsFlag

const char testing::internal::kCatchExceptionsFlag[] = "catch_exceptions"

◆ kColorEncodedHelpMessage

const char testing::internal::kColorEncodedHelpMessage[]
static

◆ kColorFlag

const char testing::internal::kColorFlag[] = "color"

◆ kCurrentDirectoryString

const char testing::internal::kCurrentDirectoryString[] = "./"

◆ kDeathTestStyleFlag

const char testing::internal::kDeathTestStyleFlag[] = "death_test_style"

◆ kDeathTestUseFork

const char testing::internal::kDeathTestUseFork[] = "death_test_use_fork"

◆ kFilterFlag

const char testing::internal::kFilterFlag[] = "filter"

◆ kFlagfileFlag

const char testing::internal::kFlagfileFlag[] = "flagfile"

◆ kInternalRunDeathTestFlag

const char testing::internal::kInternalRunDeathTestFlag[] = "internal_run_death_test"

◆ kListTestsFlag

const char testing::internal::kListTestsFlag[] = "list_tests"

◆ kMaxBiggestInt

const BiggestInt testing::internal::kMaxBiggestInt
Initial value:
=
~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1))
long long BiggestInt
Definition: gtest-port.h:2241

◆ kMaxCodePoint1

const UInt32 testing::internal::kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1

◆ kMaxCodePoint2

const UInt32 testing::internal::kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1

◆ kMaxCodePoint3

const UInt32 testing::internal::kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1

◆ kMaxCodePoint4

const UInt32 testing::internal::kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1

◆ kMaxRandomSeed

const int testing::internal::kMaxRandomSeed = 99999

◆ kOutputFlag

const char testing::internal::kOutputFlag[] = "output"

◆ kPathSeparator

const char testing::internal::kPathSeparator = '/'

◆ kPrintTimeFlag

const char testing::internal::kPrintTimeFlag[] = "print_time"

◆ kRandomSeedFlag

const char testing::internal::kRandomSeedFlag[] = "random_seed"

◆ kRepeatFlag

const char testing::internal::kRepeatFlag[] = "repeat"

◆ kShuffleFlag

const char testing::internal::kShuffleFlag[] = "shuffle"

◆ kStackTraceDepthFlag

const char testing::internal::kStackTraceDepthFlag[] = "stack_trace_depth"

◆ kStackTraceMarker

const char testing::internal::kStackTraceMarker = "\nStack trace:\n"

◆ kStdErrFileno

const int testing::internal::kStdErrFileno = STDERR_FILENO

◆ kStdOutFileno

const int testing::internal::kStdOutFileno = STDOUT_FILENO

◆ kStreamResultToFlag

const char testing::internal::kStreamResultToFlag[] = "stream_result_to"

◆ kTestTypeIdInGoogleTest

const TypeId testing::internal::kTestTypeIdInGoogleTest = GetTestTypeId()

◆ kThrowOnFailureFlag

const char testing::internal::kThrowOnFailureFlag[] = "throw_on_failure"

◆ kTypedTestCases

const int testing::internal::kTypedTestCases = 0

◆ kTypedTests

const int testing::internal::kTypedTests = 0

◆ kTypeParamLabel

const char testing::internal::kTypeParamLabel[] = "TypeParam"
static

◆ kUnknownFile

const char testing::internal::kUnknownFile[] = "unknown file"

◆ kValueParamLabel

const char testing::internal::kValueParamLabel[] = "GetParam()"
static