Classes | Namespaces | Defines | Enumerations | Functions | Variables File Reference
#include "gtest/gtest.h"
#include <ctype.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <wchar.h>
#include <wctype.h>
#include <algorithm>
#include <iomanip>
#include <limits>
#include <ostream>
#include <sstream>
#include <vector>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <stddef.h>
#include <string.h>
#include <string>
#include <limits.h>
#include <climits>
Include dependency graph for

Go to the source code of this file.


class  testing::internal::DefaultGlobalTestPartResultReporter
class  testing::internal::DefaultPerThreadTestPartResultReporter
class  testing::internal::GTestFlagSaver
class  testing::internal::OsStackTraceGetter
class  testing::internal::OsStackTraceGetterInterface
class  testing::internal::PrettyUnitTestResultPrinter
class  testing::ScopedFakeTestPartResultReporter
class  testing::internal::ScopedPrematureExitFile
class  testing::internal::SingleFailureChecker
class  testing::internal::TestCaseNameIs
class  testing::internal::TestEventRepeater
class  testing::internal::TestPropertyKeyIs
class  testing::internal::TestResultAccessor
struct  testing::internal::TraceInfo
class  testing::internal::UnitTestImpl
class  testing::internal::UnitTestOptions
class  testing::internal::XmlUnitTestResultPrinter


namespace  testing
namespace  testing::internal
namespace  testing::internal2


#define EXPECT_FATAL_FAILURE(statement, substr)
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr)
#define EXPECT_NONFATAL_FAILURE(statement, substr)
#define GTEST_IMPL_CMP_HELPER_(op_name, op)
#define GTEST_REPEATER_METHOD_(Name, Type)


enum  testing::internal::CharFormat { testing::internal::kAsIs, testing::internal::kHexEscape, testing::internal::kSpecialEscape }
enum  testing::internal::GTestColor { testing::internal::COLOR_DEFAULT, testing::internal::COLOR_RED, testing::internal::COLOR_GREEN, testing::internal::COLOR_YELLOW }


