1 files changed, 36 insertions, 27 deletions

diff --git a/gtest/test/gtest-listener_test.cc b/gtest/test/gtest-listener_test.cc
index c9be39a..f12f518 100644
--- a/gtest/test/gtest-listener_test.cc
+++ b/gtest/test/gtest-listener_test.cc
@@ -34,7 +34,15 @@
 // right times.
 
 #include <gtest/gtest.h>
-#include <vector>
+
+// Indicates that this translation unit is part of Google Test's
+// implementation.  It must come before gtest-internal-inl.h is
+// included, or there will be a compiler error.  This trick is to
+// prevent a user from accidentally including gtest-internal-inl.h in
+// his code.
+#define GTEST_IMPLEMENTATION_ 1
+#include "src/gtest-internal-inl.h"  // For Vector.
+#undef GTEST_IMPLEMENTATION_
 
 using ::testing::AddGlobalTestEnvironment;
 using ::testing::Environment;
@@ -46,9 +54,10 @@ using ::testing::TestInfo;
 using ::testing::TestPartResult;
 using ::testing::UnitTest;
 using ::testing::internal::String;
+using ::testing::internal::Vector;
 
 // Used by tests to register their events.
-std::vector<String>* g_events = NULL;
+Vector<String>* g_events = NULL;
 
 namespace testing {
 namespace internal {
@@ -59,7 +68,7 @@ class EventRecordingListener : public TestEventListener {
 
  protected:
   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnTestProgramStart"));
+    g_events->PushBack(GetFullMethodName("OnTestProgramStart"));
   }
 
   virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
@@ -67,43 +76,43 @@ class EventRecordingListener : public TestEventListener {
     Message message;
     message << GetFullMethodName("OnTestIterationStart")
             << "(" << iteration << ")";
-    g_events->push_back(message.GetString());
+    g_events->PushBack(message.GetString());
   }
 
   virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpStart"));
   }
 
   virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsSetUpEnd"));
   }
 
   virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
-    g_events->push_back(GetFullMethodName("OnTestCaseStart"));
+    g_events->PushBack(GetFullMethodName("OnTestCaseStart"));
   }
 
   virtual void OnTestStart(const TestInfo& /*test_info*/) {
-    g_events->push_back(GetFullMethodName("OnTestStart"));
+    g_events->PushBack(GetFullMethodName("OnTestStart"));
   }
 
   virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
-    g_events->push_back(GetFullMethodName("OnTestPartResult"));
+    g_events->PushBack(GetFullMethodName("OnTestPartResult"));
   }
 
   virtual void OnTestEnd(const TestInfo& /*test_info*/) {
-    g_events->push_back(GetFullMethodName("OnTestEnd"));
+    g_events->PushBack(GetFullMethodName("OnTestEnd"));
   }
 
   virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
-    g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
+    g_events->PushBack(GetFullMethodName("OnTestCaseEnd"));
   }
 
   virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownStart"));
   }
 
   virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
+    g_events->PushBack(GetFullMethodName("OnEnvironmentsTearDownEnd"));
   }
 
   virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
@@ -111,11 +120,11 @@ class EventRecordingListener : public TestEventListener {
     Message message;
     message << GetFullMethodName("OnTestIterationEnd")
             << "("  << iteration << ")";
-    g_events->push_back(message.GetString());
+    g_events->PushBack(message.GetString());
   }
 
   virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
-    g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
+    g_events->PushBack(GetFullMethodName("OnTestProgramEnd"));
   }
 
  private:
@@ -131,42 +140,42 @@ class EventRecordingListener : public TestEventListener {
 class EnvironmentInvocationCatcher : public Environment {
  protected:
   virtual void SetUp() {
-    g_events->push_back(String("Environment::SetUp"));
+    g_events->PushBack(String("Environment::SetUp"));
   }
 
   virtual void TearDown() {
-    g_events->push_back(String("Environment::TearDown"));
+    g_events->PushBack(String("Environment::TearDown"));
   }
 };
 
 class ListenerTest : public Test {
  protected:
   static void SetUpTestCase() {
-    g_events->push_back(String("ListenerTest::SetUpTestCase"));
+    g_events->PushBack(String("ListenerTest::SetUpTestCase"));
   }
 
   static void TearDownTestCase() {
-    g_events->push_back(String("ListenerTest::TearDownTestCase"));
+    g_events->PushBack(String("ListenerTest::TearDownTestCase"));
   }
 
   virtual void SetUp() {
-    g_events->push_back(String("ListenerTest::SetUp"));
+    g_events->PushBack(String("ListenerTest::SetUp"));
   }
 
   virtual void TearDown() {
-    g_events->push_back(String("ListenerTest::TearDown"));
+    g_events->PushBack(String("ListenerTest::TearDown"));
   }
 };
 
 TEST_F(ListenerTest, DoesFoo) {
   // Test execution order within a test case is not guaranteed so we are not
   // recording the test name.
-  g_events->push_back(String("ListenerTest::* Test Body"));
+  g_events->PushBack(String("ListenerTest::* Test Body"));
   SUCCEED();  // Triggers OnTestPartResult.
 }
 
 TEST_F(ListenerTest, DoesBar) {
-  g_events->push_back(String("ListenerTest::* Test Body"));
+  g_events->PushBack(String("ListenerTest::* Test Body"));
   SUCCEED();  // Triggers OnTestPartResult.
 }
 
@@ -177,7 +186,7 @@ TEST_F(ListenerTest, DoesBar) {
 using ::testing::internal::EnvironmentInvocationCatcher;
 using ::testing::internal::EventRecordingListener;
 
-void VerifyResults(const std::vector<String>& data,
+void VerifyResults(const Vector<String>& data,
                    const char* const* expected_data,
                    int expected_data_size) {
   const int actual_size = data.size();
@@ -190,18 +199,18 @@ void VerifyResults(const std::vector<String>& data,
       expected_data_size : actual_size;
   int i = 0;
   for (; i < shorter_size; ++i) {
-    ASSERT_STREQ(expected_data[i], data[i].c_str())
+    ASSERT_STREQ(expected_data[i], data.GetElement(i).c_str())
         << "at position " << i;
   }
 
   // Prints extra elements in the actual data.
   for (; i < actual_size; ++i) {
-    printf("  Actual event #%d: %s\n", i, data[i].c_str());
+    printf("  Actual event #%d: %s\n", i, data.GetElement(i).c_str());
   }
 }
 
 int main(int argc, char **argv) {
-  std::vector<String> events;
+  Vector<String> events;
   g_events = &events;
   InitGoogleTest(&argc, argv);