From 1ce454985edf37b17f2f266d499c2b7dec339002 Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Mon, 22 Mar 2010 21:23:51 +0000 Subject: Adds missing gtest DLL exports. git-svn-id: http://googletest.googlecode.com/svn/trunk@399 861a406c-534a-0410-8894-cb66d6ee9925 --- CMakeLists.txt | 25 +- Makefile.am | 3 +- include/gtest/gtest.h | 38 +-- include/gtest/internal/gtest-filepath.h | 2 +- include/gtest/internal/gtest-internal.h | 11 +- include/gtest/internal/gtest-port.h | 12 +- src/gtest-internal-inl.h | 72 +++-- src/gtest_main.cc | 2 +- test/gtest-filepath_test.cc | 2 - test/gtest-options_test.cc | 139 +++------ test/gtest_all_test.cc | 1 + test/gtest_color_test_.cc | 13 +- test/gtest_dll_test_.cc | 509 -------------------------------- test/gtest_unittest.cc | 7 - 14 files changed, 143 insertions(+), 693 deletions(-) delete mode 100644 test/gtest_dll_test_.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index 74c5e96..c9805a3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -124,15 +124,12 @@ target_link_libraries(gtest_main gtest) option(build_gtest_samples "Build gtest's sample programs." OFF) -# cxx_executable(name dir lib srcs...) +# cxx_executable_with_flags(name cxx_flags lib srcs...) # -# creates a named target that depends on the given lib and is built -# from the given source files. dir/name.cc is implicitly included in -# the source file list. -function(cxx_executable_with_flags name dir cxx_flags lib) - add_executable(${name} - ${dir}/${name}.cc - ${ARGN}) +# creates a named C++ executable that depends on the given library and +# is built from the given source files with the given compiler flags. +function(cxx_executable_with_flags name cxx_flags lib) + add_executable(${name} ${ARGN}) if (cxx_flags) set_target_properties(${name} PROPERTIES @@ -141,8 +138,14 @@ function(cxx_executable_with_flags name dir cxx_flags lib) target_link_libraries(${name} ${lib}) endfunction() +# cxx_executable(name dir lib srcs...) +# +# creates a named target that depends on the given lib and is built +# from the given source files. dir/name.cc is implicitly included in +# the source file list. function(cxx_executable name dir lib) - cxx_executable_with_flags(${name} ${dir} "${cxx_default}" ${lib} ${ARGN}) + cxx_executable_with_flags( + ${name} "${cxx_default}" ${lib} "${dir}/${name}.cc" ${ARGN}) endfunction() if (build_gtest_samples) @@ -273,8 +276,8 @@ if (build_all_gtest_tests) # TODO(vladl): This and the next tests may not run in the hermetic # environment on Windows. Re-evaluate and possibly make them # platform-conditional after implementing hermetic builds. - cxx_executable_with_flags(gtest_dll_test_ test "${cxx_use_shared_gtest}" - gtest_dll) + cxx_executable_with_flags(gtest_dll_test_ "${cxx_use_shared_gtest}" + gtest_dll test/gtest_all_test.cc) if (NOT(MSVC AND (MSVC_VERSION EQUAL 1600))) # The C++ Standard specifies tuple_element. diff --git a/Makefile.am b/Makefile.am index 015269c..9f103a3 100644 --- a/Makefile.am +++ b/Makefile.am @@ -82,8 +82,7 @@ EXTRA_DIST += \ test/gtest_uninitialized_test_.cc \ test/gtest_xml_outfile1_test_.cc \ test/gtest_xml_outfile2_test_.cc \ - test/gtest_xml_output_unittest_.cc \ - test/gtest_dll_test_.cc + test/gtest_xml_output_unittest_.cc # Python tests that we don't run. EXTRA_DIST += \ diff --git a/include/gtest/gtest.h b/include/gtest/gtest.h index 446f028..ee7a8d5 100644 --- a/include/gtest/gtest.h +++ b/include/gtest/gtest.h @@ -1278,10 +1278,10 @@ AssertionResult CmpHelperEQ(const char* expected_expression, // With this overloaded version, we allow anonymous enums to be used // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums // can be implicitly cast to BiggestInt. -AssertionResult CmpHelperEQ(const char* expected_expression, - const char* actual_expression, - BiggestInt expected, - BiggestInt actual); +GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual); // The helper class for {ASSERT|EXPECT}_EQ. The template argument // lhs_is_null_literal is true iff the first argument to ASSERT_EQ() @@ -1370,21 +1370,21 @@ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ return AssertionFailure(msg);\ }\ }\ -AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ - BiggestInt val1, BiggestInt val2); +GTEST_API_ AssertionResult CmpHelper##op_name(\ + const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // Implements the helper function for {ASSERT|EXPECT}_NE -GTEST_IMPL_CMP_HELPER_(NE, !=) +GTEST_IMPL_CMP_HELPER_(NE, !=); // Implements the helper function for {ASSERT|EXPECT}_LE -GTEST_IMPL_CMP_HELPER_(LE, <=) +GTEST_IMPL_CMP_HELPER_(LE, <=); // Implements the helper function for {ASSERT|EXPECT}_LT -GTEST_IMPL_CMP_HELPER_(LT, < ) +GTEST_IMPL_CMP_HELPER_(LT, < ); // Implements the helper function for {ASSERT|EXPECT}_GE -GTEST_IMPL_CMP_HELPER_(GE, >=) +GTEST_IMPL_CMP_HELPER_(GE, >=); // Implements the helper function for {ASSERT|EXPECT}_GT -GTEST_IMPL_CMP_HELPER_(GT, > ) +GTEST_IMPL_CMP_HELPER_(GT, > ); #undef GTEST_IMPL_CMP_HELPER_ @@ -1447,30 +1447,30 @@ GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, // // The {needle,haystack}_expr arguments are the stringified // expressions that generated the two real arguments. -AssertionResult IsSubstring( +GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); -AssertionResult IsSubstring( +GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); -AssertionResult IsNotSubstring( +GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); -AssertionResult IsNotSubstring( +GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); -AssertionResult IsSubstring( +GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); -AssertionResult IsNotSubstring( +GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); #if GTEST_HAS_STD_WSTRING -AssertionResult IsSubstring( +GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); -AssertionResult IsNotSubstring( +GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); #endif // GTEST_HAS_STD_WSTRING diff --git a/include/gtest/internal/gtest-filepath.h b/include/gtest/internal/gtest-filepath.h index 394f26a..4b76d79 100644 --- a/include/gtest/internal/gtest-filepath.h +++ b/include/gtest/internal/gtest-filepath.h @@ -56,7 +56,7 @@ namespace internal { // Names are NOT checked for syntax correctness -- no checking for illegal // characters, malformed paths, etc. -class FilePath { +class GTEST_API_ FilePath { public: FilePath() : pathname_("") { } FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } diff --git a/include/gtest/internal/gtest-internal.h b/include/gtest/internal/gtest-internal.h index 7bc35e2..31a66e9 100644 --- a/include/gtest/internal/gtest-internal.h +++ b/include/gtest/internal/gtest-internal.h @@ -120,7 +120,7 @@ extern int g_init_gtest_count; // The text used in failure messages to indicate the start of the // stack trace. -extern const char kStackTraceMarker[]; +GTEST_API_ extern const char kStackTraceMarker[]; // A secret type that Google Test users don't know about. It has no // definition on purpose. Therefore it's impossible to create a @@ -157,8 +157,8 @@ char (&IsNullLiteralHelper(...))[2]; // NOLINT #endif // GTEST_ELLIPSIS_NEEDS_POD_ // Appends the user-supplied message to the Google-Test-generated message. -String AppendUserMessage(const String& gtest_msg, - const Message& user_msg); +GTEST_API_ String AppendUserMessage(const String& gtest_msg, + const Message& user_msg); // A helper class for creating scoped traces in user programs. class GTEST_API_ ScopedTrace { @@ -750,7 +750,8 @@ class TypeParameterizedTestCase { // For example, if Foo() calls Bar(), which in turn calls // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. -String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test, int skip_count); +GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test, + int skip_count); // Helpers for suppressing warnings on unreachable code or constant // condition. @@ -766,7 +767,7 @@ inline bool AlwaysFalse() { return !AlwaysTrue(); } // doesn't use global state (and therefore can't interfere with user // code). Unlike rand_r(), it's portable. An LCG isn't very random, // but it's good enough for our purposes. -class Random { +class GTEST_API_ Random { public: static const UInt32 kMaxRange = 1u << 31; diff --git a/include/gtest/internal/gtest-port.h b/include/gtest/internal/gtest-port.h index 0b00c99..23c2ff6 100644 --- a/include/gtest/internal/gtest-port.h +++ b/include/gtest/internal/gtest-port.h @@ -782,10 +782,10 @@ inline void FlushInfoLog() { fflush(NULL); } // CaptureStderr - starts capturing stderr. // GetCapturedStderr - stops capturing stderr and returns the captured string. // -void CaptureStdout(); -String GetCapturedStdout(); -void CaptureStderr(); -String GetCapturedStderr(); +GTEST_API_ void CaptureStdout(); +GTEST_API_ String GetCapturedStdout(); +GTEST_API_ void CaptureStderr(); +GTEST_API_ String GetCapturedStderr(); #endif // GTEST_HAS_STREAM_REDIRECTION_ @@ -1135,7 +1135,7 @@ class ThreadLocal { // Returns the number of threads running in the process, or 0 to indicate that // we cannot detect it. -size_t GetThreadCount(); +GTEST_API_ size_t GetThreadCount(); // Passing non-POD classes through ellipsis (...) crashes the ARM // compiler and generates a warning in Sun Studio. The Nokia Symbian @@ -1414,7 +1414,7 @@ bool ParseInt32(const Message& src_text, const char* str, Int32* value); // Parses a bool/Int32/string from the environment variable // corresponding to the given Google Test flag. bool BoolFromGTestEnv(const char* flag, bool default_val); -Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); +GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); const char* StringFromGTestEnv(const char* flag, const char* default_val); } // namespace internal diff --git a/src/gtest-internal-inl.h b/src/gtest-internal-inl.h index 269798a..855b215 100644 --- a/src/gtest-internal-inl.h +++ b/src/gtest-internal-inl.h @@ -78,7 +78,7 @@ namespace internal { // The value of GetTestTypeId() as seen from within the Google Test // library. This is solely for testing GetTestTypeId(). -extern const TypeId kTestTypeIdInGoogleTest; +GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; // Names of the flags (needed for parsing Google Test flags). const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; @@ -98,8 +98,25 @@ const char kThrowOnFailureFlag[] = "throw_on_failure"; // A valid random seed must be in [1, kMaxRandomSeed]. const int kMaxRandomSeed = 99999; +// g_help_flag is true iff the --help flag or an equivalent form is +// specified on the command line. +GTEST_API_ extern bool g_help_flag; + // Returns the current time in milliseconds. -TimeInMillis GetTimeInMillis(); +GTEST_API_ TimeInMillis GetTimeInMillis(); + +// Returns true iff Google Test should use colors in the output. +GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); + +// Formats the given time in milliseconds as seconds. +GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); + +// Parses a string for an Int32 flag, in the form of "--flag=value". +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +GTEST_API_ bool ParseInt32Flag( + const char* str, const char* flag, Int32* value); // Returns a random seed in range [1, kMaxRandomSeed] based on the // given --gtest_random_seed flag value. @@ -199,7 +216,7 @@ class GTestFlagSaver { // If the code_point is not a valid Unicode code point // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output // as '(Invalid Unicode 0xXXXXXXXX)'. -char* CodePointToUtf8(UInt32 code_point, char* str); +GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str); // Converts a wide string to a narrow string in UTF-8 encoding. // The wide string is assumed to have the following encoding: @@ -214,10 +231,7 @@ char* CodePointToUtf8(UInt32 code_point, char* str); // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding // and contains invalid UTF-16 surrogate pairs, values in those pairs // will be encoded as individual Unicode characters from Basic Normal Plane. -String WideStringToUtf8(const wchar_t* str, int num_chars); - -// Returns the number of active threads, or 0 when there is an error. -size_t GetThreadCount(); +GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars); // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file // if the variable is present. If a file already exists at this location, this @@ -231,19 +245,21 @@ void WriteToShardStatusFileIfNeeded(); // an error and exits. If in_subprocess_for_death_test, sharding is // disabled because it must only be applied to the original test // process. Otherwise, we could filter out death tests we intended to execute. -bool ShouldShard(const char* total_shards_str, const char* shard_index_str, - bool in_subprocess_for_death_test); +GTEST_API_ bool ShouldShard(const char* total_shards_str, + const char* shard_index_str, + bool in_subprocess_for_death_test); // Parses the environment variable var as an Int32. If it is unset, // returns default_val. If it is not an Int32, prints an error and // and aborts. -Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); +GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); // Given the total number of shards, the shard index, and the test id, // returns true iff the test should be run on this shard. The test id is // some arbitrary but unique non-negative integer assigned to each test // method. Assumes that 0 <= shard_index < total_shards. -bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id); +GTEST_API_ bool ShouldRunTestOnShard( + int total_shards, int shard_index, int test_id); // STL container utilities. @@ -413,7 +429,7 @@ class TestInfoImpl { // test filter using either GTEST_FILTER or --gtest_filter. If both // the variable and the flag are present, the latter overrides the // former. -class UnitTestOptions { +class GTEST_API_ UnitTestOptions { public: // Functions for processing the gtest_output flag. @@ -455,7 +471,7 @@ class UnitTestOptions { // Returns the current application's name, removing directory path if that // is present. Used by UnitTestOptions::GetOutputFile. -FilePath GetCurrentExecutableName(); +GTEST_API_ FilePath GetCurrentExecutableName(); // The role interface for getting the OS stack trace as a string. class OsStackTraceGetterInterface { @@ -546,7 +562,7 @@ class DefaultPerThreadTestPartResultReporter // the methods under a mutex, as this class is not accessible by a // user and the UnitTest class that delegates work to this class does // proper locking. -class UnitTestImpl { +class GTEST_API_ UnitTestImpl { public: explicit UnitTestImpl(UnitTest* parent); virtual ~UnitTestImpl(); @@ -938,24 +954,24 @@ inline UnitTestImpl* GetUnitTestImpl() { // Internal helper functions for implementing the simple regular // expression matcher. -bool IsInSet(char ch, const char* str); -bool IsDigit(char ch); -bool IsPunct(char ch); -bool IsRepeat(char ch); -bool IsWhiteSpace(char ch); -bool IsWordChar(char ch); -bool IsValidEscape(char ch); -bool AtomMatchesChar(bool escaped, char pattern, char ch); -bool ValidateRegex(const char* regex); -bool MatchRegexAtHead(const char* regex, const char* str); -bool MatchRepetitionAndRegexAtHead( +GTEST_API_ bool IsInSet(char ch, const char* str); +GTEST_API_ bool IsDigit(char ch); +GTEST_API_ bool IsPunct(char ch); +GTEST_API_ bool IsRepeat(char ch); +GTEST_API_ bool IsWhiteSpace(char ch); +GTEST_API_ bool IsWordChar(char ch); +GTEST_API_ bool IsValidEscape(char ch); +GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); +GTEST_API_ bool ValidateRegex(const char* regex); +GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); +GTEST_API_ bool MatchRepetitionAndRegexAtHead( bool escaped, char ch, char repeat, const char* regex, const char* str); -bool MatchRegexAnywhere(const char* regex, const char* str); +GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); // Parses the command line for Google Test flags, without initializing // other parts of Google Test. -void ParseGoogleTestFlagsOnly(int* argc, char** argv); -void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); #if GTEST_HAS_DEATH_TEST diff --git a/src/gtest_main.cc b/src/gtest_main.cc index 6d4d22d..d20c02f 100644 --- a/src/gtest_main.cc +++ b/src/gtest_main.cc @@ -31,7 +31,7 @@ #include -GTEST_API_ int main(int argc, char **argv) { +int main(int argc, char **argv) { std::cout << "Running main() from gtest_main.cc\n"; testing::InitGoogleTest(&argc, argv); diff --git a/test/gtest-filepath_test.cc b/test/gtest-filepath_test.cc index c5f58f4..6250282 100644 --- a/test/gtest-filepath_test.cc +++ b/test/gtest-filepath_test.cc @@ -688,5 +688,3 @@ TEST(FilePathTest, IsRootDirectory) { } // namespace } // namespace internal } // namespace testing - -#undef GTEST_PATH_SEP_ diff --git a/test/gtest-options_test.cc b/test/gtest-options_test.cc index 31ae327..2e2cbc9 100644 --- a/test/gtest-options_test.cc +++ b/test/gtest-options_test.cc @@ -89,61 +89,38 @@ TEST(XmlOutputTest, GetOutputFileSingleFile) { } TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) { -#if GTEST_OS_WINDOWS - GTEST_FLAG(output) = "xml:path\\"; + GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_; + const std::string expected_output_file = + GetAbsolutePathOf( + FilePath(std::string("path") + GTEST_PATH_SEP_ + + GetCurrentExecutableName().c_str() + ".xml")).c_str(); const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - EXPECT_TRUE( - _strcmpi(output_file.c_str(), - GetAbsolutePathOf( - FilePath("path\\gtest-options_test.xml")).c_str()) == 0 || - _strcmpi(output_file.c_str(), - GetAbsolutePathOf( - FilePath("path\\gtest-options-ex_test.xml")).c_str()) == 0 || - _strcmpi(output_file.c_str(), - GetAbsolutePathOf( - FilePath("path\\gtest_all_test.xml")).c_str()) == 0) - << " output_file = " << output_file; +#if GTEST_OS_WINDOWS + EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); #else - GTEST_FLAG(output) = "xml:path/"; - const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - // TODO(wan@google.com): libtool causes the test binary file to be - // named lt-gtest-options_test. Therefore the output file may be - // named .../lt-gtest-options_test.xml. We should remove this - // hard-coded logic when Chandler Carruth's libtool replacement is - // ready. - EXPECT_TRUE(output_file == - GetAbsolutePathOf( - FilePath("path/gtest-options_test.xml")).c_str() || - output_file == - GetAbsolutePathOf( - FilePath("path/lt-gtest-options_test.xml")).c_str() || - output_file == - GetAbsolutePathOf( - FilePath("path/gtest_all_test.xml")).c_str() || - output_file == - GetAbsolutePathOf( - FilePath("path/lt-gtest_all_test.xml")).c_str()) - << " output_file = " << output_file; + EXPECT_EQ(expected_output_file, output_file.c_str()); #endif } TEST(OutputFileHelpersTest, GetCurrentExecutableName) { - const FilePath executable = GetCurrentExecutableName(); - const char* const exe_str = executable.c_str(); + const std::string exe_str = GetCurrentExecutableName().c_str(); #if GTEST_OS_WINDOWS - ASSERT_TRUE(_strcmpi("gtest-options_test", exe_str) == 0 || - _strcmpi("gtest-options-ex_test", exe_str) == 0 || - _strcmpi("gtest_all_test", exe_str) == 0) - << "GetCurrentExecutableName() returns " << exe_str; + const bool success = + _strcmpi("gtest-options_test", exe_str.c_str()) == 0 || + _strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 || + _strcmpi("gtest_all_test", exe_str.c_str()) == 0 || + _strcmpi("gtest_dll_test", exe_str.c_str()) == 0; #else // TODO(wan@google.com): remove the hard-coded "lt-" prefix when // Chandler Carruth's libtool replacement is ready. - EXPECT_TRUE(String(exe_str) == "gtest-options_test" || - String(exe_str) == "lt-gtest-options_test" || - String(exe_str) == "gtest_all_test" || - String(exe_str) == "lt-gtest_all_test") - << "GetCurrentExecutableName() returns " << exe_str; + const bool success = + exe_str == "gtest-options_test" || + exe_str == "gtest_all_test" || + exe_str == "lt-gtest_all_test" || + exe_str == "gtest_dll_test"; #endif // GTEST_OS_WINDOWS + if (!success) + FAIL() << "GetCurrentExecutableName() returns " << exe_str; } class XmlOutputChangeDirTest : public Test { @@ -185,40 +162,17 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativeFile) { } TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) { -#if GTEST_OS_WINDOWS - GTEST_FLAG(output) = "xml:path\\"; + GTEST_FLAG(output) = "xml:path" GTEST_PATH_SEP_; + const std::string expected_output_file = + FilePath::ConcatPaths( + original_working_dir_, + FilePath(std::string("path") + GTEST_PATH_SEP_ + + GetCurrentExecutableName().c_str() + ".xml")).c_str(); const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - EXPECT_TRUE( - _strcmpi(output_file.c_str(), - FilePath::ConcatPaths( - original_working_dir_, - FilePath("path\\gtest-options_test.xml")).c_str()) == 0 || - _strcmpi(output_file.c_str(), - FilePath::ConcatPaths( - original_working_dir_, - FilePath("path\\gtest-options-ex_test.xml")).c_str()) == 0 || - _strcmpi(output_file.c_str(), - FilePath::ConcatPaths( - original_working_dir_, - FilePath("path\\gtest_all_test.xml")).c_str()) == 0) - << " output_file = " << output_file; +#if GTEST_OS_WINDOWS + EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); #else - GTEST_FLAG(output) = "xml:path/"; - const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - // TODO(wan@google.com): libtool causes the test binary file to be - // named lt-gtest-options_test. Therefore the output file may be - // named .../lt-gtest-options_test.xml. We should remove this - // hard-coded logic when Chandler Carruth's libtool replacement is - // ready. - EXPECT_TRUE(output_file == FilePath::ConcatPaths(original_working_dir_, - FilePath("path/gtest-options_test.xml")).c_str() || - output_file == FilePath::ConcatPaths(original_working_dir_, - FilePath("path/lt-gtest-options_test.xml")).c_str() || - output_file == FilePath::ConcatPaths(original_working_dir_, - FilePath("path/gtest_all_test.xml")).c_str() || - output_file == FilePath::ConcatPaths(original_working_dir_, - FilePath("path/lt-gtest_all_test.xml")).c_str()) - << " output_file = " << output_file; + EXPECT_EQ(expected_output_file, output_file.c_str()); #endif } @@ -236,29 +190,20 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) { TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) { #if GTEST_OS_WINDOWS - GTEST_FLAG(output) = "xml:c:\\tmp\\"; - const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - EXPECT_TRUE( - _strcmpi(output_file.c_str(), - FilePath("c:\\tmp\\gtest-options_test.xml").c_str()) == 0 || - _strcmpi(output_file.c_str(), - FilePath("c:\\tmp\\gtest-options-ex_test.xml").c_str()) == 0 || - _strcmpi(output_file.c_str(), - FilePath("c:\\tmp\\gtest_all_test.xml").c_str()) == 0) - << " output_file = " << output_file; + const std::string path = "c:\\tmp\\"; #else - GTEST_FLAG(output) = "xml:/tmp/"; + const std::string path = "/tmp/"; +#endif + + GTEST_FLAG(output) = "xml:" + path; + const std::string expected_output_file = + path + GetCurrentExecutableName().c_str() + ".xml"; const String& output_file = UnitTestOptions::GetAbsolutePathToOutputFile(); - // TODO(wan@google.com): libtool causes the test binary file to be - // named lt-gtest-options_test. Therefore the output file may be - // named .../lt-gtest-options_test.xml. We should remove this - // hard-coded logic when Chandler Carruth's libtool replacement is - // ready. - EXPECT_TRUE(output_file == "/tmp/gtest-options_test.xml" || - output_file == "/tmp/lt-gtest-options_test.xml" || - output_file == "/tmp/gtest_all_test.xml" || - output_file == "/tmp/lt-gtest_all_test.xml") - << " output_file = " << output_file; + +#if GTEST_OS_WINDOWS + EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); +#else + EXPECT_EQ(expected_output_file, output_file.c_str()); #endif } diff --git a/test/gtest_all_test.cc b/test/gtest_all_test.cc index 955aa62..e1edb08 100644 --- a/test/gtest_all_test.cc +++ b/test/gtest_all_test.cc @@ -45,3 +45,4 @@ #include "test/gtest-typed-test2_test.cc" #include "test/gtest_unittest.cc" #include "test/production.cc" +#include "src/gtest_main.cc" diff --git a/test/gtest_color_test_.cc b/test/gtest_color_test_.cc index 305aeb9..58d377c 100644 --- a/test/gtest_color_test_.cc +++ b/test/gtest_color_test_.cc @@ -37,11 +37,14 @@ #include -namespace testing { -namespace internal { -bool ShouldUseColor(bool stdout_is_tty); -} // namespace internal -} // namespace testing +// Indicates that this translation unit is part of Google Test's +// implementation. It must come before gtest-internal-inl.h is +// included, or there will be a compiler error. This trick is to +// prevent a user from accidentally including gtest-internal-inl.h in +// his code. +#define GTEST_IMPLEMENTATION_ 1 +#include "src/gtest-internal-inl.h" +#undef GTEST_IMPLEMENTATION_ using testing::internal::ShouldUseColor; diff --git a/test/gtest_dll_test_.cc b/test/gtest_dll_test_.cc deleted file mode 100644 index 3bb3c76..0000000 --- a/test/gtest_dll_test_.cc +++ /dev/null @@ -1,509 +0,0 @@ -// Copyright 2009 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Author: vladl@google.com (Vlad Losev) -// -// Tests for Google Test itself. This verifies that Google Test can be -// linked into an executable successfully when built as a shared library (a -// DLL on Windows). The test is not meant to check the success of test -// assertions employed in it. It only checks that constructs in them can be -// successfully linked. -// -// If you add new features to Google Test's documented interface, you need to -// add tests exercising them to this file. -// -// If you start having 'unresolved external symbol' linker errors in this file -// after the changes you have made, you have to modify your source code to -// export the new symbols. - -#include -#include - -#if GTEST_OS_WINDOWS -#include -#endif -#include - -using ::std::vector; -using ::std::tr1::tuple; - - -using ::testing::AddGlobalTestEnvironment; -using ::testing::AssertionFailure; -using ::testing::AssertionResult; -using ::testing::AssertionSuccess; -using ::testing::DoubleLE; -using ::testing::EmptyTestEventListener; -using ::testing::Environment; -using ::testing::ExitedWithCode; -using ::testing::FloatLE; -using ::testing::GTEST_FLAG(also_run_disabled_tests); -using ::testing::GTEST_FLAG(break_on_failure); -using ::testing::GTEST_FLAG(catch_exceptions); -using ::testing::GTEST_FLAG(color); -using ::testing::GTEST_FLAG(filter); -using ::testing::GTEST_FLAG(output); -using ::testing::GTEST_FLAG(print_time); -using ::testing::GTEST_FLAG(random_seed); -using ::testing::GTEST_FLAG(repeat); -using ::testing::GTEST_FLAG(shuffle); -using ::testing::GTEST_FLAG(stack_trace_depth); -using ::testing::GTEST_FLAG(throw_on_failure); -using ::testing::InitGoogleTest; -using ::testing::Message; -using ::testing::Test; -using ::testing::TestCase; -using ::testing::TestEventListener; -using ::testing::TestEventListeners; -using ::testing::TestInfo; -using ::testing::TestPartResult; -using ::testing::TestProperty; -using ::testing::TestResult; -using ::testing::UnitTest; -using ::testing::internal::AlwaysTrue; -using ::testing::internal::AlwaysFalse; - -#if GTEST_HAS_PARAM_TEST -using ::testing::Bool; -using ::testing::Combine; -using ::testing::TestWithParam; -using ::testing::Values; -using ::testing::ValuesIn; -#endif // GTEST_HAS_PARAM_TEST - -#if GTEST_HAS_TYPED_TEST -using ::testing::Types; -#endif // GTEST_HAS_TYPED_TEST - -// Tests linking of TEST constructs. -TEST(TestMacroTest, LinksSuccessfully) { -} - -// Tests linking of TEST_F constructs. -class FixtureTest : public Test { -}; - -TEST_F(FixtureTest, LinksSuccessfully) { -} - -// Tests linking of value parameterized tests. -#if GTEST_HAS_PARAM_TEST -class IntParamTest : public TestWithParam {}; - -TEST_P(IntParamTest, LinksSuccessfully) {} - -const int c_array[] = {1, 2}; -INSTANTIATE_TEST_CASE_P(ValuesInCArrayTest, IntParamTest, ValuesIn(c_array)); - -INSTANTIATE_TEST_CASE_P(ValuesInIteratorPairTest, IntParamTest, - ValuesIn(c_array, c_array + 2)); - -vector stl_vector(c_array, c_array + 2); -INSTANTIATE_TEST_CASE_P(ValuesInStlVectorTest, IntParamTest, - ValuesIn(stl_vector)); - -class BoolParamTest : public TestWithParam {}; - -INSTANTIATE_TEST_CASE_P(BoolTest, BoolParamTest, Bool()); - -INSTANTIATE_TEST_CASE_P(ValuesTest, IntParamTest, Values(1, 2)); - -#if GTEST_HAS_COMBINE -class CombineTest : public TestWithParam > {}; - -INSTANTIATE_TEST_CASE_P(CombineTest, CombineTest, Combine(Values(1), Bool())); -#endif // GTEST_HAS_COMBINE -#endif // GTEST_HAS_PARAM_TEST - -// Tests linking of typed tests. -#if GTEST_HAS_TYPED_TEST -template class TypedTest : public Test {}; - -TYPED_TEST_CASE(TypedTest, Types); - -TYPED_TEST(TypedTest, LinksSuccessfully) {} -#endif // GTEST_HAS_TYPED_TEST - -// Tests linking of type-parameterized tests. -#if GTEST_HAS_TYPED_TEST_P -template class TypeParameterizedTest : public Test {}; - -TYPED_TEST_CASE_P(TypeParameterizedTest); - -TYPED_TEST_P(TypeParameterizedTest, LinksSuccessfully) {} - -REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTest, LinksSuccessfully); - -INSTANTIATE_TYPED_TEST_CASE_P(Char, TypeParameterizedTest, Types); -#endif // GTEST_HAS_TYPED_TEST_P - -// Tests linking of explicit success or failure. -TEST(ExplicitSuccessFailureTest, ExplicitSuccessAndFailure) { - if (AlwaysTrue()) - SUCCEED() << "This is a success statement"; - if (AlwaysFalse()) { - ADD_FAILURE() << "This is a non-fatal failure assertion"; - FAIL() << "This is a fatal failure assertion"; - } -} - -// Tests linking of Boolean assertions. -AssertionResult IsEven(int n) { - if (n % 2 == 0) - return AssertionSuccess() << n << " is even"; - else - return AssertionFailure() << n << " is odd"; -} - -TEST(BooleanAssertionTest, LinksSuccessfully) { - EXPECT_TRUE(true) << "true is true"; - EXPECT_FALSE(false) << "false is not true"; - ASSERT_TRUE(true); - ASSERT_FALSE(false); - EXPECT_TRUE(IsEven(2)); - EXPECT_FALSE(IsEven(3)); -} - -// Tests linking of predicate assertions. -bool IsOdd(int n) { return n % 2 != 0; } - -bool Ge(int val1, int val2) { return val1 >= val2; } - -TEST(PredicateAssertionTest, LinksSuccessfully) { - EXPECT_PRED1(IsOdd, 1); - EXPECT_PRED2(Ge, 2, 1); -} - -AssertionResult AddToFive(const char* val1_expr, - const char* val2_expr, - int val1, - int val2) { - if (val1 + val2 == 5) - return AssertionSuccess(); - - return AssertionFailure() << val1_expr << " and " << val2_expr - << " (" << val1 << " and " << val2 << ") " - << "do not add up to five, as their sum is " - << val1 + val2; -} - -TEST(PredicateFormatterAssertionTest, LinksSuccessfully) { - EXPECT_PRED_FORMAT2(AddToFive, 1 + 2, 2); -} - - -// Tests linking of comparison assertions. -TEST(ComparisonAssertionTest, LinksSuccessfully) { - EXPECT_EQ(1, 1); - EXPECT_NE(1, 2); - EXPECT_LT(1, 2); - EXPECT_LE(1, 1); - EXPECT_GT(2, 1); - EXPECT_GE(2, 1); - - EXPECT_EQ('\n', '\n'); - EXPECT_NE('\n', '\r'); - EXPECT_LT('\n', 'a'); - EXPECT_LE('\n', 'b'); - EXPECT_GT('a', '\t'); - EXPECT_GE('b', '\t'); -} - -TEST(StringComparisonAssertionTest, LinksSuccessfully) { - EXPECT_STREQ("test", "test"); - EXPECT_STRNE("test", "prod"); - - char test_str[5] = "test"; - char prod_str[5] = "prod"; - - EXPECT_STREQ(test_str, test_str); - EXPECT_STRNE(test_str, prod_str); - - EXPECT_STRCASEEQ("test", "TEST"); - EXPECT_STRCASENE("test", "prod"); - - wchar_t test_wstr[5] = L"test"; - wchar_t prod_wstr[5] = L"prod"; - - EXPECT_STREQ(L"test", L"test"); - EXPECT_STRNE(L"test", L"prod"); - - EXPECT_STREQ(test_wstr, test_wstr); - EXPECT_STRNE(test_wstr, prod_wstr); - -#if GTEST_HAS_STD_STRING - EXPECT_EQ("test", ::std::string("test")); - EXPECT_NE("test", ::std::string("prod")); - - EXPECT_EQ(::std::string("test"), "test"); - EXPECT_NE(::std::string("prod"), "test"); - - EXPECT_EQ(test_str, ::std::string("test")); - EXPECT_NE(test_str, ::std::string("prod")); - - EXPECT_EQ(::std::string("test"), test_str); - EXPECT_NE(::std::string("prod"), test_str); - - EXPECT_EQ(::std::string("test"), ::std::string("test")); - EXPECT_NE(::std::string("test"), ::std::string("prod")); -#endif // GTEST_HAS_STD_STRING - -#if GTEST_HAS_STD_WSTRING - EXPECT_EQ(L"test", ::std::wstring(L"test")); - EXPECT_NE(L"test", ::std::wstring(L"prod")); - - EXPECT_EQ(::std::wstring(L"test"), L"test"); - EXPECT_NE(::std::wstring(L"prod"), L"test"); - - EXPECT_EQ(test_wstr, ::std::wstring(L"test")); - EXPECT_NE(test_wstr, ::std::wstring(L"prod")); - - EXPECT_EQ(::std::wstring(L"test"), test_wstr); - EXPECT_NE(::std::wstring(L"prod"), test_wstr); - - EXPECT_EQ(::std::wstring(L"test"), ::std::wstring(L"test")); - EXPECT_NE(::std::wstring(L"test"), ::std::wstring(L"prod")); -#endif // GTEST_HAS_STD_WSTRING -} - -// Tests linking of floating point assertions. -TEST(FloatingPointComparisonAssertionTest, LinksSuccessfully) { - EXPECT_FLOAT_EQ(0.0f, 0.0f); - EXPECT_DOUBLE_EQ(0.0, 0.0); - EXPECT_NEAR(0.0, 0.1, 0.2); - EXPECT_PRED_FORMAT2(::testing::FloatLE, 0.0f, 0.01f); - EXPECT_PRED_FORMAT2(::testing::DoubleLE, 0.0, 0.001); -} - -#if GTEST_OS_WINDOWS -// Tests linking of HRESULT assertions. -TEST(HresultAssertionTest, LinksSuccessfully) { - EXPECT_HRESULT_SUCCEEDED(S_OK); - EXPECT_HRESULT_FAILED(E_FAIL); -} -#endif // GTEST_OS_WINDOWS - -#if GTEST_HAS_EXCEPTIONS -// Tests linking of exception assertions. -TEST(ExceptionAssertionTest, LinksSuccessfully) { - EXPECT_THROW(throw 1, int); - EXPECT_ANY_THROW(throw 1); - EXPECT_NO_THROW(std::vector v); -} -#endif // GTEST_HAS_EXCEPTIONS - -// Tests linking of death test assertions. -TEST(DeathTestAssertionDeathTest, LinksSuccessfully) { - EXPECT_DEATH_IF_SUPPORTED(exit(1), ""); - -#if GTEST_HAS_DEATH_TEST - EXPECT_EXIT(exit(1), ExitedWithCode(1), ""); -#endif // GTEST_HAS_DEATH_TEST -} - -// Tests linking of SCOPED_TRACE. -void Sub() { EXPECT_EQ(1, 1); } - -TEST(ScopedTraceTest, LinksSuccessfully) { - SCOPED_TRACE("X"); - Sub(); -} - -// Tests linking of failure absence assertions. -TEST(NoFailureAssertionTest, LinksSuccessfully) { - EXPECT_NO_FATAL_FAILURE(IsEven(2)); -} - -// Tests linking of HasFatalFailure. -TEST(HasFatalFailureTest, LinksSuccessfully) { - EXPECT_FALSE(HasFatalFailure()); - EXPECT_FALSE(HasNonfatalFailure()); - EXPECT_FALSE(HasFailure()); -} - -// Tests linking of RecordProperty. -TEST(RecordPropertyTest, LinksSuccessfully) { - RecordProperty("DummyPropery", "DummyValue"); -} - -// Tests linking of environments. -class MyEnvironment : public Environment {}; - -Environment* const environment = AddGlobalTestEnvironment(new MyEnvironment); - -// Tests linking of flags. -TEST(FlagTest, LinksSuccessfully) { - Message message; - - message << GTEST_FLAG(filter); - message << GTEST_FLAG(also_run_disabled_tests); - message << GTEST_FLAG(repeat); - message << GTEST_FLAG(shuffle); - message << GTEST_FLAG(random_seed); - message << GTEST_FLAG(color); - message << GTEST_FLAG(print_time); - message << GTEST_FLAG(output); - message << GTEST_FLAG(break_on_failure); - message << GTEST_FLAG(throw_on_failure); - message << GTEST_FLAG(catch_exceptions); - message << GTEST_FLAG(stack_trace_depth); -} - -// Tests linking of failure catching assertions. -void FunctionWithFailure() { FAIL(); } - -TEST(FailureCatchingAssertionTest, LinksCorrectly) { - EXPECT_FATAL_FAILURE(FunctionWithFailure(), ""); - EXPECT_NONFATAL_FAILURE(ADD_FAILURE(), ""); - EXPECT_FATAL_FAILURE_ON_ALL_THREADS(FunctionWithFailure(), ""); - EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(ADD_FAILURE(), ""); -} - -// Tests linking of the reflection API. -TEST(ReflectionApiTest, LinksCorrectly) { - // UnitTest API. - UnitTest* unit_test = UnitTest::GetInstance(); - - unit_test->original_working_dir(); - EXPECT_TRUE(unit_test->current_test_case() != NULL); - EXPECT_TRUE(unit_test->current_test_info() != NULL); - EXPECT_NE(0, unit_test->random_seed()); - EXPECT_GE(unit_test->successful_test_case_count(), 0); - EXPECT_EQ(0, unit_test->failed_test_case_count()); - EXPECT_GE(unit_test->total_test_case_count(), 0); - EXPECT_GT(unit_test->test_case_to_run_count(), 0); - EXPECT_GE(unit_test->successful_test_count(), 0); - EXPECT_EQ(0, unit_test->failed_test_count()); - EXPECT_EQ(0, unit_test->disabled_test_count()); - EXPECT_GT(unit_test->total_test_count(), 0); - EXPECT_GT(unit_test->test_to_run_count(), 0); - EXPECT_GE(unit_test->elapsed_time(), 0); - EXPECT_TRUE(unit_test->Passed()); - EXPECT_FALSE(unit_test->Failed()); - EXPECT_TRUE(unit_test->GetTestCase(0) != NULL); - - // TestCase API. - const TestCase*const test_case = unit_test->current_test_case(); - - EXPECT_STRNE("", test_case->name()); - const char* const test_case_comment = test_case->comment(); - EXPECT_TRUE(test_case->should_run()); - EXPECT_GE(test_case->successful_test_count(), 0); - EXPECT_EQ(0, test_case->failed_test_count()); - EXPECT_EQ(0, test_case->disabled_test_count()); - EXPECT_GT(test_case->test_to_run_count(), 0); - EXPECT_GT(test_case->total_test_count(), 0); - EXPECT_TRUE(test_case->Passed()); - EXPECT_FALSE(test_case->Failed()); - EXPECT_GE(test_case->elapsed_time(), 0); - EXPECT_TRUE(test_case->GetTestInfo(0) != NULL); - - // TestInfo API. - const TestInfo* const test_info = unit_test->current_test_info(); - - EXPECT_STRNE("", test_info->test_case_name()); - EXPECT_STRNE("", test_info->name()); - EXPECT_STREQ(test_case_comment, test_info->test_case_comment()); - const char* const comment = test_info->comment(); - EXPECT_TRUE(comment == NULL || strlen(comment) >= 0); - EXPECT_TRUE(test_info->should_run()); - EXPECT_TRUE(test_info->result() != NULL); - - // TestResult API. - const TestResult* const test_result = test_info->result(); - - SUCCEED() << "This generates a successful test part instance for API testing"; - RecordProperty("Test Name", "Test Value"); - EXPECT_EQ(1, test_result->total_part_count()); - EXPECT_EQ(1, test_result->test_property_count()); - EXPECT_TRUE(test_result->Passed()); - EXPECT_FALSE(test_result->Failed()); - EXPECT_FALSE(test_result->HasFatalFailure()); - EXPECT_FALSE(test_result->HasNonfatalFailure()); - EXPECT_GE(test_result->elapsed_time(), 0); - const TestPartResult& test_part_result = test_result->GetTestPartResult(0); - const TestProperty& test_property = test_result->GetTestProperty(0); - - // TestPartResult API. - EXPECT_EQ(TestPartResult::kSuccess, test_part_result.type()); - EXPECT_STRNE("", test_part_result.file_name()); - EXPECT_GT(test_part_result.line_number(), 0); - EXPECT_STRNE("", test_part_result.summary()); - EXPECT_STRNE("", test_part_result.message()); - EXPECT_TRUE(test_part_result.passed()); - EXPECT_FALSE(test_part_result.failed()); - EXPECT_FALSE(test_part_result.nonfatally_failed()); - EXPECT_FALSE(test_part_result.fatally_failed()); - - // TestProperty API. - EXPECT_STREQ("Test Name", test_property.key()); - EXPECT_STREQ("Test Value", test_property.value()); -} - -// Tests linking of the event listener API. -class MyListener : public TestEventListener { - virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} - virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, - int /*iteration*/) {} - virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} - virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} - virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} - virtual void OnTestStart(const TestInfo& /*test_info*/) {} - virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} - virtual void OnTestEnd(const TestInfo& /*test_info*/) {} - virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} - virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} - virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} - virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, - int /*iteration*/) {} - virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} -}; - -class MyOtherListener : public EmptyTestEventListener {}; - -int main(int argc, char **argv) { - testing::InitGoogleTest(&argc, argv); - - void (*wide_init_google_test)(int*, wchar_t**) = &testing::InitGoogleTest; - - // Ensures the linker doesn't throw away reference to wide InitGoogleTest. - GTEST_CHECK_(wide_init_google_test != NULL); - - TestEventListeners& listeners = UnitTest::GetInstance()->listeners(); - TestEventListener* listener = new MyListener; - - listeners.Append(listener); - listeners.Release(listener); - listeners.Append(new MyOtherListener); - listener = listeners.default_result_printer(); - listener = listeners.default_xml_generator(); - - int ret_val = RUN_ALL_TESTS(); - static_cast(ret_val); - return 0; -} diff --git a/test/gtest_unittest.cc b/test/gtest_unittest.cc index bd10ae0..199b254 100644 --- a/test/gtest_unittest.cc +++ b/test/gtest_unittest.cc @@ -76,13 +76,6 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) { namespace testing { namespace internal { -bool ShouldUseColor(bool stdout_is_tty); -::std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); -bool ParseInt32Flag(const char* str, const char* flag, Int32* value); - -// Used for testing the flag parsing. -extern bool g_help_flag; - // Provides access to otherwise private parts of the TestEventListeners class // that are needed to test it. class TestEventListenersAccessor { -- cgit v1.2.3