bool testing::internal::AlwaysTrue ()
std::string testing::internal::AppendUserMessage (const std::string &gtest_msg, const Message &user_msg)
template<int kSize>
std::vector< std::string > testing::ArrayAsVector (const char *const (&array)[kSize])
AssertionResult testing::AssertionFailure ()
AssertionResult testing::AssertionFailure (const Message &message)
AssertionResult testing::AssertionSuccess ()
bool testing::internal::BoolFromGTestEnv (const char *flag, bool default_value)
UInt32 testing::internal::ChopLowBits (UInt32 *bits, int n)
AssertionResult testing::internal::CmpHelperEQ (const char *expected_expression, const char *actual_expression, BiggestInt expected, BiggestInt actual)
AssertionResult testing::internal::CmpHelperSTRCASEEQ (const char *expected_expression, const char *actual_expression, const char *expected, const char *actual)
AssertionResult testing::internal::CmpHelperSTRCASENE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult testing::internal::CmpHelperSTREQ (const char *expected_expression, const char *actual_expression, const char *expected, const char *actual)
AssertionResult testing::internal::CmpHelperSTREQ (const char *expected_expression, const char *actual_expression, const wchar_t *expected, const wchar_t *actual)
AssertionResult testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
AssertionResult testing::internal::CmpHelperSTRNE (const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
GTEST_API_ std::string testing::internal::CodePointToUtf8 (UInt32 code_point)
void testing::internal::ColoredPrintf (GTestColor color, const char *fmt,...)
template<class Container , typename Predicate >
int testing::internal::CountIf (const Container &c, Predicate predicate)
UInt32 testing::internal::CreateCodePointFromUtf16SurrogatePair (wchar_t first, wchar_t second)
template<typename T >
static void testing::internal::Delete (T *x)
AssertionResult testing::DoubleLE (const char *expr1, const char *expr2, double val1, double val2)
AssertionResult testing::internal::DoubleNearPredFormat (const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
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)
static std::string testing::internal::FlagToEnvVar (const char *flag)
template<typename RawType >
AssertionResult testing::internal::FloatingPointLE (const char *expr1, const char *expr2, RawType val1, RawType val2)
AssertionResult testing::FloatLE (const char *expr1, const char *expr2, float val1, float val2)
template<class Container , typename Functor >
void testing::internal::ForEach (const Container &c, Functor functor)
GTEST_API_::std::string testing::internal::FormatCompilerIndependentFileLocation (const char *file, int line)
static std::string testing::FormatCountableNoun (int count, const char *singular_form, const char *plural_form)
GTEST_API_ std::string testing::internal::FormatEpochTimeInMillisAsIso8601 (TimeInMillis ms)
GTEST_API_::std::string testing::internal::FormatFileLocation (const char *file, int line)
static std::string testing::FormatTestCaseCount (int test_case_count)
static std::string testing::FormatTestCount (int test_count)
GTEST_API_ std::string testing::internal::FormatTimeInMillisAsSeconds (TimeInMillis ms)
static std::string testing::FormatWordList (const std::vector< std::string > &words)
const char * testing::internal::GetAnsiColorCode (GTestColor color)
std::string testing::internal::GetBoolAssertionFailureMessage (const AssertionResult &assertion_result, const char *expression_text, const char *actual_predicate_value, const char *expected_predicate_value)
GTEST_API_ FilePath testing::internal::GetCurrentExecutableName ()
std::string testing::internal::GetCurrentOsStackTraceExceptTop (UnitTest *, int skip_count)
static const char * testing::GetDefaultFilter ()
template<typename E >
testing::internal::GetElementOr (const std::vector< E > &v, int i, E default_value)
int testing::internal::GetNextRandomSeed (int seed)
int testing::internal::GetRandomSeedFromFlag (Int32 random_seed_flag)
static std::vector< std::string > testing::GetReservedAttributesForElement (const std::string &xml_element)
TypeId testing::internal::GetTestTypeId ()
size_t testing::internal::GetThreadCount ()
GTEST_API_ TimeInMillis testing::internal::GetTimeInMillis ()
UnitTestImpl * testing::internal::GetUnitTestImpl ()
 testing::GTEST_DECLARE_bool_ (death_test_use_fork)
 testing::GTEST_DEFINE_bool_ (also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false),"Run disabled tests too, in addition to the tests normally being run.")
 testing::GTEST_DEFINE_bool_ (break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),"True iff a failed assertion should be a debugger break-point.")
 testing::GTEST_DEFINE_bool_ (catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true),"True iff "GTEST_NAME_" should catch exceptions and treat them as test failures.")
 testing::GTEST_DEFINE_bool_ (list_tests, false,"List all tests without running them.")
 testing::GTEST_DEFINE_bool_ (print_time, internal::BoolFromGTestEnv("print_time", true),"True iff "GTEST_NAME_" should display elapsed time in text output.")
 testing::GTEST_DEFINE_bool_ (show_internal_stack_frames, false,"True iff "GTEST_NAME_" should include internal stack frames when ""printing test failure stack traces.")
 testing::GTEST_DEFINE_bool_ (shuffle, internal::BoolFromGTestEnv("shuffle", false),"True iff "GTEST_NAME_" should randomize tests' order on every run.")
 testing::GTEST_DEFINE_bool_ (throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false),"When this flag is specified, a failed assertion will throw an exception ""if exceptions are enabled or exit the program with a non-zero code ""otherwise.")
 testing::GTEST_DEFINE_bool_ (death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false),"Instructs to use fork()/_exit() instead of clone() in death tests. ""Ignored and always uses fork() on POSIX systems where clone() is not ""implemented. Useful when running under valgrind or similar tools if ""those do not support clone(). Valgrind 3.3.1 will just fail if ""it sees an unsupported combination of clone() flags. ""It is not recommended to use this flag w/o valgrind though it will ""work in 99% of the cases. Once valgrind is fixed, this flag will ""most likely be removed.")
 testing::GTEST_DEFINE_int32_ (random_seed, internal::Int32FromGTestEnv("random_seed", 0),"Random number seed to use when shuffling test orders. Must be in range ""[1, 99999], or 0 to use a seed based on the current time.")
 testing::GTEST_DEFINE_int32_ (repeat, internal::Int32FromGTestEnv("repeat", 1),"How many times to repeat each test. Specify a negative number ""for repeating forever. Useful for shaking out flaky tests.")
 testing::GTEST_DEFINE_int32_ (stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),"The maximum number of stack frames to print when an ""assertion fails. The valid range is 0 through 100, inclusive.")
