Bug 1313467 - Part 4: Convert TestAutoPtr to a gtest. r=froydnj
authorEric Rahm <erahm@mozilla.com>
Fri, 04 Nov 2016 11:13:58 -0700
changeset 347749 6ca9d7aa4dc75e39aa260313d8ba552b2e76322a
parent 347748 d7335cf91ad0ad8b9f798735490a15876aa05bb8
child 347750 1aa86d89eea5dd233705e7cce1c3883ee0466ea8
push id10298
push userraliiev@mozilla.com
push dateMon, 14 Nov 2016 12:33:03 +0000
treeherdermozilla-aurora@7e29173b1641 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1313467
milestone52.0a1
Bug 1313467 - Part 4: Convert TestAutoPtr to a gtest. r=froydnj MozReview-Commit-ID: EOKHAQyZ4fZ
testing/cppunittest.ini
xpcom/tests/TestAutoPtr.cpp
xpcom/tests/gtest/TestAutoPtr.cpp
xpcom/tests/gtest/TestStringStream.cpp
xpcom/tests/gtest/moz.build
xpcom/tests/moz.build
--- a/testing/cppunittest.ini
+++ b/testing/cppunittest.ini
@@ -1,17 +1,16 @@
 [ShowSSEConfig]
 [TestAppShellSteadyState]
 [TestArray]
 [TestArrayUtils]
 [TestAtomics]
 [TestAudioBuffers]
 skip-if = os == 'b2g'  # Bug 1062937
 [TestAudioMixer]
-[TestAutoPtr]
 [TestAutoRef]
 [TestBinarySearch]
 [TestBind]
 [TestBloomFilter]
 [TestCOM]
 skip-if = os != 'win'
 [TestCOMArray]
 [TestCOMPtr]
