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 320996 6ca9d7aa4dc75e39aa260313d8ba552b2e76322a
parent 320995 d7335cf91ad0ad8b9f798735490a15876aa05bb8
child 320997 1aa86d89eea5dd233705e7cce1c3883ee0466ea8
push id83505
push usererahm@mozilla.com
push dateFri, 04 Nov 2016 18:14:05 +0000
treeherdermozilla-inbound@6ca9d7aa4dc7 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1313467
milestone52.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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',