diff options
Diffstat (limited to 'gtest/include')
21 files changed, 460 insertions, 1028 deletions
diff --git a/gtest/include/gtest/gtest-death-test.h b/gtest/include/gtest/gtest-death-test.h index 121dc1f..fdb497f 100644 --- a/gtest/include/gtest/gtest-death-test.h +++ b/gtest/include/gtest/gtest-death-test.h @@ -176,7 +176,7 @@ GTEST_DECLARE_string_(death_test_style); // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: // Tests that an exit code describes a normal exit with a given exit code. -class GTEST_API_ ExitedWithCode { +class ExitedWithCode { public: explicit ExitedWithCode(int exit_code); bool operator()(int exit_status) const; @@ -190,7 +190,7 @@ class GTEST_API_ ExitedWithCode { #if !GTEST_OS_WINDOWS // Tests that an exit code describes an exit due to termination by a // given signal. -class GTEST_API_ KilledBySignal { +class KilledBySignal { public: explicit KilledBySignal(int signum); bool operator()(int exit_status) const; diff --git a/gtest/include/gtest/gtest-message.h b/gtest/include/gtest/gtest-message.h index f135b69..6398712 100644 --- a/gtest/include/gtest/gtest-message.h +++ b/gtest/include/gtest/gtest-message.h @@ -46,8 +46,6 @@ #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ -#include <limits> - #include <gtest/internal/gtest-string.h> #include <gtest/internal/gtest-internal.h> @@ -79,7 +77,7 @@ namespace testing { // latter (it causes an access violation if you do). The Message // class hides this difference by treating a NULL char pointer as // "(null)". -class GTEST_API_ Message { +class Message { private: // The type of basic IO manipulators (endl, ends, and flush) for // narrow streams. @@ -91,11 +89,7 @@ class GTEST_API_ Message { // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's // stack frame leading to huge stack frames in some cases; gcc does not reuse // the stack space. - Message() : ss_(new internal::StrStream) { - // By default, we want there to be enough precision when printing - // a double to a Message. - *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2); - } + Message() : ss_(new internal::StrStream) {} // Copy constructor. Message(const Message& msg) : ss_(new internal::StrStream) { // NOLINT diff --git a/gtest/include/gtest/gtest-param-test.h b/gtest/include/gtest/gtest-param-test.h index 8100696..6c8622a 100644 --- a/gtest/include/gtest/gtest-param-test.h +++ b/gtest/include/gtest/gtest-param-test.h @@ -133,12 +133,9 @@ INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); // in the given test case, whether their definitions come before or // AFTER the INSTANTIATE_TEST_CASE_P statement. // -// Please also note that generator expressions (including parameters to the -// generators) are evaluated in InitGoogleTest(), after main() has started. -// This allows the user on one hand, to adjust generator parameters in order -// to dynamically determine a set of tests to run and on the other hand, -// give the user a chance to inspect the generated tests with Google Test -// reflection API before RUN_ALL_TESTS() is executed. +// Please also note that generator expressions are evaluated in +// RUN_ALL_TESTS(), after main() has started. This allows evaluation of +// parameter list based on command line parameters. // // You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc // for more examples. @@ -155,15 +152,12 @@ INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); #include <utility> #endif -// scripts/fuse_gtest.py depends on gtest's own header being #included -// *unconditionally*. Therefore these #includes cannot be moved -// inside #if GTEST_HAS_PARAM_TEST. +#if GTEST_HAS_PARAM_TEST + #include <gtest/internal/gtest-internal.h> #include <gtest/internal/gtest-param-util.h> #include <gtest/internal/gtest-param-util-generated.h> -#if GTEST_HAS_PARAM_TEST - namespace testing { // Functions producing parameter generators. diff --git a/gtest/include/gtest/gtest-param-test.h.pump b/gtest/include/gtest/gtest-param-test.h.pump index a231188..c761f12 100644 --- a/gtest/include/gtest/gtest-param-test.h.pump +++ b/gtest/include/gtest/gtest-param-test.h.pump @@ -52,7 +52,7 @@ $var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. // class. It must be derived from testing::TestWithParam<T>, where T is // the type of your parameter values. TestWithParam<T> is itself derived // from testing::Test. T can be any copyable type. If it's a raw pointer, -// you are responsible for managing the lifespan of the pointed values. +// you are responsible for managing the lifespan of the pointed values. class FooTest : public ::testing::TestWithParam<const char*> { // You can implement all the usual class fixture members here. @@ -60,7 +60,7 @@ class FooTest : public ::testing::TestWithParam<const char*> { // Then, use the TEST_P macro to define as many parameterized tests // for this fixture as you want. The _P suffix is for "parameterized" -// or "pattern", whichever you prefer to think. +// or "pattern", whichever you prefer to think. TEST_P(FooTest, DoesBlah) { // Inside a test, access the test parameter with the GetParam() method @@ -124,7 +124,7 @@ const char* pets[] = {"cat", "dog"}; INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); // The tests from the instantiation above will have these names: -// +// // * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" // * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" // * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" @@ -147,21 +147,17 @@ INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); #endif // 0 -#include <gtest/internal/gtest-port.h> -#if !GTEST_OS_SYMBIAN #include <utility> -#endif -// scripts/fuse_gtest.py depends on gtest's own header being #included -// *unconditionally*. Therefore these #includes cannot be moved -// inside #if GTEST_HAS_PARAM_TEST. +#include <gtest/internal/gtest-port.h> + +#if GTEST_HAS_PARAM_TEST + #include <gtest/internal/gtest-internal.h> #include <gtest/internal/gtest-param-util.h> #include <gtest/internal/gtest-param-util-generated.h> -#if GTEST_HAS_PARAM_TEST - namespace testing { // Functions producing parameter generators. diff --git a/gtest/include/gtest/gtest-spi.h b/gtest/include/gtest/gtest-spi.h index c41da48..2953411 100644 --- a/gtest/include/gtest/gtest-spi.h +++ b/gtest/include/gtest/gtest-spi.h @@ -48,7 +48,7 @@ namespace testing { // generated in the same thread that created this object or it can intercept // all generated failures. The scope of this mock object can be controlled with // the second argument to the two arguments constructor. -class GTEST_API_ ScopedFakeTestPartResultReporter +class ScopedFakeTestPartResultReporter : public TestPartResultReporterInterface { public: // The two possible mocking modes of this object. @@ -93,7 +93,7 @@ namespace internal { // TestPartResultArray contains exactly one failure that has the given // type and contains the given substring. If that's not the case, a // non-fatal failure will be generated. -class GTEST_API_ SingleFailureChecker { +class SingleFailureChecker { public: // The constructor remembers the arguments. SingleFailureChecker(const TestPartResultArray* results, diff --git a/gtest/include/gtest/gtest-test-part.h b/gtest/include/gtest/gtest-test-part.h index f714759..58e7df9 100644 --- a/gtest/include/gtest/gtest-test-part.h +++ b/gtest/include/gtest/gtest-test-part.h @@ -34,7 +34,6 @@ #define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ #include <iosfwd> -#include <vector> #include <gtest/internal/gtest-internal.h> #include <gtest/internal/gtest-string.h> @@ -44,7 +43,7 @@ namespace testing { // assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). // // Don't inherit from TestPartResult as its destructor is not virtual. -class GTEST_API_ TestPartResult { +class TestPartResult { public: // The possible outcomes of a test part (i.e. an assertion or an // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). @@ -57,15 +56,15 @@ class GTEST_API_ TestPartResult { // C'tor. TestPartResult does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestPartResult object. - TestPartResult(Type a_type, - const char* a_file_name, - int a_line_number, - const char* a_message) - : type_(a_type), - file_name_(a_file_name), - line_number_(a_line_number), - summary_(ExtractSummary(a_message)), - message_(a_message) { + TestPartResult(Type type, + const char* file_name, + int line_number, + const char* message) + : type_(type), + file_name_(file_name), + line_number_(line_number), + summary_(ExtractSummary(message)), + message_(message) { } // Gets the outcome of the test part. @@ -118,11 +117,15 @@ std::ostream& operator<<(std::ostream& os, const TestPartResult& result); // An array of TestPartResult objects. // +// We define this class as we cannot use STL containers when compiling +// Google Test with MSVC 7.1 and exceptions disabled. +// // Don't inherit from TestPartResultArray as its destructor is not // virtual. -class GTEST_API_ TestPartResultArray { +class TestPartResultArray { public: - TestPartResultArray() {} + TestPartResultArray(); + ~TestPartResultArray(); // Appends the given TestPartResult to the array. void Append(const TestPartResult& result); @@ -132,9 +135,9 @@ class GTEST_API_ TestPartResultArray { // Returns the number of TestPartResult objects in the array. int size() const; - private: - std::vector<TestPartResult> array_; + // Internally we use a Vector to implement the array. + internal::Vector<TestPartResult>* const array_; GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); }; @@ -155,8 +158,7 @@ namespace internal { // reported, it only delegates the reporting to the former result reporter. // The original result reporter is restored in the destructor. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -class GTEST_API_ HasNewFatalFailureHelper - : public TestPartResultReporterInterface { +class HasNewFatalFailureHelper : public TestPartResultReporterInterface { public: HasNewFatalFailureHelper(); virtual ~HasNewFatalFailureHelper(); diff --git a/gtest/include/gtest/gtest-typed-test.h b/gtest/include/gtest/gtest-typed-test.h index 1ec8eb8..519edfe 100644 --- a/gtest/include/gtest/gtest-typed-test.h +++ b/gtest/include/gtest/gtest-typed-test.h @@ -159,11 +159,8 @@ INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); // given test case. #define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ -// The 'Types' template argument below must have spaces around it -// since some compilers may choke on '>>' when passing a template -// instance (e.g. Types<int>) #define TYPED_TEST_CASE(CaseName, Types) \ - typedef ::testing::internal::TypeList< Types >::type \ + typedef ::testing::internal::TypeList<Types>::type \ GTEST_TYPE_PARAMS_(CaseName) #define TYPED_TEST(CaseName, TestName) \ @@ -244,14 +241,11 @@ INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\ __FILE__, __LINE__, #__VA_ARGS__) -// The 'Types' template argument below must have spaces around it -// since some compilers may choke on '>>' when passing a template -// instance (e.g. Types<int>) #define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ bool gtest_##Prefix##_##CaseName = \ ::testing::internal::TypeParameterizedTestCase<CaseName, \ GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \ - ::testing::internal::TypeList< Types >::type>::Register(\ + ::testing::internal::TypeList<Types>::type>::Register(\ #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) #endif // GTEST_HAS_TYPED_TEST_P diff --git a/gtest/include/gtest/gtest.h b/gtest/include/gtest/gtest.h index 921fad1..9be15fb 100644 --- a/gtest/include/gtest/gtest.h +++ b/gtest/include/gtest/gtest.h @@ -52,8 +52,6 @@ #define GTEST_INCLUDE_GTEST_GTEST_H_ #include <limits> -#include <vector> - #include <gtest/internal/gtest-internal.h> #include <gtest/internal/gtest-string.h> #include <gtest/gtest-death-test.h> @@ -64,19 +62,24 @@ #include <gtest/gtest-typed-test.h> // Depending on the platform, different string classes are available. -// On Linux, in addition to ::std::string, Google also makes use of -// class ::string, which has the same interface as ::std::string, but -// has a different implementation. -// -// The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that -// ::string is available AND is a distinct type to ::std::string, or -// define it to 0 to indicate otherwise. +// On Windows, ::std::string compiles only when exceptions are +// enabled. On Linux, in addition to ::std::string, Google also makes +// use of class ::string, which has the same interface as +// ::std::string, but has a different implementation. +// +// The user can tell us whether ::std::string is available in his +// environment by defining the macro GTEST_HAS_STD_STRING to either 1 +// or 0 on the compiler command line. He can also define +// GTEST_HAS_GLOBAL_STRING to 1 to indicate that ::string is available +// AND is a distinct type to ::std::string, or define it to 0 to +// indicate otherwise. // // If the user's ::std::string and ::string are the same class due to -// aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0. +// aliasing, he should define GTEST_HAS_STD_STRING to 1 and +// GTEST_HAS_GLOBAL_STRING to 0. // -// If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined -// heuristically. +// If the user doesn't define GTEST_HAS_STD_STRING and/or +// GTEST_HAS_GLOBAL_STRING, they are defined heuristically. namespace testing { @@ -174,146 +177,64 @@ String StreamableToString(const T& streamable) { // A class for indicating whether an assertion was successful. When // the assertion wasn't successful, the AssertionResult object -// remembers a non-empty message that describes how it failed. -// -// To create an instance of this class, use one of the factory functions -// (AssertionSuccess() and AssertionFailure()). -// -// This class is useful for two purposes: -// 1. Defining predicate functions to be used with Boolean test assertions -// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts -// 2. Defining predicate-format functions to be -// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). -// -// For example, if you define IsEven predicate: -// -// testing::AssertionResult IsEven(int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess(); -// else -// return testing::AssertionFailure() << n << " is odd"; -// } -// -// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) -// will print the message +// remembers a non-empty message that described how it failed. // -// Value of: IsEven(Fib(5)) -// Actual: false (5 is odd) -// Expected: true +// This class is useful for defining predicate-format functions to be +// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). // -// instead of a more opaque -// -// Value of: IsEven(Fib(5)) -// Actual: false -// Expected: true -// -// in case IsEven is a simple Boolean predicate. -// -// If you expect your predicate to be reused and want to support informative -// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up -// about half as often as positive ones in our tests), supply messages for -// both success and failure cases: -// -// testing::AssertionResult IsEven(int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess() << n << " is even"; -// else -// return testing::AssertionFailure() << n << " is odd"; -// } -// -// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print -// -// Value of: IsEven(Fib(6)) -// Actual: true (8 is even) -// Expected: false -// -// NB: Predicates that support negative Boolean assertions have reduced -// performance in positive ones so be careful not to use them in tests -// that have lots (tens of thousands) of positive Boolean assertions. +// The constructor of AssertionResult is private. To create an +// instance of this class, use one of the factory functions +// (AssertionSuccess() and AssertionFailure()). // -// To use this class with EXPECT_PRED_FORMAT assertions such as: +// For example, in order to be able to write: // // // Verifies that Foo() returns an even number. // EXPECT_PRED_FORMAT1(IsEven, Foo()); // -// you need to define: +// you just need to define: // // testing::AssertionResult IsEven(const char* expr, int n) { -// if ((n % 2) == 0) -// return testing::AssertionSuccess(); -// else -// return testing::AssertionFailure() -// << "Expected: " << expr << " is even\n Actual: it's " << n; +// if ((n % 2) == 0) return testing::AssertionSuccess(); +// +// Message msg; +// msg << "Expected: " << expr << " is even\n" +// << " Actual: it's " << n; +// return testing::AssertionFailure(msg); // } // // If Foo() returns 5, you will see the following message: // // Expected: Foo() is even // Actual: it's 5 -// -class GTEST_API_ AssertionResult { +class AssertionResult { public: - // Copy constructor. - // Used in EXPECT_TRUE/FALSE(assertion_result). - AssertionResult(const AssertionResult& other); - // Used in the EXPECT_TRUE/FALSE(bool_expression). - explicit AssertionResult(bool success) : success_(success) {} + // Declares factory functions for making successful and failed + // assertion results as friends. + friend AssertionResult AssertionSuccess(); + friend AssertionResult AssertionFailure(const Message&); // Returns true iff the assertion succeeded. - operator bool() const { return success_; } // NOLINT - - // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. - AssertionResult operator!() const; - - // Returns the text streamed into this AssertionResult. Test assertions - // use it when they fail (i.e., the predicate's outcome doesn't match the - // assertion's expectation). When nothing has been streamed into the - // object, returns an empty string. - const char* message() const { - return message_.get() != NULL && message_->c_str() != NULL ? - message_->c_str() : ""; - } - // TODO(vladl@google.com): Remove this after making sure no clients use it. - // Deprecated; please use message() instead. - const char* failure_message() const { return message(); } + operator bool() const { return failure_message_.c_str() == NULL; } // NOLINT - // Streams a custom failure message into this object. - template <typename T> AssertionResult& operator<<(const T& value); + // Returns the assertion's failure message. + const char* failure_message() const { return failure_message_.c_str(); } private: - // No implementation - we want AssertionResult to be - // copy-constructible but not assignable. - void operator=(const AssertionResult& other); - - // Stores result of the assertion predicate. - bool success_; - // Stores the message describing the condition in case the expectation - // construct is not satisfied with the predicate's outcome. - // Referenced via a pointer to avoid taking too much stack frame space - // with test assertions. - internal::scoped_ptr<internal::String> message_; -}; // class AssertionResult - -// Streams a custom failure message into this object. -template <typename T> -AssertionResult& AssertionResult::operator<<(const T& value) { - Message msg; - if (message_.get() != NULL) - msg << *message_; - msg << value; - message_.reset(new internal::String(msg.GetString())); - return *this; -} + // The default constructor. It is used when the assertion succeeded. + AssertionResult() {} -// Makes a successful assertion result. -GTEST_API_ AssertionResult AssertionSuccess(); + // The constructor used when the assertion failed. + explicit AssertionResult(const internal::String& failure_message); + + // Stores the assertion's failure message. + internal::String failure_message_; +}; -// Makes a failed assertion result. -GTEST_API_ AssertionResult AssertionFailure(); +// Makes a successful assertion result. +AssertionResult AssertionSuccess(); // Makes a failed assertion result with the given failure message. -// Deprecated; use AssertionFailure() << msg. -GTEST_API_ AssertionResult AssertionFailure(const Message& msg); +AssertionResult AssertionFailure(const Message& msg); // The abstract class that all tests inherit from. // @@ -338,7 +259,7 @@ GTEST_API_ AssertionResult AssertionFailure(const Message& msg); // TEST_F(FooTest, Baz) { ... } // // Test is not copyable. -class GTEST_API_ Test { +class Test { public: friend class internal::TestInfoImpl; @@ -454,8 +375,8 @@ class TestProperty { // C'tor. TestProperty does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestProperty object. - TestProperty(const char* a_key, const char* a_value) : - key_(a_key), value_(a_value) { + TestProperty(const char* key, const char* value) : + key_(key), value_(value) { } // Gets the user supplied key. @@ -486,7 +407,7 @@ class TestProperty { // the Test. // // TestResult is not copyable. -class GTEST_API_ TestResult { +class TestResult { public: // Creates an empty TestResult. TestResult(); @@ -537,13 +458,13 @@ class GTEST_API_ TestResult { friend class internal::WindowsDeathTest; // Gets the vector of TestPartResults. - const std::vector<TestPartResult>& test_part_results() const { - return test_part_results_; + const internal::Vector<TestPartResult>& test_part_results() const { + return *test_part_results_; } // Gets the vector of TestProperties. - const std::vector<TestProperty>& test_properties() const { - return test_properties_; + const internal::Vector<TestProperty>& test_properties() const { + return *test_properties_; } // Sets the elapsed time. @@ -581,9 +502,9 @@ class GTEST_API_ TestResult { internal::Mutex test_properites_mutex_; // The vector of TestPartResults - std::vector<TestPartResult> test_part_results_; + internal::scoped_ptr<internal::Vector<TestPartResult> > test_part_results_; // The vector of TestProperties - std::vector<TestProperty> test_properties_; + internal::scoped_ptr<internal::Vector<TestProperty> > test_properties_; // Running count of death tests. int death_test_count_; // The elapsed time, in milliseconds. @@ -604,7 +525,7 @@ class GTEST_API_ TestResult { // The constructor of TestInfo registers itself with the UnitTest // singleton such that the RUN_ALL_TESTS() macro knows which tests to // run. -class GTEST_API_ TestInfo { +class TestInfo { public: // Destructs a TestInfo object. This function is not virtual, so // don't inherit from TestInfo. @@ -686,7 +607,7 @@ class GTEST_API_ TestInfo { // A test case, which consists of a vector of TestInfos. // // TestCase is not copyable. -class GTEST_API_ TestCase { +class TestCase { public: // Creates a TestCase with the given name. // @@ -747,11 +668,11 @@ class GTEST_API_ TestCase { friend class internal::UnitTestImpl; // Gets the (mutable) vector of TestInfos in this TestCase. - std::vector<TestInfo*>& test_info_list() { return test_info_list_; } + internal::Vector<TestInfo*>& test_info_list() { return *test_info_list_; } // Gets the (immutable) vector of TestInfos in this TestCase. - const std::vector<TestInfo*>& test_info_list() const { - return test_info_list_; + const internal::Vector<TestInfo *> & test_info_list() const { + return *test_info_list_; } // Returns the i-th test among all the tests. i can range from 0 to @@ -800,11 +721,11 @@ class GTEST_API_ TestCase { internal::String comment_; // The vector of TestInfos in their original order. It owns the // elements in the vector. - std::vector<TestInfo*> test_info_list_; + const internal::scoped_ptr<internal::Vector<TestInfo*> > test_info_list_; // Provides a level of indirection for the test list to allow easy // shuffling and restoring the test order. The i-th element in this // vector is the index of the i-th test in the shuffled test list. - std::vector<int> test_indices_; + const internal::scoped_ptr<internal::Vector<int> > test_indices_; // Pointer to the function that sets up the test case. Test::SetUpTestCaseFunc set_up_tc_; // Pointer to the function that tears down the test case. @@ -924,7 +845,7 @@ class EmptyTestEventListener : public TestEventListener { }; // TestEventListeners lets users add listeners to track events in Google Test. -class GTEST_API_ TestEventListeners { +class TestEventListeners { public: TestEventListeners(); ~TestEventListeners(); @@ -1011,7 +932,7 @@ class GTEST_API_ TestEventListeners { // // This class is thread-safe as long as the methods are called // according to their specification. -class GTEST_API_ UnitTest { +class UnitTest { public: // Gets the singleton UnitTest object. The first time this method // is called, a UnitTest object is constructed and returned. @@ -1198,34 +1119,36 @@ inline Environment* AddGlobalTestEnvironment(Environment* env) { // updated. // // Calling the function for the second time has no user-visible effect. -GTEST_API_ void InitGoogleTest(int* argc, char** argv); +void InitGoogleTest(int* argc, char** argv); // This overloaded version can be used in Windows programs compiled in // UNICODE mode. -GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); +void InitGoogleTest(int* argc, wchar_t** argv); namespace internal { // These overloaded versions handle ::std::string and ::std::wstring. -GTEST_API_ inline String FormatForFailureMessage(const ::std::string& str) { +#if GTEST_HAS_STD_STRING +inline String FormatForFailureMessage(const ::std::string& str) { return (Message() << '"' << str << '"').GetString(); } +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_STD_WSTRING -GTEST_API_ inline String FormatForFailureMessage(const ::std::wstring& wstr) { +inline String FormatForFailureMessage(const ::std::wstring& wstr) { return (Message() << "L\"" << wstr << '"').GetString(); } #endif // GTEST_HAS_STD_WSTRING // These overloaded versions handle ::string and ::wstring. #if GTEST_HAS_GLOBAL_STRING -GTEST_API_ inline String FormatForFailureMessage(const ::string& str) { +inline String FormatForFailureMessage(const ::string& str) { return (Message() << '"' << str << '"').GetString(); } #endif // GTEST_HAS_GLOBAL_STRING #if GTEST_HAS_GLOBAL_WSTRING -GTEST_API_ inline String FormatForFailureMessage(const ::wstring& wstr) { +inline String FormatForFailureMessage(const ::wstring& wstr) { return (Message() << "L\"" << wstr << '"').GetString(); } #endif // GTEST_HAS_GLOBAL_WSTRING @@ -1278,10 +1201,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. -GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression, - const char* actual_expression, - BiggestInt expected, - BiggestInt actual); +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,72 +1293,72 @@ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ return AssertionFailure(msg);\ }\ }\ -GTEST_API_ AssertionResult CmpHelper##op_name(\ - const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) +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_ // The helper function for {ASSERT|EXPECT}_STREQ. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, - const char* actual_expression, - const char* expected, - const char* actual); +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); // The helper function for {ASSERT|EXPECT}_STRCASEEQ. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, - const char* actual_expression, - const char* expected, - const char* actual); +AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); // The helper function for {ASSERT|EXPECT}_STRNE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); // The helper function for {ASSERT|EXPECT}_STRCASENE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, - const char* s2_expression, - const char* s1, - const char* s2); +AssertionResult CmpHelperSTRCASENE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); // Helper function for *_STREQ on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, - const char* actual_expression, - const wchar_t* expected, - const wchar_t* actual); +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const wchar_t* expected, + const wchar_t* actual); // Helper function for *_STRNE on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, - const char* s2_expression, - const wchar_t* s1, - const wchar_t* s2); +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const wchar_t* s1, + const wchar_t* s2); } // namespace internal @@ -1447,30 +1370,32 @@ GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, // // The {needle,haystack}_expr arguments are the stringified // expressions that generated the two real arguments. -GTEST_API_ AssertionResult IsSubstring( +AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); -GTEST_API_ AssertionResult IsSubstring( +AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); -GTEST_API_ AssertionResult IsNotSubstring( +AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); -GTEST_API_ AssertionResult IsNotSubstring( +AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); -GTEST_API_ AssertionResult IsSubstring( +#if GTEST_HAS_STD_STRING +AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); -GTEST_API_ AssertionResult IsNotSubstring( +AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_STD_WSTRING -GTEST_API_ AssertionResult IsSubstring( +AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); -GTEST_API_ AssertionResult IsNotSubstring( +AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); #endif // GTEST_HAS_STD_WSTRING @@ -1513,16 +1438,16 @@ AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression, // Helper function for implementing ASSERT_NEAR. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. -GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, - const char* expr2, - const char* abs_error_expr, - double val1, - double val2, - double abs_error); +AssertionResult DoubleNearPredFormat(const char* expr1, + const char* expr2, + const char* abs_error_expr, + double val1, + double val2, + double abs_error); // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // A class that enables one to stream messages to assertion macros -class GTEST_API_ AssertHelper { +class AssertHelper { public: // Constructor. AssertHelper(TestPartResult::Type type, @@ -1651,22 +1576,10 @@ const T* TestWithParam<T>::parameter_ = NULL; #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") // Generates a fatal failure with a generic message. -#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") - -// Define this macro to 1 to omit the definition of FAIL(), which is a -// generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_FAIL -#define FAIL() GTEST_FAIL() -#endif +#define FAIL() GTEST_FATAL_FAILURE_("Failed") // Generates a success with a generic message. -#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") - -// Define this macro to 1 to omit the definition of SUCCEED(), which -// is a generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_SUCCEED -#define SUCCEED() GTEST_SUCCEED() -#endif +#define SUCCEED() GTEST_SUCCESS_("Succeeded") // Macros for testing exceptions. // @@ -1690,9 +1603,7 @@ const T* TestWithParam<T>::parameter_ = NULL; #define ASSERT_ANY_THROW(statement) \ GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) -// Boolean assertions. Condition can be either a Boolean expression or an -// AssertionResult. For more information on how to use AssertionResult with -// these macros see comments on that class. +// Boolean assertions. #define EXPECT_TRUE(condition) \ GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ GTEST_NONFATAL_FAILURE_) @@ -1865,10 +1776,10 @@ const T* TestWithParam<T>::parameter_ = NULL; // Asserts that val1 is less than, or almost equal to, val2. Fails // otherwise. In particular, it fails if either val1 or val2 is NaN. -GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, - float val1, float val2); -GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, - double val1, double val2); +AssertionResult FloatLE(const char* expr1, const char* expr2, + float val1, float val2); +AssertionResult DoubleLE(const char* expr1, const char* expr2, + double val1, double val2); #if GTEST_OS_WINDOWS @@ -1998,15 +1909,10 @@ bool StaticAssertTypeEq() { // code. GetTestTypeId() is guaranteed to always return the same // value, as it always calls GetTypeId<>() from the Google Test // framework. -#define GTEST_TEST(test_case_name, test_name)\ +#define TEST(test_case_name, test_name)\ GTEST_TEST_(test_case_name, test_name, \ ::testing::Test, ::testing::internal::GetTestTypeId()) -// Define this macro to 1 to omit the definition of TEST(), which -// is a generic name and clashes with some other libraries. -#if !GTEST_DONT_DEFINE_TEST -#define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) -#endif // Defines a test that uses a test fixture. // diff --git a/gtest/include/gtest/internal/gtest-death-test-internal.h b/gtest/include/gtest/internal/gtest-death-test-internal.h index e433084..5aba1a0 100644 --- a/gtest/include/gtest/internal/gtest-death-test-internal.h +++ b/gtest/include/gtest/internal/gtest-death-test-internal.h @@ -64,7 +64,7 @@ const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; // by wait(2) // exit code: The integer code passed to exit(3), _exit(2), or // returned from main() -class GTEST_API_ DeathTest { +class DeathTest { public: // Create returns false if there was an error determining the // appropriate action to take for the current death test; for example, @@ -147,7 +147,7 @@ class DefaultDeathTestFactory : public DeathTestFactory { // Returns true if exit_status describes a process that was terminated // by a signal, or exited normally with a nonzero exit code. -GTEST_API_ bool ExitedUnsuccessfully(int exit_status); +bool ExitedUnsuccessfully(int exit_status); // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*, // ASSERT_EXIT*, and EXPECT_EXIT*. @@ -189,12 +189,11 @@ GTEST_API_ bool ExitedUnsuccessfully(int exit_status); // RUN_ALL_TESTS was called. class InternalRunDeathTestFlag { public: - InternalRunDeathTestFlag(const String& a_file, - int a_line, - int an_index, - int a_write_fd) - : file_(a_file), line_(a_line), index_(an_index), - write_fd_(a_write_fd) {} + InternalRunDeathTestFlag(const String& file, + int line, + int index, + int write_fd) + : file_(file), line_(line), index_(index), write_fd_(write_fd) {} ~InternalRunDeathTestFlag() { if (write_fd_ >= 0) diff --git a/gtest/include/gtest/internal/gtest-filepath.h b/gtest/include/gtest/internal/gtest-filepath.h index 4b76d79..1b2f586 100644 --- a/gtest/include/gtest/internal/gtest-filepath.h +++ b/gtest/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 GTEST_API_ FilePath { +class FilePath { public: FilePath() : pathname_("") { } FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } @@ -189,18 +189,9 @@ class GTEST_API_ FilePath { // particular, RemoveTrailingPathSeparator() only removes one separator, and // it is called in CreateDirectoriesRecursively() assuming that it will change // a pathname from directory syntax (trailing separator) to filename syntax. - // - // On Windows this method also replaces the alternate path separator '/' with - // the primary path separator '\\', so that for example "bar\\/\\foo" becomes - // "bar\\foo". void Normalize(); - // Returns a pointer to the last occurence of a valid path separator in - // the FilePath. On Windows, for example, both '/' and '\' are valid path - // separators. Returns NULL if no path separator was found. - const char* FindLastPathSeparator() const; - String pathname_; }; // class FilePath diff --git a/gtest/include/gtest/internal/gtest-internal.h b/gtest/include/gtest/internal/gtest-internal.h index 31a66e9..7033b0c 100644 --- a/gtest/include/gtest/internal/gtest-internal.h +++ b/gtest/include/gtest/internal/gtest-internal.h @@ -114,13 +114,14 @@ struct TraceInfo; // Information about a trace point. class ScopedTrace; // Implements scoped trace. class TestInfoImpl; // Opaque implementation of TestInfo class UnitTestImpl; // Opaque implementation of UnitTest +template <typename E> class Vector; // A generic vector. // How many times InitGoogleTest() has been called. extern int g_init_gtest_count; // The text used in failure messages to indicate the start of the // stack trace. -GTEST_API_ extern const char kStackTraceMarker[]; +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 @@ -147,21 +148,24 @@ char (&IsNullLiteralHelper(...))[2]; // NOLINT // A compile-time bool constant that is true if and only if x is a // null pointer literal (i.e. NULL or any 0-valued compile-time // integral constant). -#ifdef GTEST_ELLIPSIS_NEEDS_POD_ -// We lose support for NULL detection where the compiler doesn't like -// passing non-POD classes through ellipsis (...). +#ifdef GTEST_ELLIPSIS_NEEDS_COPY_ +// Passing non-POD classes through ellipsis (...) crashes the ARM +// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to +// instantiate a copy constructor for objects passed through ellipsis +// (...), failing for uncopyable objects. Hence we define this to +// false (and lose support for NULL detection). #define GTEST_IS_NULL_LITERAL_(x) false #else #define GTEST_IS_NULL_LITERAL_(x) \ (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) -#endif // GTEST_ELLIPSIS_NEEDS_POD_ +#endif // GTEST_ELLIPSIS_NEEDS_COPY_ // Appends the user-supplied message to the Google-Test-generated message. -GTEST_API_ String AppendUserMessage(const String& gtest_msg, - const Message& user_msg); +String AppendUserMessage(const String& gtest_msg, + const Message& user_msg); // A helper class for creating scoped traces in user programs. -class GTEST_API_ ScopedTrace { +class ScopedTrace { public: // The c'tor pushes the given source file location and message onto // a trace stack maintained by Google Test. @@ -240,8 +244,8 @@ inline String FormatForFailureMessage(T* pointer) { #endif // GTEST_NEEDS_IS_POINTER_ // These overloaded versions handle narrow and wide characters. -GTEST_API_ String FormatForFailureMessage(char ch); -GTEST_API_ String FormatForFailureMessage(wchar_t wchar); +String FormatForFailureMessage(char ch); +String FormatForFailureMessage(wchar_t wchar); // When this operand is a const char* or char*, and the other operand // is a ::std::string or ::string, we print this operand as a C string @@ -258,7 +262,9 @@ inline String FormatForComparisonFailureMessage(\ return operand1_printer(str);\ } +#if GTEST_HAS_STD_STRING GTEST_FORMAT_IMPL_(::std::string, String::ShowCStringQuoted) +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_STD_WSTRING GTEST_FORMAT_IMPL_(::std::wstring, String::ShowWideCStringQuoted) #endif // GTEST_HAS_STD_WSTRING @@ -287,18 +293,12 @@ GTEST_FORMAT_IMPL_(::wstring, String::ShowWideCStringQuoted) // The ignoring_case parameter is true iff the assertion is a // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will // be inserted into the message. -GTEST_API_ AssertionResult EqFailure(const char* expected_expression, - const char* actual_expression, - const String& expected_value, - const String& actual_value, - bool ignoring_case); - -// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. -GTEST_API_ String GetBoolAssertionFailureMessage( - const AssertionResult& assertion_result, - const char* expression_text, - const char* actual_predicate_value, - const char* expected_predicate_value); +AssertionResult EqFailure(const char* expected_expression, + const char* actual_expression, + const String& expected_value, + const String& actual_value, + bool ignoring_case); + // This template class represents an IEEE floating-point number // (either single-precision or double-precision, depending on the @@ -518,7 +518,7 @@ TypeId GetTypeId() { // ::testing::Test, as the latter may give the wrong result due to a // suspected linker bug when compiling Google Test as a Mac OS X // framework. -GTEST_API_ TypeId GetTestTypeId(); +TypeId GetTestTypeId(); // Defines the abstract factory interface that creates instances // of a Test object. @@ -551,10 +551,8 @@ class TestFactoryImpl : public TestFactoryBase { // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} // We pass a long instead of HRESULT to avoid causing an // include dependency for the HRESULT type. -GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, - long hr); // NOLINT -GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, - long hr); // NOLINT +AssertionResult IsHRESULTSuccess(const char* expr, long hr); // NOLINT +AssertionResult IsHRESULTFailure(const char* expr, long hr); // NOLINT #endif // GTEST_OS_WINDOWS @@ -593,7 +591,7 @@ typedef void (*TearDownTestCaseFunc)(); // factory: pointer to the factory that creates a test object. // The newly created TestInfo instance will assume // ownership of the factory object. -GTEST_API_ TestInfo* MakeAndRegisterTestInfo( +TestInfo* MakeAndRegisterTestInfo( const char* test_case_name, const char* name, const char* test_case_comment, const char* comment, TypeId fixture_class_id, @@ -601,15 +599,10 @@ GTEST_API_ TestInfo* MakeAndRegisterTestInfo( TearDownTestCaseFunc tear_down_tc, TestFactoryBase* factory); -// If *pstr starts with the given prefix, modifies *pstr to be right -// past the prefix and returns true; otherwise leaves *pstr unchanged -// and returns false. None of pstr, *pstr, and prefix can be NULL. -bool SkipPrefix(const char* prefix, const char** pstr); - #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P // State of the definition of a type-parameterized test case. -class GTEST_API_ TypedTestCasePState { +class TypedTestCasePState { public: TypedTestCasePState() : registered_(false) {} @@ -750,14 +743,13 @@ class TypeParameterizedTestCase<Fixture, Templates0, Types> { // 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. -GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test, - int skip_count); +String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test, int skip_count); // Helpers for suppressing warnings on unreachable code or constant // condition. // Always returns true. -GTEST_API_ bool AlwaysTrue(); +bool AlwaysTrue(); // Always returns false. inline bool AlwaysFalse() { return !AlwaysTrue(); } @@ -767,7 +759,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 GTEST_API_ Random { +class Random { public: static const UInt32 kMaxRange = 1u << 31; @@ -866,17 +858,12 @@ class GTEST_API_ Random { fail(gtest_msg) -// Implements Boolean test assertions such as EXPECT_TRUE. expression can be -// either a boolean expression or an AssertionResult. text is a textual -// represenation of expression as it was passed into the EXPECT_TRUE. -#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ +#define GTEST_TEST_BOOLEAN_(boolexpr, booltext, actual, expected, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const ::testing::AssertionResult gtest_ar_ = \ - ::testing::AssertionResult(expression)) \ + if (::testing::internal::IsTrue(boolexpr)) \ ; \ else \ - fail(::testing::internal::GetBoolAssertionFailureMessage(\ - gtest_ar_, text, #actual, #expected).c_str()) + fail("Value of: " booltext "\n Actual: " #actual "\nExpected: " #expected) #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ diff --git a/gtest/include/gtest/internal/gtest-linked_ptr.h b/gtest/include/gtest/internal/gtest-linked_ptr.h index 540ef4c..f98af0b 100644 --- a/gtest/include/gtest/internal/gtest-linked_ptr.h +++ b/gtest/include/gtest/internal/gtest-linked_ptr.h @@ -77,7 +77,7 @@ namespace testing { namespace internal { // Protects copying of all linked_ptr objects. -GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex); +extern Mutex g_linked_ptr_mutex; // This is used internally by all instances of linked_ptr<>. It needs to be // a non-template class because different types of linked_ptr<> can refer to diff --git a/gtest/include/gtest/internal/gtest-param-util-generated.h b/gtest/include/gtest/internal/gtest-param-util-generated.h index ab4ab56..1358c32 100644 --- a/gtest/include/gtest/internal/gtest-param-util-generated.h +++ b/gtest/include/gtest/internal/gtest-param-util-generated.h @@ -44,30 +44,13 @@ #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ -// scripts/fuse_gtest.py depends on gtest's own header being #included -// *unconditionally*. Therefore these #includes cannot be moved -// inside #if GTEST_HAS_PARAM_TEST. -#include <gtest/internal/gtest-param-util.h> #include <gtest/internal/gtest-port.h> #if GTEST_HAS_PARAM_TEST -namespace testing { - -// Forward declarations of ValuesIn(), which is implemented in -// include/gtest/gtest-param-test.h. -template <typename ForwardIterator> -internal::ParamGenerator< - typename ::std::iterator_traits<ForwardIterator>::value_type> ValuesIn( - ForwardIterator begin, ForwardIterator end); - -template <typename T, size_t N> -internal::ParamGenerator<T> ValuesIn(const T (&array)[N]); - -template <class Container> -internal::ParamGenerator<typename Container::value_type> ValuesIn( - const Container& container); +#include <gtest/internal/gtest-param-util.h> +namespace testing { namespace internal { // Used in the Values() function to provide polymorphic capabilities. diff --git a/gtest/include/gtest/internal/gtest-param-util-generated.h.pump b/gtest/include/gtest/internal/gtest-param-util-generated.h.pump index baedfbc..2da2872 100644 --- a/gtest/include/gtest/internal/gtest-param-util-generated.h.pump +++ b/gtest/include/gtest/internal/gtest-param-util-generated.h.pump @@ -45,30 +45,13 @@ $var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ -// scripts/fuse_gtest.py depends on gtest's own header being #included -// *unconditionally*. Therefore these #includes cannot be moved -// inside #if GTEST_HAS_PARAM_TEST. -#include <gtest/internal/gtest-param-util.h> #include <gtest/internal/gtest-port.h> #if GTEST_HAS_PARAM_TEST -namespace testing { - -// Forward declarations of ValuesIn(), which is implemented in -// include/gtest/gtest-param-test.h. -template <typename ForwardIterator> -internal::ParamGenerator< - typename ::std::iterator_traits<ForwardIterator>::value_type> ValuesIn( - ForwardIterator begin, ForwardIterator end); - -template <typename T, size_t N> -internal::ParamGenerator<T> ValuesIn(const T (&array)[N]); - -template <class Container> -internal::ParamGenerator<typename Container::value_type> ValuesIn( - const Container& container); +#include <gtest/internal/gtest-param-util.h> +namespace testing { namespace internal { // Used in the Values() function to provide polymorphic capabilities. diff --git a/gtest/include/gtest/internal/gtest-param-util.h b/gtest/include/gtest/internal/gtest-param-util.h index 0cbb58c..dcc5494 100644 --- a/gtest/include/gtest/internal/gtest-param-util.h +++ b/gtest/include/gtest/internal/gtest-param-util.h @@ -38,15 +38,17 @@ #include <utility> #include <vector> -// scripts/fuse_gtest.py depends on gtest's own header being #included -// *unconditionally*. Therefore these #includes cannot be moved -// inside #if GTEST_HAS_PARAM_TEST. -#include <gtest/internal/gtest-internal.h> -#include <gtest/internal/gtest-linked_ptr.h> #include <gtest/internal/gtest-port.h> #if GTEST_HAS_PARAM_TEST +#if GTEST_HAS_RTTI +#include <typeinfo> +#endif // GTEST_HAS_RTTI + +#include <gtest/internal/gtest-linked_ptr.h> +#include <gtest/internal/gtest-internal.h> + namespace testing { namespace internal { @@ -56,8 +58,26 @@ namespace internal { // fixture class for the same test case. This may happen when // TEST_P macro is used to define two tests with the same name // but in different namespaces. -GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, - const char* file, int line); +void ReportInvalidTestCaseType(const char* test_case_name, + const char* file, int line); + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Downcasts the pointer of type Base to Derived. +// Derived must be a subclass of Base. The parameter MUST +// point to a class of type Derived, not any subclass of it. +// When RTTI is available, the function performs a runtime +// check to enforce this. +template <class Derived, class Base> +Derived* CheckedDowncastToActualType(Base* base) { +#if GTEST_HAS_RTTI + GTEST_CHECK_(typeid(*base) == typeid(Derived)); + Derived* derived = dynamic_cast<Derived*>(base); // NOLINT +#else + Derived* derived = static_cast<Derived*>(base); // Poor man's downcast. +#endif // GTEST_HAS_RTTI + return derived; +} template <typename> class ParamGeneratorInterface; template <typename> class ParamGenerator; @@ -149,7 +169,7 @@ class ParamGeneratorInterface { virtual ParamIteratorInterface<T>* End() const = 0; }; -// Wraps ParamGeneratorInterface<T> and provides general generator syntax +// Wraps ParamGeneratorInetrface<T> and provides general generator syntax // compatible with the STL Container concept. // This class implements copy initialization semantics and the contained // ParamGeneratorInterface<T> instance is shared among all copies @@ -225,8 +245,7 @@ class RangeGenerator : public ParamGeneratorInterface<T> { private: Iterator(const Iterator& other) - : ParamIteratorInterface<T>(), - base_(other.base_), value_(other.value_), index_(other.index_), + : base_(other.base_), value_(other.value_), index_(other.index_), step_(other.step_) {} // No implementation - assignment is unsupported. @@ -523,12 +542,12 @@ class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { // LocalTestInfo structure keeps information about a single test registered // with TEST_P macro. struct TestInfo { - TestInfo(const char* a_test_case_base_name, - const char* a_test_base_name, - TestMetaFactoryBase<ParamType>* a_test_meta_factory) : - test_case_base_name(a_test_case_base_name), - test_base_name(a_test_base_name), - test_meta_factory(a_test_meta_factory) {} + TestInfo(const char* test_case_base_name, + const char* test_base_name, + TestMetaFactoryBase<ParamType>* test_meta_factory) : + test_case_base_name(test_case_base_name), + test_base_name(test_base_name), + test_meta_factory(test_meta_factory) {} const String test_case_base_name; const String test_base_name; diff --git a/gtest/include/gtest/internal/gtest-port.h b/gtest/include/gtest/internal/gtest-port.h index a2a62be..ee97881 100644 --- a/gtest/include/gtest/internal/gtest-port.h +++ b/gtest/include/gtest/internal/gtest-port.h @@ -42,8 +42,6 @@ // // GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) // is/isn't available. -// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions -// are enabled. // GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string // is/isn't available (some systems define // ::string, which is different to std::string). @@ -54,6 +52,9 @@ // is/isn't available. // GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't // enabled. +// GTEST_HAS_STD_STRING - Define it to 1/0 to indicate that +// std::string does/doesn't work (Google Test can +// be used where std::string is unavailable). // GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that // std::wstring does/doesn't work (Google Test can // be used where std::wstring is unavailable). @@ -66,19 +67,11 @@ // Test's own tr1 tuple implementation should be // used. Unused when the user sets // GTEST_HAS_TR1_TUPLE to 0. -// GTEST_LINKED_AS_SHARED_LIBRARY -// - Define to 1 when compiling tests that use -// Google Test as a shared library (known as -// DLL on Windows). -// GTEST_CREATE_SHARED_LIBRARY -// - Define to 1 when compiling Google Test itself -// as a shared library. // This header defines the following utilities: // // Macros indicating the current platform (defined to 1 if compiled on // the given platform; otherwise undefined): -// GTEST_OS_AIX - IBM AIX // GTEST_OS_CYGWIN - Cygwin // GTEST_OS_LINUX - Linux // GTEST_OS_MAC - Mac OS X @@ -87,7 +80,7 @@ // GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) // GTEST_OS_WINDOWS_DESKTOP - Windows Desktop // GTEST_OS_WINDOWS_MINGW - MinGW -// GTEST_OS_WINDOWS_MOBILE - Windows Mobile +// GTEST_OS_WINODWS_MOBILE - Windows Mobile // GTEST_OS_ZOS - z/OS // // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the @@ -110,13 +103,11 @@ // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. // GTEST_USES_SIMPLE_RE - our own simple regex is used; // the above two are mutually exclusive. -// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). // // Macros for basic C++ coding: // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a // variable don't have to be used. -// GTEST_DISALLOW_ASSIGN_ - disables operator=. // GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. // @@ -143,10 +134,7 @@ // LogToStderr() - directs all log messages to stderr. // FlushInfoLog() - flushes informational log messages. // -// Stdout and stderr capturing: -// CaptureStdout() - starts capturing stdout. -// GetCapturedStdout() - stops capturing stdout and returns the captured -// string. +// Stderr capturing: // CaptureStderr() - starts capturing stderr. // GetCapturedStderr() - stops capturing stderr and returns the captured // string. @@ -178,12 +166,9 @@ #endif // !_WIN32_WCE #include <iostream> // NOLINT -#include <sstream> // NOLINT -#include <string> // NOLINT #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" #define GTEST_FLAG_PREFIX_ "gtest_" -#define GTEST_FLAG_PREFIX_DASH_ "gtest-" #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" #define GTEST_NAME_ "Google Test" #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" @@ -217,12 +202,10 @@ #define GTEST_OS_ZOS 1 #elif defined(__sun) && defined(__SVR4) #define GTEST_OS_SOLARIS 1 -#elif defined(_AIX) -#define GTEST_OS_AIX 1 #endif // __CYGWIN__ #if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_SYMBIAN || \ - GTEST_OS_SOLARIS || GTEST_OS_AIX + GTEST_OS_SOLARIS // On some platforms, <regex.h> needs someone to define size_t, and // won't compile otherwise. We can #include it here as we already @@ -231,7 +214,6 @@ #include <regex.h> // NOLINT #include <strings.h> // NOLINT #include <sys/types.h> // NOLINT -#include <time.h> // NOLINT #include <unistd.h> // NOLINT #define GTEST_USES_POSIX_RE 1 @@ -254,11 +236,11 @@ #define GTEST_USES_SIMPLE_RE 1 #endif // GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC || - // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS || GTEST_OS_AIX + // GTEST_OS_SYMBIAN || GTEST_OS_SOLARIS + +// Defines GTEST_HAS_EXCEPTIONS to 1 if exceptions are enabled, or 0 +// otherwise. -#ifndef GTEST_HAS_EXCEPTIONS -// The user didn't tell us whether exceptions are enabled, so we need -// to figure it out. #if defined(_MSC_VER) || defined(__BORLANDC__) // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS // macro to enable exceptions, so we'll do the same. @@ -267,32 +249,30 @@ #define _HAS_EXCEPTIONS 1 #endif // _HAS_EXCEPTIONS #define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS -#elif defined(__GNUC__) && __EXCEPTIONS -// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. -#define GTEST_HAS_EXCEPTIONS 1 -#elif defined(__SUNPRO_CC) -// Sun Pro CC supports exceptions. However, there is no compile-time way of -// detecting whether they are enabled or not. Therefore, we assume that -// they are enabled unless the user tells us otherwise. -#define GTEST_HAS_EXCEPTIONS 1 -#elif defined(__IBMCPP__) && __EXCEPTIONS -// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. +#else // The compiler is not MSVC or C++Builder. +// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. For +// other compilers, we assume exceptions are disabled to be +// conservative. +#if defined(__GNUC__) && __EXCEPTIONS #define GTEST_HAS_EXCEPTIONS 1 #else -// For other compilers, we assume exceptions are disabled to be -// conservative. #define GTEST_HAS_EXCEPTIONS 0 +#endif // defined(__GNUC__) && __EXCEPTIONS #endif // defined(_MSC_VER) || defined(__BORLANDC__) -#endif // GTEST_HAS_EXCEPTIONS -#if !defined(GTEST_HAS_STD_STRING) -// Even though we don't use this macro any longer, we keep it in case -// some clients still depend on it. +// Determines whether ::std::string and ::string are available. + +#ifndef GTEST_HAS_STD_STRING +// The user didn't tell us whether ::std::string is available, so we +// need to figure it out. The only environment that we know +// ::std::string is not available is MSVC 7.1 or lower with exceptions +// disabled. +#if defined(_MSC_VER) && (_MSC_VER < 1400) && !GTEST_HAS_EXCEPTIONS +#define GTEST_HAS_STD_STRING 0 +#else #define GTEST_HAS_STD_STRING 1 -#elif !GTEST_HAS_STD_STRING -// The user told us that ::std::string isn't available. -#error "Google Test cannot be used where ::std::string isn't available." -#endif // !defined(GTEST_HAS_STD_STRING) +#endif +#endif // GTEST_HAS_STD_STRING #ifndef GTEST_HAS_GLOBAL_STRING // The user didn't tell us whether ::string is available, so we need @@ -308,10 +288,14 @@ // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring // is available. +#if GTEST_OS_CYGWIN || GTEST_OS_SOLARIS // Cygwin 1.5 and below doesn't support ::std::wstring. // Cygwin 1.7 might add wstring support; this should be updated when clear. // Solaris' libc++ doesn't support it either. -#define GTEST_HAS_STD_WSTRING (!(GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) +#define GTEST_HAS_STD_WSTRING 0 +#else +#define GTEST_HAS_STD_WSTRING GTEST_HAS_STD_STRING +#endif // GTEST_OS_CYGWIN || GTEST_OS_SOLARIS #endif // GTEST_HAS_STD_WSTRING @@ -322,6 +306,18 @@ (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) #endif // GTEST_HAS_GLOBAL_WSTRING +#if GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || \ + GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING +#include <string> // NOLINT +#endif // GTEST_HAS_STD_STRING || GTEST_HAS_GLOBAL_STRING || + // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING + +#if GTEST_HAS_STD_STRING +#include <sstream> // NOLINT +#else +#include <strstream> // NOLINT +#endif // GTEST_HAS_STD_STRING + // Determines whether RTTI is available. #ifndef GTEST_HAS_RTTI // The user didn't tell us whether RTTI is enabled, so we need to @@ -333,49 +329,34 @@ #define GTEST_HAS_RTTI 1 #else #define GTEST_HAS_RTTI 0 -#endif +#endif // _CPPRTTI -// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. -#elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) +#elif defined(__GNUC__) +// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. +#if GTEST_GCC_VER_ >= 40302 #ifdef __GXX_RTTI #define GTEST_HAS_RTTI 1 #else #define GTEST_HAS_RTTI 0 #endif // __GXX_RTTI - -// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if -// both the typeid and dynamic_cast features are present. -#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) - -#ifdef __RTTI_ALL__ -#define GTEST_HAS_RTTI 1 #else -#define GTEST_HAS_RTTI 0 -#endif +// For gcc versions smaller than 4.3.2, we assume RTTI is enabled. +#define GTEST_HAS_RTTI 1 +#endif // GTEST_GCC_VER >= 40302 #else -// For all other compilers, we assume RTTI is enabled. +// Unknown compiler - assume RTTI is enabled. #define GTEST_HAS_RTTI 1 #endif // _MSC_VER #endif // GTEST_HAS_RTTI -// It's this header's responsibility to #include <typeinfo> when RTTI -// is enabled. -#if GTEST_HAS_RTTI -#include <typeinfo> -#endif - -// Determines whether Google Test can use the pthreads library. +// Determines whether <pthread.h> is available. #ifndef GTEST_HAS_PTHREAD -// The user didn't tell us explicitly, so we assume pthreads support is -// available on Linux and Mac. -// -// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 -// to your compiler flags. +// The user didn't tell us, so we need to figure it out. #define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC) #endif // GTEST_HAS_PTHREAD @@ -392,19 +373,17 @@ #ifndef GTEST_USE_OWN_TR1_TUPLE // The user didn't tell us, so we need to figure it out. -// We use our own TR1 tuple if we aren't sure the user has an -// implementation of it already. At this time, GCC 4.0.0+ and MSVC -// 2010 are the only mainstream compilers that come with a TR1 tuple -// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by -// defining __GNUC__ and friends, but cannot compile GCC's tuple -// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB -// Feature Pack download, which we cannot assume the user has. -#if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ - || _MSC_VER >= 1600 +// We use our own tr1 tuple if we aren't sure the user has an +// implementation of it already. At this time, GCC 4.0.0+ is the only +// mainstream compiler that comes with a TR1 tuple implementation. +// MSVC 2008 (9.0) provides TR1 tuple in a 323 MB Feature Pack +// download, which we cannot assume the user has. MSVC 2010 isn't +// released yet. +#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) #define GTEST_USE_OWN_TR1_TUPLE 0 #else #define GTEST_USE_OWN_TR1_TUPLE 1 -#endif +#endif // defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) #endif // GTEST_USE_OWN_TR1_TUPLE @@ -446,13 +425,13 @@ #undef _TR1_FUNCTIONAL // Allows the user to #include // <tr1/functional> if he chooses to. #else -#include <tr1/tuple> // NOLINT +#include <tr1/tuple> #endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 #else // If the compiler is not GCC 4.0+, we assume the user is using a // spec-conforming TR1 implementation. -#include <tuple> // NOLINT +#include <tuple> #endif // GTEST_USE_OWN_TR1_TUPLE #endif // GTEST_HAS_TR1_TUPLE @@ -472,49 +451,47 @@ #endif // GTEST_HAS_CLONE -// Determines whether to support stream redirection. This is used to test -// output correctness and to implement death tests. -#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN -#define GTEST_HAS_STREAM_REDIRECTION_ 1 -#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN - // Determines whether to support death tests. -// Google Test does not support death tests for VC 7.1 and earlier as -// abort() in a VC 7.1 application compiled as GUI in debug config -// pops up a dialog window that cannot be suppressed programmatically. -#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ - (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ - GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX) +// Google Test does not support death tests for VC 7.1 and earlier for +// these reasons: +// 1. std::vector does not build in VC 7.1 when exceptions are disabled. +// 2. std::string does not build in VC 7.1 when exceptions are disabled +// (this is covered by GTEST_HAS_STD_STRING guard). +// 3. abort() in a VC 7.1 application compiled as GUI in debug config +// pops up a dialog window that cannot be suppressed programmatically. +#if GTEST_HAS_STD_STRING && \ + (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || \ + (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || GTEST_OS_WINDOWS_MINGW) #define GTEST_HAS_DEATH_TEST 1 #include <vector> // NOLINT #endif -// We don't support MSVC 7.1 with exceptions disabled now. Therefore -// all the compilers we care about are adequate for supporting -// value-parameterized tests. +// Determines whether to support value-parameterized tests. + +#if defined(__GNUC__) || (_MSC_VER >= 1400) +// TODO(vladl@google.com): get the implementation rid of vector and list +// to compile on MSVC 7.1. #define GTEST_HAS_PARAM_TEST 1 +#endif // defined(__GNUC__) || (_MSC_VER >= 1400) // Determines whether to support type-driven tests. -// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, -// Sun Pro CC, and IBM Visual Age support. -#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ - defined(__IBMCPP__) +// Typed tests need <typeinfo> and variadic macros, which gcc and VC +// 8.0+ support. +#if defined(__GNUC__) || (_MSC_VER >= 1400) #define GTEST_HAS_TYPED_TEST 1 #define GTEST_HAS_TYPED_TEST_P 1 -#endif +#endif // defined(__GNUC__) || (_MSC_VER >= 1400) // Determines whether to support Combine(). This only makes sense when -// value-parameterized tests are enabled. The implementation doesn't -// work on Sun Studio since it doesn't understand templated conversion -// operators. -#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) +// value-parameterized tests are enabled. +#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE #define GTEST_HAS_COMBINE 1 -#endif +#endif // GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE // Determines whether the system compiler uses UTF-16 for encoding wide strings. #define GTEST_WIDE_STRING_USES_UTF16_ \ - (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) + (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN) // Defines some utility macros. @@ -549,16 +526,11 @@ #define GTEST_ATTRIBUTE_UNUSED_ #endif -// A macro to disallow operator= -// This should be used in the private: declarations for a class. -#define GTEST_DISALLOW_ASSIGN_(type)\ - void operator=(type const &) - -// A macro to disallow copy constructor and operator= +// A macro to disallow the evil copy constructor and operator= functions // This should be used in the private: declarations for a class. #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ - type(type const &);\ - GTEST_DISALLOW_ASSIGN_(type) + type(const type &);\ + void operator=(const type &) // Tell the compiler to warn about unused return values for functions declared // with this macro. The macro should be used on function declarations @@ -587,20 +559,6 @@ #endif // GTEST_HAS_SEH -#ifdef _MSC_VER - -#if GTEST_LINKED_AS_SHARED_LIBRARY -#define GTEST_API_ __declspec(dllimport) -#elif GTEST_CREATE_SHARED_LIBRARY -#define GTEST_API_ __declspec(dllexport) -#endif - -#endif // _MSC_VER - -#ifndef GTEST_API_ -#define GTEST_API_ -#endif - namespace testing { class Message; @@ -609,11 +567,19 @@ namespace internal { class String; +// std::strstream is deprecated. However, we have to use it on +// Windows as std::stringstream won't compile on Windows when +// exceptions are disabled. We use std::stringstream on other +// platforms to avoid compiler warnings there. +#if GTEST_HAS_STD_STRING typedef ::std::stringstream StrStream; +#else +typedef ::std::strstream StrStream; +#endif // GTEST_HAS_STD_STRING // A helper for suppressing warnings on constant condition. It just // returns 'condition'. -GTEST_API_ bool IsTrue(bool condition); +bool IsTrue(bool condition); // Defines scoped_ptr. @@ -622,8 +588,6 @@ GTEST_API_ bool IsTrue(bool condition); template <typename T> class scoped_ptr { public: - typedef T element_type; - explicit scoped_ptr(T* p = NULL) : ptr_(p) {} ~scoped_ptr() { reset(); } @@ -653,16 +617,14 @@ class scoped_ptr { // Defines RE. -// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended +// A simple C++ wrapper for <regex.h>. It uses the POSIX Enxtended // Regular Expression syntax. -class GTEST_API_ RE { +class RE { public: - // A copy constructor is required by the Standard to initialize object - // references from r-values. - RE(const RE& other) { Init(other.pattern()); } - // Constructs an RE from a string. +#if GTEST_HAS_STD_STRING RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_GLOBAL_STRING RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT @@ -681,12 +643,14 @@ class GTEST_API_ RE { // // TODO(wan@google.com): make FullMatch() and PartialMatch() work // when str contains NUL characters. +#if GTEST_HAS_STD_STRING static bool FullMatch(const ::std::string& str, const RE& re) { return FullMatch(str.c_str(), re); } static bool PartialMatch(const ::std::string& str, const RE& re) { return PartialMatch(str.c_str(), re); } +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_GLOBAL_STRING static bool FullMatch(const ::string& str, const RE& re) { @@ -716,7 +680,7 @@ class GTEST_API_ RE { const char* full_pattern_; // For FullMatch(); #endif - GTEST_DISALLOW_ASSIGN_(RE); + GTEST_DISALLOW_COPY_AND_ASSIGN_(RE); }; // Defines logging utilities: @@ -735,7 +699,7 @@ enum GTestLogSeverity { // Formats log entry severity, provides a stream object for streaming the // log message, and terminates the message with a newline when going out of // scope. -class GTEST_API_ GTestLog { +class GTestLog { public: GTestLog(GTestLogSeverity severity, const char* file, int line); @@ -757,69 +721,12 @@ class GTEST_API_ GTestLog { inline void LogToStderr() {} inline void FlushInfoLog() { fflush(NULL); } -// INTERNAL IMPLEMENTATION - DO NOT USE. -// -// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition -// is not satisfied. -// Synopsys: -// GTEST_CHECK_(boolean_condition); -// or -// GTEST_CHECK_(boolean_condition) << "Additional message"; -// -// This checks the condition and if the condition is not satisfied -// it prints message about the condition violation, including the -// condition itself, plus additional message streamed into it, if any, -// and then it aborts the program. It aborts the program irrespective of -// whether it is built in the debug mode or not. -#define GTEST_CHECK_(condition) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (::testing::internal::IsTrue(condition)) \ - ; \ - else \ - GTEST_LOG_(FATAL) << "Condition " #condition " failed. " - -// An all-mode assert to verify that the given POSIX-style function -// call returns 0 (indicating success). Known limitation: this -// doesn't expand to a balanced 'if' statement, so enclose the macro -// in {} if you need to use it as the only statement in an 'if' -// branch. -#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ - if (const int gtest_error = (posix_call)) \ - GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ - << gtest_error - -// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. -// -// Downcasts the pointer of type Base to Derived. -// Derived must be a subclass of Base. The parameter MUST -// point to a class of type Derived, not any subclass of it. -// When RTTI is available, the function performs a runtime -// check to enforce this. -template <class Derived, class Base> -Derived* CheckedDowncastToActualType(Base* base) { -#if GTEST_HAS_RTTI - GTEST_CHECK_(typeid(*base) == typeid(Derived)); - return dynamic_cast<Derived*>(base); // NOLINT -#else - return static_cast<Derived*>(base); // Poor man's downcast. -#endif -} - -#if GTEST_HAS_STREAM_REDIRECTION_ - // Defines the stderr capturer: -// CaptureStdout - starts capturing stdout. -// GetCapturedStdout - stops capturing stdout and returns the captured string. // CaptureStderr - starts capturing stderr. // GetCapturedStderr - stops capturing stderr and returns the captured string. -// -GTEST_API_ void CaptureStdout(); -GTEST_API_ String GetCapturedStdout(); -GTEST_API_ void CaptureStderr(); -GTEST_API_ String GetCapturedStderr(); - -#endif // GTEST_HAS_STREAM_REDIRECTION_ +void CaptureStderr(); +String GetCapturedStderr(); #if GTEST_HAS_DEATH_TEST @@ -833,338 +740,6 @@ const ::std::vector<String>& GetArgvs(); // Defines synchronization primitives. -#if GTEST_HAS_PTHREAD - -// Sleeps for (roughly) n milli-seconds. This function is only for -// testing Google Test's own constructs. Don't use it in user tests, -// either directly or indirectly. -inline void SleepMilliseconds(int n) { - const timespec time = { - 0, // 0 seconds. - n * 1000L * 1000L, // And n ms. - }; - nanosleep(&time, NULL); -} - -// Allows a controller thread to pause execution of newly created -// threads until notified. Instances of this class must be created -// and destroyed in the controller thread. -// -// This class is only for testing Google Test's own constructs. Do not -// use it in user tests, either directly or indirectly. -class Notification { - public: - Notification() : notified_(false) {} - - // Notifies all threads created with this notification to start. Must - // be called from the controller thread. - void Notify() { notified_ = true; } - - // Blocks until the controller thread notifies. Must be called from a test - // thread. - void WaitForNotification() { - while(!notified_) { - SleepMilliseconds(10); - } - } - - private: - volatile bool notified_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); -}; - -// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. -// Consequently, it cannot select a correct instantiation of ThreadWithParam -// in order to call its Run(). Introducing ThreadWithParamBase as a -// non-templated base class for ThreadWithParam allows us to bypass this -// problem. -class ThreadWithParamBase { - public: - virtual ~ThreadWithParamBase() {} - virtual void Run() = 0; -}; - -// pthread_create() accepts a pointer to a function type with the C linkage. -// According to the Standard (7.5/1), function types with different linkages -// are different even if they are otherwise identical. Some compilers (for -// example, SunStudio) treat them as different types. Since class methods -// cannot be defined with C-linkage we need to define a free C-function to -// pass into pthread_create(). -extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { - static_cast<ThreadWithParamBase*>(thread)->Run(); - return NULL; -} - -// Helper class for testing Google Test's multi-threading constructs. -// To use it, write: -// -// void ThreadFunc(int param) { /* Do things with param */ } -// Notification thread_can_start; -// ... -// // The thread_can_start parameter is optional; you can supply NULL. -// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); -// thread_can_start.Notify(); -// -// These classes are only for testing Google Test's own constructs. Do -// not use them in user tests, either directly or indirectly. -template <typename T> -class ThreadWithParam : public ThreadWithParamBase { - public: - typedef void (*UserThreadFunc)(T); - - ThreadWithParam( - UserThreadFunc func, T param, Notification* thread_can_start) - : func_(func), - param_(param), - thread_can_start_(thread_can_start), - finished_(false) { - ThreadWithParamBase* const base = this; - // The thread can be created only after all fields except thread_ - // have been initialized. - GTEST_CHECK_POSIX_SUCCESS_( - pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); - } - ~ThreadWithParam() { Join(); } - - void Join() { - if (!finished_) { - GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); - finished_ = true; - } - } - - virtual void Run() { - if (thread_can_start_ != NULL) - thread_can_start_->WaitForNotification(); - func_(param_); - } - - private: - const UserThreadFunc func_; // User-supplied thread function. - const T param_; // User-supplied parameter to the thread function. - // When non-NULL, used to block execution until the controller thread - // notifies. - Notification* const thread_can_start_; - bool finished_; // true iff we know that the thread function has finished. - pthread_t thread_; // The native thread object. - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); -}; - -// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is -// true. -#include <pthread.h> - -// MutexBase and Mutex implement mutex on pthreads-based platforms. They -// are used in conjunction with class MutexLock: -// -// Mutex mutex; -// ... -// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end -// // of the current scope. -// -// MutexBase implements behavior for both statically and dynamically -// allocated mutexes. Do not use MutexBase directly. Instead, write -// the following to define a static mutex: -// -// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); -// -// You can forward declare a static mutex like this: -// -// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); -// -// To create a dynamic mutex, just define an object of type Mutex. -class MutexBase { - public: - // Acquires this mutex. - void Lock() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); - owner_ = pthread_self(); - } - - // Releases this mutex. - void Unlock() { - // We don't protect writing to owner_ here, as it's the caller's - // responsibility to ensure that the current thread holds the - // mutex when this is called. - owner_ = 0; - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); - } - - // Does nothing if the current thread holds the mutex. Otherwise, crashes - // with high probability. - void AssertHeld() const { - GTEST_CHECK_(owner_ == pthread_self()) - << "The current thread is not holding the mutex @" << this; - } - - // A static mutex may be used before main() is entered. It may even - // be used before the dynamic initialization stage. Therefore we - // must be able to initialize a static mutex object at link time. - // This means MutexBase has to be a POD and its member variables - // have to be public. - public: - pthread_mutex_t mutex_; // The underlying pthread mutex. - pthread_t owner_; // The thread holding the mutex; 0 means no one holds it. -}; - -// Forward-declares a static mutex. -#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ - extern ::testing::internal::MutexBase mutex - -// Defines and statically (i.e. at link time) initializes a static mutex. -#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ - ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 } - -// The Mutex class can only be used for mutexes created at runtime. It -// shares its API with MutexBase otherwise. -class Mutex : public MutexBase { - public: - Mutex() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); - owner_ = 0; - } - ~Mutex() { - GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); - } - - private: - GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); -}; - -// We cannot name this class MutexLock as the ctor declaration would -// conflict with a macro named MutexLock, which is defined on some -// platforms. Hence the typedef trick below. -class GTestMutexLock { - public: - explicit GTestMutexLock(MutexBase* mutex) - : mutex_(mutex) { mutex_->Lock(); } - - ~GTestMutexLock() { mutex_->Unlock(); } - - private: - MutexBase* const mutex_; - - GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); -}; - -typedef GTestMutexLock MutexLock; - -// Helpers for ThreadLocal. - -// pthread_key_create() requires DeleteThreadLocalValue() to have -// C-linkage. Therefore it cannot be templatized to access -// ThreadLocal<T>. Hence the need for class -// ThreadLocalValueHolderBase. -class ThreadLocalValueHolderBase { - public: - virtual ~ThreadLocalValueHolderBase() {} -}; - -// Called by pthread to delete thread-local data stored by -// pthread_setspecific(). -extern "C" inline void DeleteThreadLocalValue(void* value_holder) { - delete static_cast<ThreadLocalValueHolderBase*>(value_holder); -} - -// Implements thread-local storage on pthreads-based systems. -// -// // Thread 1 -// ThreadLocal<int> tl(100); // 100 is the default value for each thread. -// -// // Thread 2 -// tl.set(150); // Changes the value for thread 2 only. -// EXPECT_EQ(150, tl.get()); -// -// // Thread 1 -// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. -// tl.set(200); -// EXPECT_EQ(200, tl.get()); -// -// The template type argument T must have a public copy constructor. -// In addition, the default ThreadLocal constructor requires T to have -// a public default constructor. -// -// An object managed for a thread by a ThreadLocal instance is deleted -// when the thread exits. Or, if the ThreadLocal instance dies in -// that thread, when the ThreadLocal dies. It's the user's -// responsibility to ensure that all other threads using a ThreadLocal -// have exited when it dies, or the per-thread objects for those -// threads will not be deleted. -// -// Google Test only uses global ThreadLocal objects. That means they -// will die after main() has returned. Therefore, no per-thread -// object managed by Google Test will be leaked as long as all threads -// using Google Test have exited when main() returns. -template <typename T> -class ThreadLocal { - public: - ThreadLocal() : key_(CreateKey()), - default_() {} - explicit ThreadLocal(const T& value) : key_(CreateKey()), - default_(value) {} - - ~ThreadLocal() { - // Destroys the managed object for the current thread, if any. - DeleteThreadLocalValue(pthread_getspecific(key_)); - - // Releases resources associated with the key. This will *not* - // delete managed objects for other threads. - GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); - } - - T* pointer() { return GetOrCreateValue(); } - const T* pointer() const { return GetOrCreateValue(); } - const T& get() const { return *pointer(); } - void set(const T& value) { *pointer() = value; } - - private: - // Holds a value of type T. - class ValueHolder : public ThreadLocalValueHolderBase { - public: - explicit ValueHolder(const T& value) : value_(value) {} - - T* pointer() { return &value_; } - - private: - T value_; - GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); - }; - - static pthread_key_t CreateKey() { - pthread_key_t key; - // When a thread exits, DeleteThreadLocalValue() will be called on - // the object managed for that thread. - GTEST_CHECK_POSIX_SUCCESS_( - pthread_key_create(&key, &DeleteThreadLocalValue)); - return key; - } - - T* GetOrCreateValue() const { - ThreadLocalValueHolderBase* const holder = - static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); - if (holder != NULL) { - return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); - } - - ValueHolder* const new_holder = new ValueHolder(default_); - ThreadLocalValueHolderBase* const holder_base = new_holder; - GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); - return new_holder->pointer(); - } - - // A key pthreads uses for looking up per-thread values. - const pthread_key_t key_; - const T default_; // The default value for each thread. - - GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); -}; - -#define GTEST_IS_THREADSAFE 1 - -#else // GTEST_HAS_PTHREAD - // A dummy implementation of synchronization primitives (mutex, lock, // and thread-local variable). Necessary for compiling Google Test where // mutex is not supported - using Google Test in multiple threads is not @@ -1173,14 +748,14 @@ class ThreadLocal { class Mutex { public: Mutex() {} + explicit Mutex(int /*unused*/) {} void AssertHeld() const {} + enum { NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX = 0 }; }; -#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ - extern ::testing::internal::Mutex mutex - -#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex - +// We cannot call it MutexLock directly as the ctor declaration would +// conflict with a macro named MutexLock, which is defined on some +// platforms. Hence the typedef trick below. class GTestMutexLock { public: explicit GTestMutexLock(Mutex*) {} // NOLINT @@ -1201,37 +776,30 @@ class ThreadLocal { T value_; }; +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +size_t GetThreadCount(); + // The above synchronization primitives have dummy implementations. // Therefore Google Test is not thread-safe. #define GTEST_IS_THREADSAFE 0 -#endif // GTEST_HAS_PTHREAD - -// Returns the number of threads running in the process, or 0 to indicate that -// we cannot detect it. -GTEST_API_ size_t GetThreadCount(); +#if defined(__SYMBIAN32__) || defined(__IBMCPP__) // Passing non-POD classes through ellipsis (...) crashes the ARM -// compiler and generates a warning in Sun Studio. The Nokia Symbian -// and the IBM XL C/C++ compiler try to instantiate a copy constructor -// for objects passed through ellipsis (...), failing for uncopyable -// objects. We define this to ensure that only POD is passed through -// ellipsis on these systems. -#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) -// We lose support for NULL detection where the compiler doesn't like -// passing non-POD classes through ellipsis (...). -#define GTEST_ELLIPSIS_NEEDS_POD_ 1 -#else -#define GTEST_CAN_COMPARE_NULL 1 -#endif +// compiler. The Nokia Symbian and the IBM XL C/C++ compiler try to +// instantiate a copy constructor for objects passed through ellipsis +// (...), failing for uncopyable objects. We define this to indicate +// the fact. +#define GTEST_ELLIPSIS_NEEDS_COPY_ 1 // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between // const T& and const T* in a function template. These compilers // _can_ decide between class template specializations for T and T*, // so a tr1::type_traits-like is_pointer works. -#if defined(__SYMBIAN32__) || defined(__IBMCPP__) #define GTEST_NEEDS_IS_POINTER_ 1 -#endif + +#endif // defined(__SYMBIAN32__) || defined(__IBMCPP__) template <bool bool_value> struct bool_constant { @@ -1251,12 +819,10 @@ struct is_pointer<T*> : public true_type {}; #if GTEST_OS_WINDOWS #define GTEST_PATH_SEP_ "\\" -#define GTEST_HAS_ALT_PATH_SEP_ 1 // The biggest signed integer type the compiler supports. typedef __int64 BiggestInt; #else #define GTEST_PATH_SEP_ "/" -#define GTEST_HAS_ALT_PATH_SEP_ 0 typedef long long BiggestInt; // NOLINT #endif // GTEST_OS_WINDOWS @@ -1364,7 +930,7 @@ inline const char* GetEnv(const char* name) { #if GTEST_OS_WINDOWS_MOBILE // We are on Windows CE, which has no environment variables. return NULL; -#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) +#elif defined(__BORLANDC__) // Environment variables which we programmatically clear will be set to the // empty string rather than unset (NULL). Handle that case. const char* const env = getenv(name); @@ -1459,23 +1025,44 @@ typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. // Utilities for command line flags and environment variables. +// INTERNAL IMPLEMENTATION - DO NOT USE. +// +// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition +// is not satisfied. +// Synopsys: +// GTEST_CHECK_(boolean_condition); +// or +// GTEST_CHECK_(boolean_condition) << "Additional message"; +// +// This checks the condition and if the condition is not satisfied +// it prints message about the condition violation, including the +// condition itself, plus additional message streamed into it, if any, +// and then it aborts the program. It aborts the program irrespective of +// whether it is built in the debug mode or not. +#define GTEST_CHECK_(condition) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::IsTrue(condition)) \ + ; \ + else \ + GTEST_LOG_(FATAL) << "Condition " #condition " failed. " + // Macro for referencing flags. #define GTEST_FLAG(name) FLAGS_gtest_##name // Macros for declaring flags. -#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) +#define GTEST_DECLARE_bool_(name) extern bool GTEST_FLAG(name) #define GTEST_DECLARE_int32_(name) \ - GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) + extern ::testing::internal::Int32 GTEST_FLAG(name) #define GTEST_DECLARE_string_(name) \ - GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name) + extern ::testing::internal::String GTEST_FLAG(name) // Macros for defining flags. #define GTEST_DEFINE_bool_(name, default_val, doc) \ - GTEST_API_ bool GTEST_FLAG(name) = (default_val) + bool GTEST_FLAG(name) = (default_val) #define GTEST_DEFINE_int32_(name, default_val, doc) \ - GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) + ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) #define GTEST_DEFINE_string_(name, default_val, doc) \ - GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val) + ::testing::internal::String GTEST_FLAG(name) = (default_val) // Parses 'str' for a 32-bit signed integer. If successful, writes the result // to *value and returns true; otherwise leaves *value unchanged and returns @@ -1488,7 +1075,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); -GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); +Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); const char* StringFromGTestEnv(const char* flag, const char* default_val); } // namespace internal diff --git a/gtest/include/gtest/internal/gtest-string.h b/gtest/include/gtest/internal/gtest-string.h index aff093d..4bc8241 100644 --- a/gtest/include/gtest/internal/gtest-string.h +++ b/gtest/include/gtest/internal/gtest-string.h @@ -41,28 +41,26 @@ #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ -#ifdef __BORLANDC__ -// string.h is not guaranteed to provide strcpy on C++ Builder. -#include <mem.h> -#endif - #include <string.h> #include <gtest/internal/gtest-port.h> +#if GTEST_HAS_GLOBAL_STRING || GTEST_HAS_STD_STRING #include <string> +#endif // GTEST_HAS_GLOBAL_STRING || GTEST_HAS_STD_STRING namespace testing { namespace internal { // String - a UTF-8 string class. // -// For historic reasons, we don't use std::string. +// We cannot use std::string as Microsoft's STL implementation in +// Visual C++ 7.1 has problems when exception is disabled. There is a +// hack to work around this, but we've seen cases where the hack fails +// to work. // -// TODO(wan@google.com): replace this class with std::string or -// implement it in terms of the latter. -// -// Note that String can represent both NULL and the empty string, -// while std::string cannot represent NULL. +// Also, String is different from std::string in that it can represent +// both NULL and the empty string, while std::string cannot represent +// NULL. // // NULL and the empty string are considered different. NULL is less // than anything (including the empty string) except itself. @@ -78,7 +76,7 @@ namespace internal { // // In order to make the representation efficient, the d'tor of String // is not virtual. Therefore DO NOT INHERIT FROM String. -class GTEST_API_ String { +class String { public: // Static utility methods @@ -192,12 +190,12 @@ class GTEST_API_ String { String() : c_str_(NULL), length_(0) {} // Constructs a String by cloning a 0-terminated C string. - String(const char* a_c_str) { // NOLINT - if (a_c_str == NULL) { + String(const char* c_str) { // NOLINT + if (c_str == NULL) { c_str_ = NULL; length_ = 0; } else { - ConstructNonNull(a_c_str, strlen(a_c_str)); + ConstructNonNull(c_str, strlen(c_str)); } } @@ -205,8 +203,8 @@ class GTEST_API_ String { // buffer. E.g. String("hello", 3) creates the string "hel", // String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "", // and String(NULL, 1) results in access violation. - String(const char* buffer, size_t a_length) { - ConstructNonNull(buffer, a_length); + String(const char* buffer, size_t length) { + ConstructNonNull(buffer, length); } // The copy c'tor creates a new copy of the string. The two @@ -223,11 +221,13 @@ class GTEST_API_ String { // Converting a ::std::string or ::string containing an embedded NUL // character to a String will result in the prefix up to the first // NUL character. +#if GTEST_HAS_STD_STRING String(const ::std::string& str) { ConstructNonNull(str.c_str(), str.length()); } operator ::std::string() const { return ::std::string(c_str(), length()); } +#endif // GTEST_HAS_STD_STRING #if GTEST_HAS_GLOBAL_STRING String(const ::string& str) { @@ -247,7 +247,7 @@ class GTEST_API_ String { // Returns true iff this String equals the given C string. A NULL // string and a non-NULL string are considered not equal. - bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; } + bool operator==(const char* c_str) const { return Compare(c_str) == 0; } // Returns true iff this String is less than the given String. A // NULL string is considered less than "". @@ -255,7 +255,7 @@ class GTEST_API_ String { // Returns true iff this String doesn't equal the given C string. A NULL // string and a non-NULL string are considered not equal. - bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); } + bool operator!=(const char* c_str) const { return !(*this == c_str); } // Returns true iff this String ends with the given suffix. *Any* // String is considered to end with a NULL or empty suffix. @@ -275,9 +275,7 @@ class GTEST_API_ String { const char* c_str() const { return c_str_; } // Assigns a C string to this object. Self-assignment works. - const String& operator=(const char* a_c_str) { - return *this = String(a_c_str); - } + const String& operator=(const char* c_str) { return *this = String(c_str); } // Assigns a String object to this object. Self-assignment works. const String& operator=(const String& rhs) { @@ -299,12 +297,12 @@ class GTEST_API_ String { // function can only be called when data_ has not been allocated. // ConstructNonNull(NULL, 0) results in an empty string (""). // ConstructNonNull(NULL, non_zero) is undefined behavior. - void ConstructNonNull(const char* buffer, size_t a_length) { - char* const str = new char[a_length + 1]; - memcpy(str, buffer, a_length); - str[a_length] = '\0'; + void ConstructNonNull(const char* buffer, size_t length) { + char* const str = new char[length + 1]; + memcpy(str, buffer, length); + str[length] = '\0'; c_str_ = str; - length_ = a_length; + length_ = length; } const char* c_str_; @@ -331,7 +329,7 @@ inline ::std::ostream& operator<<(::std::ostream& os, const String& str) { // Gets the content of the StrStream's buffer as a String. Each '\0' // character in the buffer is replaced with "\\0". -GTEST_API_ String StrStreamToString(StrStream* stream); +String StrStreamToString(StrStream* stream); // Converts a streamable value to a String. A NULL pointer is // converted to "(null)". When the input value is a ::string, diff --git a/gtest/include/gtest/internal/gtest-tuple.h b/gtest/include/gtest/internal/gtest-tuple.h index 16178fc..86b200b 100644 --- a/gtest/include/gtest/internal/gtest-tuple.h +++ b/gtest/include/gtest/internal/gtest-tuple.h @@ -42,8 +42,7 @@ // tuple template as a friend (it complains that tuple is redefined). This // hack bypasses the bug by declaring the members that should otherwise be // private as public. -// Sun Studio versions < 12 also have the above bug. -#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) +#if defined(__SYMBIAN32__) #define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: #else #define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ @@ -184,7 +183,7 @@ class GTEST_1_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} @@ -216,7 +215,7 @@ class GTEST_2_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), f1_(f1) {} @@ -259,7 +258,7 @@ class GTEST_3_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} @@ -296,7 +295,7 @@ class GTEST_4_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), @@ -337,7 +336,7 @@ class GTEST_5_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, @@ -381,7 +380,7 @@ class GTEST_6_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, @@ -428,7 +427,7 @@ class GTEST_7_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, @@ -477,7 +476,7 @@ class GTEST_8_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, @@ -529,7 +528,7 @@ class GTEST_9_TUPLE_(T) { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, @@ -583,8 +582,7 @@ class tuple { public: template <int k> friend class gtest_internal::Get; - tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), - f9_() {} + tuple() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, diff --git a/gtest/include/gtest/internal/gtest-tuple.h.pump b/gtest/include/gtest/internal/gtest-tuple.h.pump index 85ebc80..12821d8 100644 --- a/gtest/include/gtest/internal/gtest-tuple.h.pump +++ b/gtest/include/gtest/internal/gtest-tuple.h.pump @@ -39,12 +39,11 @@ $$ This meta comment fixes auto-indentation in Emacs. }} #include <utility> // For ::std::pair. -// The compiler used in Symbian has a bug that prevents us from declaring the -// tuple template as a friend (it complains that tuple is redefined). This -// hack bypasses the bug by declaring the members that should otherwise be -// private as public. -// Sun Studio versions < 12 also have the above bug. -#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) +// The compiler used in Symbian 5th Edition (__S60_50__) has a bug +// that prevents us from declaring the tuple template as a friend (it +// complains that tuple is redefined). This hack bypasses the bug by +// declaring the members that should otherwise be private as public. +#if defined(__SYMBIAN32__) && __S60_50__ #define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: #else #define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ @@ -141,7 +140,7 @@ class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] { public: template <int k> friend class gtest_internal::Get; - tuple() : $for m, [[f$(m)_()]] {} + tuple() {} explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]] $for m, [[f$(m)_(f$m)]] {} diff --git a/gtest/include/gtest/internal/gtest-type-util.h b/gtest/include/gtest/internal/gtest-type-util.h index 093eee6..f1b1bed 100644 --- a/gtest/include/gtest/internal/gtest-type-util.h +++ b/gtest/include/gtest/internal/gtest-type-util.h @@ -1,6 +1,4 @@ -// This file was GENERATED by command: -// pump.py gtest-type-util.h.pump -// DO NOT EDIT BY HAND!!! +// This file was GENERATED by a script. DO NOT EDIT BY HAND!!! // Copyright 2008 Google Inc. // All Rights Reserved. @@ -55,6 +53,8 @@ #include <cxxabi.h> #endif // __GLIBCXX__ +#include <typeinfo> + namespace testing { namespace internal { diff --git a/gtest/include/gtest/internal/gtest-type-util.h.pump b/gtest/include/gtest/internal/gtest-type-util.h.pump index 5aed1e5..3eb5dce 100644 --- a/gtest/include/gtest/internal/gtest-type-util.h.pump +++ b/gtest/include/gtest/internal/gtest-type-util.h.pump @@ -53,6 +53,8 @@ $var n = 50 $$ Maximum length of type lists we want to support. #include <cxxabi.h> #endif // __GLIBCXX__ +#include <typeinfo> + namespace testing { namespace internal { |