rename from xpcom/tests/TestAutoPtr.cpp
rename to xpcom/tests/gtest/TestAutoPtr.cpp
--- a/xpcom/tests/TestAutoPtr.cpp
+++ b/xpcom/tests/gtest/TestAutoPtr.cpp
@@ -1,26 +1,23 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 // vim:cindent:ts=4:et:sw=4:
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsAutoPtr.h"
-#include <stdio.h>
-#include "nscore.h"
-#include "mozilla/Attributes.h"
+#include "gtest/gtest.h"
 
 class TestObjectBaseA {
   public:
     // Virtual dtor for deleting through base class pointer
     virtual ~TestObjectBaseA() { }
     void MemberFunction(int, int*, int&)
     {
-      printf("member function is invoked.\n");
     }
     virtual void VirtualMemberFunction(int, int*, int&) { };
     virtual void VirtualConstMemberFunction(int, int*, int&) const { };
     int fooA;
 };
 
 class TestObjectBaseB {
   public:
@@ -28,214 +25,196 @@ class TestObjectBaseB {
     virtual ~TestObjectBaseB() { }
     int fooB;
 };
 
 class TestObject : public TestObjectBaseA, public TestObjectBaseB {
   public:
     TestObject()
     {
-      printf("  Creating TestObject %p.\n",
-          static_cast<void*>(this));
     }
 
     // Virtual dtor for deleting through base class pointer
     virtual ~TestObject()
     {
-      printf("  Destroying TestObject %p.\n",
-          static_cast<void*>(this));
+      destructed++;
     }
 
     virtual void VirtualMemberFunction(int, int*, int&) override
     {
-      printf("override virtual member function is invoked.\n");
     }
     virtual void VirtualConstMemberFunction(int, int*, int&) const override
     {
-      printf("override virtual const member function is invoked.\n");
     }
+
+    static int destructed;
+    static const void* last_ptr;
 };
 
+int TestObject::destructed = 0;
+const void* TestObject::last_ptr = nullptr;
+
 static void CreateTestObject(TestObject **aResult)
 {
   *aResult = new TestObject();
 }
 
 static void DoSomethingWithTestObject(TestObject *aIn)
 {
-  printf("  Doing something with |TestObject| %p.\n",
-      static_cast<void*>(aIn));
+  TestObject::last_ptr = static_cast<void*>(aIn);
 }
 
 static void DoSomethingWithConstTestObject(const TestObject *aIn)
 {
-  printf("  Doing something with |const TestObject| %p.\n",
-      static_cast<const void*>(aIn));
+  TestObject::last_ptr = static_cast<const void*>(aIn);
 }
 
 static void DoSomethingWithTestObjectBaseB(TestObjectBaseB *aIn)
 {
-  printf("  Doing something with |TestObjectBaseB| %p.\n",
-      static_cast<void*>(aIn));
+  TestObject::last_ptr = static_cast<void*>(aIn);
 }
 
 static void DoSomethingWithConstTestObjectBaseB(const TestObjectBaseB *aIn)
 {
-  printf("  Doing something with |const TestObjectBaseB| %p.\n",
-      static_cast<const void*>(aIn));
+  TestObject::last_ptr = static_cast<const void*>(aIn);
 }
 
-void test_assignment()
+TEST(AutoPtr, Assignment)
 {
+  TestObject::destructed = 0;
+
   {
-    printf("Should create one |TestObject|:\n");
     nsAutoPtr<TestObject> pobj( new TestObject() );
-    printf("Should destroy one |TestObject|:\n");
   }
 
+  ASSERT_EQ(1, TestObject::destructed);
+
   {
-    printf("Should create one |TestObject|:\n");
     nsAutoPtr<TestObject> pobj( new TestObject() );
-    printf("Should create one |TestObject| and then destroy one:\n");
     pobj = new TestObject();
-    printf("Should destroy one |TestObject|:\n");
+    ASSERT_EQ(2, TestObject::destructed);
   }
+
+  ASSERT_EQ(3, TestObject::destructed);
 }
 
-void test_getter_Transfers()
+TEST(AutoPtr, getter_Transfers)
 {
-  printf("\nTesting getter_Transfers.\n");
+  TestObject::destructed = 0;
 
   {
     nsAutoPtr<TestObject> ptr;
-    printf("Should create one |TestObject|:\n");
     CreateTestObject(getter_Transfers(ptr));
-    printf("Should destroy one |TestObject|:\n");
   }
+
+  ASSERT_EQ(1, TestObject::destructed);
 }
 
-void test_casting()
+TEST(AutoPtr, Casting)
 {
-  printf("\nTesting casts and equality tests.\n");
-
   // This comparison is always false, as it should be. The extra parens
   // suppress a -Wunreachable-code warning about printf being unreachable.
-  if (((void*)(TestObject*)0x1000) ==
-      ((void*)(TestObjectBaseB*)(TestObject*)0x1000))
-    printf("\n\nAll these tests are meaningless!\n\n\n");
+  ASSERT_NE(((void*)(TestObject*)0x1000),
+             ((void*)(TestObjectBaseB*)(TestObject*)0x1000));
 
   {
     nsAutoPtr<TestObject> p1(new TestObject());
     TestObjectBaseB *p2 = p1;
-    printf("equality %s.\n",
-        ((static_cast<void*>(p1) != static_cast<void*>(p2)) &&
-         (p1 == p2) && !(p1 != p2) && (p2 == p1) && !(p2 != p1))
-        ? "OK" : "broken");
+    ASSERT_NE(static_cast<void*>(p1),
+               static_cast<void*>(p2));
+    ASSERT_EQ(p1, p2);
+    ASSERT_FALSE(p1 != p2);
+    ASSERT_EQ(p2, p1);
+    ASSERT_FALSE(p2 != p1);
   }
 
   {
     TestObject *p1 = new TestObject();
     nsAutoPtr<TestObjectBaseB> p2(p1);
-    printf("equality %s.\n",
-        ((static_cast<void*>(p1) != static_cast<void*>(p2)) &&
-         (p1 == p2) && !(p1 != p2) && (p2 == p1) && !(p2 != p1))
-        ? "OK" : "broken");
-  }
-}
-
-void test_forget()
-{
-  printf("\nTesting |forget()|.\n");
-
-  {
-    printf("Should create one |TestObject|:\n");
-    nsAutoPtr<TestObject> pobj( new TestObject() );
-    printf("Should do nothing:\n");
-    nsAutoPtr<TestObject> pobj2( pobj.forget() );
-    printf("Should destroy one |TestObject|:\n");
-  }
-}
-
-void test_construction()
-{
-  printf("\nTesting construction.\n");
-
-  {
-    printf("Should create one |TestObject|:\n");
-    nsAutoPtr<TestObject> pobj(new TestObject());
-    printf("Should destroy one |TestObject|:\n");
+    ASSERT_EQ(p1, p2);
+    ASSERT_FALSE(p1 != p2);
+    ASSERT_EQ(p2, p1);
+    ASSERT_FALSE(p2 != p1);
   }
 }
 
-void test_implicit_conversion()
+TEST(AutoPtr, Forget)
 {
-  printf("\nTesting calling of functions (including array access and casts).\n");
+  TestObject::destructed = 0;
 
   {
-    printf("Should create one |TestObject|:\n");
-    nsAutoPtr<TestObject> pobj(new TestObject());
-    printf("Should do something with one |TestObject|:\n");
-    DoSomethingWithTestObject(pobj);
-    printf("Should do something with one |TestObject|:\n");
-    DoSomethingWithConstTestObject(pobj);
-    printf("Should destroy one |TestObject|:\n");
+    nsAutoPtr<TestObject> pobj( new TestObject() );
+    nsAutoPtr<TestObject> pobj2( pobj.forget() );
+    ASSERT_EQ(0, TestObject::destructed);
   }
 
+  ASSERT_EQ(1, TestObject::destructed);
+}
+
+TEST(AutoPtr, Construction)
+{
+  TestObject::destructed = 0;
+
   {
-    printf("Should create one |TestObject|:\n");
     nsAutoPtr<TestObject> pobj(new TestObject());
-    printf("Should do something with one |TestObject|:\n");
-    DoSomethingWithTestObjectBaseB(pobj);
-    printf("Should do something with one |TestObject|:\n");
-    DoSomethingWithConstTestObjectBaseB(pobj);
-    printf("Should destroy one |TestObject|:\n");
   }
 
+  ASSERT_EQ(1, TestObject::destructed);
+}
+
+TEST(AutoPtr, ImplicitConversion)
+{
+  // This test is basically successful if it builds. We add a few assertions
+  // to make gtest happy.
+  TestObject::destructed = 0;
+
   {
-    printf("Should create one |TestObject|:\n");
-    const nsAutoPtr<TestObject> pobj(new TestObject());
-    printf("Should do something with one |TestObject|:\n");
+    nsAutoPtr<TestObject> pobj(new TestObject());
     DoSomethingWithTestObject(pobj);
-    printf("Should do something with one |TestObject|:\n");
     DoSomethingWithConstTestObject(pobj);
-    printf("Should destroy one |TestObject|:\n");
   }
 
+  ASSERT_EQ(1, TestObject::destructed);
+
   {
-    printf("Should create one |TestObject|:\n");
-    const nsAutoPtr<TestObject> pobj(new TestObject());
-    printf("Should do something with one |TestObject|:\n");
+    nsAutoPtr<TestObject> pobj(new TestObject());
     DoSomethingWithTestObjectBaseB(pobj);
-    printf("Should do something with one |TestObject|:\n");
     DoSomethingWithConstTestObjectBaseB(pobj);
-    printf("Should destroy one |TestObject|:\n");
+  }
+
+  ASSERT_EQ(2, TestObject::destructed);
+
+  {
+    const nsAutoPtr<TestObject> pobj(new TestObject());
+    DoSomethingWithTestObject(pobj);
+    DoSomethingWithConstTestObject(pobj);
   }
+
+  ASSERT_EQ(3, TestObject::destructed);
+
+  {
+    const nsAutoPtr<TestObject> pobj(new TestObject());
+    DoSomethingWithTestObjectBaseB(pobj);
+    DoSomethingWithConstTestObjectBaseB(pobj);
+  }
+
+  ASSERT_EQ(4, TestObject::destructed);
 }
 
-void test_arrow_operator()
+TEST(AutoPtr, ArrowOperator)
 {
+  // This test is basically successful if it builds. We add a few assertions
+  // to make gtest happy.
+  TestObject::destructed = 0;
+
   {
     int test = 1;
     void (TestObjectBaseA::*fPtr)( int, int*, int& ) = &TestObjectBaseA::MemberFunction;
     void (TestObjectBaseA::*fVPtr)( int, int*, int& ) = &TestObjectBaseA::VirtualMemberFunction;
     void (TestObjectBaseA::*fVCPtr)( int, int*, int& ) const = &TestObjectBaseA::VirtualConstMemberFunction;
-    printf("Should create one |TestObject|:\n");
     nsAutoPtr<TestObjectBaseA> pobj(new TestObject());
-    printf("Should do something with operator->*:\n");
     (pobj->*fPtr)(test, &test, test);
     (pobj->*fVPtr)(test, &test, test);
     (pobj->*fVCPtr)(test, &test, test);
-    printf("Should destroy one |TestObject|:\n");
   }
-}
 
-int main()
-{
-  test_assignment();
-  test_getter_Transfers();
-  test_casting();
-  test_forget();
-  test_construction();
-  test_implicit_conversion();
-  test_arrow_operator(); //???
-
-  return 0;
+  ASSERT_EQ(1, TestObject::destructed);
 }
--- a/xpcom/tests/gtest/TestStringStream.cpp
+++ b/xpcom/tests/gtest/TestStringStream.cpp
@@ -3,16 +3,19 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gtest/gtest.h"
 #include "Helpers.h"
 #include "nsICloneableInputStream.h"
 #include "nsStringStream.h"
+#include "nsTArray.h"
+#include "nsIInputStream.h"
+#include "nsCOMPtr.h"
 
 namespace {
 
 static void TestStringStream(uint32_t aNumBytes)
 {
   nsTArray<char> inputData;
   testing::CreateData(aNumBytes, inputData);
   nsDependentCSubstring inputString(inputData.Elements(), inputData.Length());
--- a/xpcom/tests/gtest/moz.build
+++ b/xpcom/tests/gtest/moz.build
@@ -2,16 +2,17 @@
 # vim: set filetype=python:
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 UNIFIED_SOURCES += [
     'Helpers.cpp',
     'TestAtoms.cpp',
+    'TestAutoPtr.cpp',
     'TestCloneInputStream.cpp',
     'TestCRT.cpp',
     'TestEncoding.cpp',
     'TestEscapeURL.cpp',
     'TestExpirationTracker.cpp',
     'TestNSPRLogModulesParser.cpp',
     'TestPipes.cpp',
     'TestPLDHash.cpp',
--- a/xpcom/tests/moz.build
+++ b/xpcom/tests/moz.build
@@ -41,17 +41,16 @@ if CONFIG['OS_TARGET'] == 'WINNT':
 if CONFIG['WRAP_STL_INCLUDES'] and not CONFIG['CLANG_CL']:
     GeckoSimplePrograms([
         'TestSTLWrappers',
     ])
 
 XPCSHELL_TESTS_MANIFESTS += ['unit/xpcshell.ini']
 
 GeckoCppUnitTests([
-    'TestAutoPtr',
     'TestAutoRef',
     'TestCOMArray',
     'TestCOMPtr',
     'TestCOMPtrEq',
     'TestFile',
     'TestHashtables',
     'TestID',
     'TestNsRefPtr',