GTEST_API_ testing::internal::GTEST_DEFINE_STATIC_MUTEX_ (g_linked_ptr_mutex)
 testing::GTEST_DEFINE_string_ (color, internal::StringFromGTestEnv("color","auto"),"Whether to use colors in the output. Valid values: yes, no, ""and auto. 'auto' means to use colors if the output is ""being sent to a terminal and the TERM environment variable ""is set to a terminal type that supports colors.")
 testing::GTEST_DEFINE_string_ (filter, internal::StringFromGTestEnv("filter", GetDefaultFilter()),"A colon-separated list of glob (not regex) patterns ""for filtering the tests to run, optionally followed by a ""'-' and a : separated list of negative patterns (tests to ""exclude). A test is run if it matches one of the positive ""patterns and does not match any of the negative patterns.")
 testing::GTEST_DEFINE_string_ (output, internal::StringFromGTestEnv("output",""),"A format (currently must be \"xml\"), optionally followed ""by a colon and an output file name or directory. A directory ""is indicated by a trailing pathname separator. ""Examples: \"xml:filename.xml\", \"xml::directoryname/\". ""If a directory is specified, output files will be created ""within that directory, with file-names based on the test ""executable's name and, if necessary, made unique by adding ""digits.")
 testing::GTEST_DEFINE_string_ (stream_result_to, internal::StringFromGTestEnv("stream_result_to",""),"This flag specifies the host name and the port number on which to stream ""test results. Example: \"localhost:555\". The flag is effective only on ""Linux.")
 testing::GTEST_DEFINE_string_ (death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),"Indicates how to run a death test in a forked child process: ""\"threadsafe\" (child process re-executes the test binary ""from the beginning, running only the specific death test) or ""\"fast\" (child process runs the death test immediately ""after forking).")
 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.")
static bool testing::internal::GTestIsInitialized ()
template<class T , typename Result >
Result testing::internal::HandleExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
template<class T , typename Result >
Result testing::internal::HandleSehExceptionsInMethodIfSupported (T *object, Result(T::*method)(), const char *location)
static bool testing::internal::HasGoogleTestFlagPrefix (const char *str)
AssertionResult testing::internal::HasOneFailure (const char *, const char *, const char *, const TestPartResultArray &results, TestPartResult::Type type, const string &substr)
void testing::InitGoogleTest (int *argc, char **argv)
void testing::InitGoogleTest (int *argc, wchar_t **argv)
template<typename CharType >
void testing::internal::InitGoogleTestImpl (int *argc, CharType **argv)
GTEST_API_ Int32 testing::internal::Int32FromEnvOrDie (const char *env_var, Int32 default_val)
Int32 testing::internal::Int32FromGTestEnv (const char *flag, Int32 default_value)
AssertionResult testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult testing::IsNotSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
static bool testing::internal::IsPathSeparator (char c)
bool testing::internal::IsPrintableAscii (wchar_t c)
AssertionResult testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
AssertionResult testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const wchar_t *needle, const wchar_t *haystack)
AssertionResult testing::IsSubstring (const char *needle_expr, const char *haystack_expr, const ::std::string &needle, const ::std::string &haystack)
bool testing::internal::IsTrue (bool condition)
bool testing::internal::IsUtf16SurrogatePair (wchar_t first, wchar_t second)
TestInfo * testing::internal::MakeAndRegisterTestInfo (const char *test_case_name, const char *name, const char *type_param, const char *value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
std::ostream & testing::operator<< (std::ostream &os, const TestPartResult &result)
bool testing::internal::ParseBoolFlag (const char *str, const char *flag, bool *value)
const char * testing::internal::ParseFlagValue (const char *str, const char *flag, bool def_optional)
GTEST_API_ void testing::internal::ParseGoogleTestFlagsOnly (int *argc, char **argv)
GTEST_API_ void testing::internal::ParseGoogleTestFlagsOnly (int *argc, wchar_t **argv)
template<typename CharType >
void testing::internal::ParseGoogleTestFlagsOnlyImpl (int *argc, CharType **argv)
bool testing::internal::ParseInt32 (const Message &src_text, const char *str, Int32 *value)
GTEST_API_ bool testing::internal::ParseInt32Flag (const char *str, const char *flag, Int32 *value)
bool testing::internal::ParseStringFlag (const char *str, const char *flag, std::string *value)
template<typename UnsignedChar , typename Char >
static CharFormat testing::internal::PrintAsCharLiteralTo (Char c, ostream *os)
static CharFormat testing::internal::PrintAsStringLiteralTo (wchar_t c, ostream *os)
static CharFormat testing::internal::PrintAsStringLiteralTo (char c, ostream *os)
void testing::internal2::PrintBytesInObjectTo (const unsigned char *obj_bytes, size_t count, ostream *os)
template<typename UnsignedChar , typename Char >
void testing::internal::PrintCharAndCodeTo (Char c, ostream *os)
template<typename CharType >
static void testing::internal::PrintCharsAsStringTo (const CharType *begin, size_t len, ostream *os)
static void testing::internal::PrintColorEncoded (const char *str)
void testing::internal::PrintFullTestCommentIfPresent (const TestInfo &test_info)
static void testing::internal::PrintOnOneLine (const char *str, int max_length)
void testing::internal::PrintStringTo (const ::std::string &s, ostream *os)
static void testing::internal::PrintTestPartResult (const TestPartResult &test_part_result)
static std::string testing::internal::PrintTestPartResultToString (const TestPartResult &test_part_result)
void testing::internal::PrintTo (unsigned char c,::std::ostream *os)
void testing::internal::PrintTo (signed char c,::std::ostream *os)
void testing::internal::PrintTo (wchar_t wc, ostream *os)
void testing::internal::PrintTo (const char *s, ostream *os)
void testing::internal::PrintTo (const wchar_t *s, ostream *os)
void testing::internal::ReportFailureInUnknownLocation (TestPartResult::Type result_type, const std::string &message)
static void testing::internal::SetUpEnvironment (Environment *env)
static bool testing::internal::ShouldRunTestCase (const TestCase *test_case)
GTEST_API_ bool testing::internal::ShouldRunTestOnShard (int total_shards, int shard_index, int test_id)
GTEST_API_ bool testing::internal::ShouldShard (const char *total_shards_str, const char *shard_index_str, bool in_subprocess_for_death_test)
GTEST_API_ bool testing::internal::ShouldUseColor (bool stdout_is_tty)
template<typename E >
void testing::internal::Shuffle (internal::Random *random, std::vector< E > *v)
template<typename E >
void testing::internal::ShuffleRange (internal::Random *random, int begin, int end, std::vector< E > *v)
bool testing::internal::SkipPrefix (const char *prefix, const char **pstr)
const char * testing::internal::StringFromGTestEnv (const char *flag, const char *default_value)
std::string testing::internal::StringStreamToString (::std::stringstream *ss)
static int testing::internal::SumOverTestCaseList (const std::vector< TestCase * > &case_list, int(TestCase::*method)() const)
static void testing::internal::TearDownEnvironment (Environment *env)
static bool testing::internal::TestCaseFailed (const TestCase *test_case)
static bool testing::internal::TestCasePassed (const TestCase *test_case)
static bool testing::TestPartFatallyFailed (const TestPartResult &result)
static bool testing::TestPartNonfatallyFailed (const TestPartResult &result)
static const char * testing::TestPartResultTypeToString (TestPartResult::Type type)
void testing::internal::UniversalPrintArray (const char *begin, size_t len, ostream *os)
void testing::internal::UniversalPrintArray (const wchar_t *begin, size_t len, ostream *os)
template<typename CharType >
static void testing::internal::UniversalPrintCharArray (const CharType *begin, size_t len, ostream *os)
bool testing::ValidateTestPropertyName (const std::string &property_name, const std::vector< std::string > &reserved_names)
GTEST_API_ std::string testing::internal::WideStringToUtf8 (const wchar_t *str, int num_chars)
void testing::internal::WriteToShardStatusFileIfNeeded ()


std::string testing::internal::g_executable_path
GTEST_API_ bool testing::internal::g_help_flag = false
GTEST_API_ int testing::internal::g_init_gtest_count = 0
const char testing::internal::kAlsoRunDisabledTestsFlag [] = "also_run_disabled_tests"
const char testing::internal::kBreakOnFailureFlag [] = "break_on_failure"
const char testing::internal::kCatchExceptionsFlag [] = "catch_exceptions"
static const char testing::internal::kColorEncodedHelpMessage [] = ">@D.\n"
const char testing::internal::kColorFlag [] = "color"
const char testing::internal::kCurrentDirectoryString [] = "./"
static const char testing::kDeathTestCaseFilter [] = "*DeathTest:*DeathTest/*"
static const char testing::kDefaultDeathTestStyle [] = "fast"
static const char testing::kDefaultOutputFile [] = "test_detail.xml"
static const char testing::kDisableTestFilter [] = "DISABLED_*:*/DISABLED_*"
const char testing::internal::kFilterFlag [] = "filter"
const char testing::internal::kListTestsFlag [] = "list_tests"
const UInt32 testing::internal::kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1
const UInt32 testing::internal::kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1
const UInt32 testing::internal::kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1
const UInt32 testing::internal::kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1
const int testing::internal::kMaxRandomSeed = 99999
const char testing::internal::kOutputFlag [] = "output"
const char testing::internal::kPathSeparator = '/'
const char testing::internal::kPathSeparatorString [] = "/"
const char testing::internal::kPrintTimeFlag [] = "print_time"
const char testing::internal::kRandomSeedFlag [] = "random_seed"
const char testing::internal::kRepeatFlag [] = "repeat"
static const char *const testing::kReservedTestCaseAttributes []
static const char *const testing::kReservedTestSuiteAttributes []
static const char *const testing::kReservedTestSuitesAttributes []
const char testing::internal::kShuffleFlag [] = "shuffle"
const char testing::internal::kStackTraceDepthFlag [] = "stack_trace_depth"
const char testing::internal::kStackTraceMarker [] = "\nStack trace:\n"
const int testing::internal::kStdErrFileno = STDERR_FILENO
const int testing::internal::kStdOutFileno = STDOUT_FILENO
const char testing::internal::kStreamResultToFlag [] = "stream_result_to"
static const char testing::kTestShardIndex [] = "GTEST_SHARD_INDEX"
static const char testing::kTestShardStatusFile [] = "GTEST_SHARD_STATUS_FILE"
static const char testing::kTestTotalShards [] = "GTEST_TOTAL_SHARDS"
GTEST_API_ const TypeId testing::internal::kTestTypeIdInGoogleTest = GetTestTypeId()
const char testing::internal::kThrowOnFailureFlag [] = "throw_on_failure"
static const char testing::internal::kTypeParamLabel [] = "TypeParam"
static const char testing::kUniversalFilter [] = "*"
const char testing::internal::kUnknownFile [] = "unknown file"
static const char testing::internal::kValueParamLabel [] = "GetParam()"

Define Documentation

#define EXPECT_FATAL_FAILURE (   statement,
do { \
    class GTestExpectFatalFailureHelper {\
      static void Execute() { statement; }\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
  } while (::testing::internal::AlwaysFalse())

Definition at line 211 of file

do { \
    class GTestExpectFatalFailureHelper {\
      static void Execute() { statement; }\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ALL_THREADS, &gtest_failures);\
  } while (::testing::internal::AlwaysFalse())

Definition at line 228 of file

#define EXPECT_NONFATAL_FAILURE (   statement,
do {\
    ::testing::TestPartResultArray gtest_failures;\
    ::testing::internal::SingleFailureChecker gtest_checker(\
        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
          ::testing::ScopedFakeTestPartResultReporter:: \
          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
      if (::testing::internal::AlwaysTrue()) { statement; }\
  } while (::testing::internal::AlwaysFalse())

Definition at line 277 of file


Definition at line 291 of file


Definition at line 381 of file

#define GTEST_IMPL_CMP_HELPER_ (   op_name,
AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                   BiggestInt val1, BiggestInt val2) {\
  if (val1 op val2) {\
    return AssertionSuccess();\
  } else {\
    return AssertionFailure() \
        << "Expected: (" << expr1 << ") " #op " (" << expr2\
        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
        << " vs " << FormatForComparisonFailureMessage(val2, val1);\

Definition at line 2616 of file


Definition at line 9416 of file


Definition at line 9416 of file


Definition at line 9416 of file


Definition at line 9416 of file

Definition at line 110 of file


Definition at line 7893 of file

#define GTEST_REPEATER_METHOD_ (   Name,
void TestEventRepeater::Name(const Type& parameter) { \
  if (forwarding_enabled_) { \
    for (size_t i = 0; i < listeners_.size(); i++) { \
      listeners_[i]->Name(parameter); \
    } \
  } \

Definition at line 4441 of file

void TestEventRepeater::Name(const Type& parameter) { \
  if (forwarding_enabled_) { \
    for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \
      listeners_[i]->Name(parameter); \
    } \
  } \

Definition at line 4451 of file

Definition at line 442 of file

Variable Documentation

std::string name_

Definition at line 3761 of file

Author(s): Kevin Watts, Brice Rebsamen
autogenerated on Tue Mar 26 2019 03:09:37