Changeset 11071 for code/trunk/test/util/SharedPtrTest.cc

Timestamp:

Jan 17, 2016, 10:29:21 PM (9 years ago)

Author:

landauf

Message:

merged branch cpp11_v3 back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• test/util/SharedPtrTest.cc (modified) (15 diffs)

code/trunk/test/util/SharedPtrTest.cc

@@ +1 @@
+#include <memory>
+#include <utility>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -27 +28 @@
         };
 
-        class TestClassMock : public TestClass
+        class TestChildClassMock : public TestChildClass
         {
             public:
-                TestClassMock() {}
-                ~TestClassMock() { objectDestroyed(); }
+                TestChildClassMock() {}
+                ~TestChildClassMock() { objectDestroyed(); }
 
                 MOCK_METHOD0(objectDestroyed, void());
@@ -39 +40 @@
     TEST(SharedPtr, ConstructorDefault)
     {
-        SharedPtr<TestClass> test;
-        EXPECT_EQ(0, test.get());
+        std::shared_ptr<TestClass> test;
+        EXPECT_EQ(nullptr, test.get());
     }
 
@@ -47 +48 @@
         TestClass* pointer = new TestClass();
 
-        SharedPtr<TestClass> test = pointer;
-        EXPECT_EQ(pointer, test.get());
+        std::shared_ptr<TestClass> test(pointer);
+        EXPECT_EQ(pointer, test.get());
+        EXPECT_EQ(pointer, &(*test));
     }
 
@@ -55 +57 @@
         TestChildClass* pointer = new TestChildClass();
 
-        SharedPtr<TestClass> test = pointer;
+        std::shared_ptr<TestClass> test(pointer);
         EXPECT_EQ(pointer, test.get());
     }
@@ -63 +65 @@
         TestClass* pointer = new TestClass();
 
-        SharedPtr<TestClass> other = pointer;
-        EXPECT_EQ(pointer, other.get());
-
-        SharedPtr<TestClass> test = other;
+        std::shared_ptr<TestClass> other(pointer);
+        EXPECT_EQ(pointer, other.get());
+
+        std::shared_ptr<TestClass> test = other;
         EXPECT_EQ(pointer, test.get());
     }
@@ -74 +76 @@
         TestChildClass* pointer = new TestChildClass();
 
-        SharedPtr<TestChildClass> other = pointer;
-        EXPECT_EQ(pointer, other.get());
-
-        SharedPtr<TestClass> test = other;
+        std::shared_ptr<TestChildClass> other(pointer);
+        EXPECT_EQ(pointer, other.get());
+
+        std::shared_ptr<TestClass> test = other;
         EXPECT_EQ(pointer, test.get());
     }
@@ -85 +87 @@
         TestClass* pointer = new TestClass();
 
-        SharedPtr<TestClass> other = pointer;
-        EXPECT_EQ(pointer, other.get());
-
-        SharedPtr<TestClass> test;
-        EXPECT_EQ(0, test.get());
+        std::shared_ptr<TestClass> other(pointer);
+        EXPECT_EQ(pointer, other.get());
+
+        std::shared_ptr<TestClass> test;
+        EXPECT_EQ(nullptr, test.get());
 
         test = other;
@@ -99 +101 @@
         TestChildClass* pointer = new TestChildClass();
 
-        SharedPtr<TestChildClass> other = pointer;
-        EXPECT_EQ(pointer, other.get());
-
-        SharedPtr<TestClass> test;
-        EXPECT_EQ(0, test.get());
+        std::shared_ptr<TestChildClass> other(pointer);
+        EXPECT_EQ(pointer, other.get());
+
+        std::shared_ptr<TestClass> test;
+        EXPECT_EQ(nullptr, test.get());
 
         test = other;
@@ -113 +115 @@
         TestChildClass* pointer = new TestChildClass();
 
-        SharedPtr<TestChildClass> other = pointer;
-        EXPECT_EQ(pointer, other.get());
-
-        SharedPtr<TestClass> test = other.cast<TestClass>();
+        std::shared_ptr<TestChildClass> other(pointer);
+        EXPECT_EQ(pointer, other.get());
+
+        std::shared_ptr<TestClass> test = std::static_pointer_cast<TestClass>(other);
         EXPECT_EQ(pointer, test.get());
     }
@@ -124 +126 @@
         TestClass* pointer = new TestClass();
 
-        SharedPtr<TestClass> test = pointer;
+        std::shared_ptr<TestClass> test(pointer);
         EXPECT_EQ(pointer, test.get());
 
@@ -135 +137 @@
     TEST(SharedPtr, Boolean)
     {
-        SharedPtr<TestClass> test;
-        EXPECT_EQ(0, test.get());
+        std::shared_ptr<TestClass> test;
+        EXPECT_EQ(nullptr, test.get());
         EXPECT_FALSE(test);
 
         TestClass* pointer = new TestClass();
 
-        test = pointer;
-        EXPECT_EQ(pointer, test.get());
-        EXPECT_TRUE(test);
+        test.reset(pointer);
+        EXPECT_EQ(pointer, test.get());
+        EXPECT_TRUE(static_cast<bool>(test));
     }
 
@@ -151 +153 @@
         TestClass* pointer2 = new TestClass();
 
-        SharedPtr<TestClass> test1 = pointer1;
-        SharedPtr<TestClass> test2 = pointer2;
+        std::shared_ptr<TestClass> test1(pointer1);
+        std::shared_ptr<TestClass> test2(pointer2);
 
         EXPECT_EQ(pointer1, test1.get());
@@ -165 +167 @@
     TEST(SharedPtr, ObjectDestroyedOnePointer)
     {
-        TestClassMock* pointer = new TestClassMock();
-        SharedPtr<TestClass> test = pointer;
+        TestChildClassMock* pointer = new TestChildClassMock();
+        std::shared_ptr<TestClass> test(pointer);
 
         EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
@@ -173 +175 @@
     TEST(SharedPtr, ObjectDestroyedManyPointers)
     {
-        TestClassMock* pointer = new TestClassMock();
-
-        SharedPtr<TestClass> test = pointer;
-        std::vector<SharedPtr<TestClass> > tests;
+        TestChildClassMock* pointer = new TestChildClassMock();
+
+        std::shared_ptr<TestClass> test(pointer);
+        std::vector<std::shared_ptr<TestClass>> tests;
         for (size_t i = 0; i < 100; ++i)
-            tests.push_back(SharedPtr<TestClass>(test));
+            tests.push_back(std::shared_ptr<TestClass>(test));
+
+        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
+    }
+
+    TEST(SharedPtr, TestConstructors)
+    {
+        {
+        TestChildClassMock* pointer = new TestChildClassMock();
+
+        // default
+        std::shared_ptr<TestChildClass> sharedPtr1;
+        EXPECT_EQ(nullptr, sharedPtr1.get());
+
+        // pointer
+        std::shared_ptr<TestChildClass> sharedPtr2(pointer);
+        EXPECT_EQ(pointer, sharedPtr2.get());
+
+        // copy
+        std::shared_ptr<TestChildClass> sharedPtr3(sharedPtr2);
+        EXPECT_EQ(pointer, sharedPtr3.get());
+
+        // move
+        std::shared_ptr<TestChildClass> sharedPtr4(std::move(sharedPtr3));
+        EXPECT_EQ(pointer, sharedPtr4.get());
+
+        // other
+        std::shared_ptr<TestClass> sharedPtr5(sharedPtr4);
+        EXPECT_EQ(pointer, sharedPtr5.get());
+
+        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
+        }
+    }
+
+    TEST(SharedPtr, TestConstructors2)
+    {
+        {
+        TestChildClassMock* pointer = new TestChildClassMock();
+
+        // default
+        std::shared_ptr<TestChildClass> sharedPtr1;
+        EXPECT_EQ(nullptr, sharedPtr1.get());
+
+        // pointer
+        std::shared_ptr<TestChildClass> sharedPtr2(pointer);
+        EXPECT_EQ(pointer, sharedPtr2.get());
+
+        // copy
+        std::shared_ptr<TestChildClass> sharedPtr3 = sharedPtr2;
+        EXPECT_EQ(pointer, sharedPtr3.get());
+
+        // move
+        std::shared_ptr<TestChildClass> sharedPtr4 = std::move(sharedPtr3);
+        EXPECT_EQ(pointer, sharedPtr4.get());
+
+        // other
+        std::shared_ptr<TestClass> sharedPtr5 = sharedPtr4;
+        EXPECT_EQ(pointer, sharedPtr5.get());
+
+        EXPECT_CALL(*pointer, objectDestroyed()).Times(1);
+        }
+    }
+
+    TEST(SharedPtr, TestAssignments)
+    {
+        TestChildClassMock* pointer = new TestChildClassMock();
+
+        std::shared_ptr<TestChildClass> sharedPtr1(pointer);
+        EXPECT_EQ(pointer, sharedPtr1.get());
+
+        // copy
+        std::shared_ptr<TestChildClass> sharedPtr2;
+        sharedPtr2 = sharedPtr1;
+        EXPECT_EQ(pointer, sharedPtr2.get());
+
+        // move
+        std::shared_ptr<TestChildClass> sharedPtr3;
+        sharedPtr3 = std::move(sharedPtr2);
+        EXPECT_EQ(pointer, sharedPtr3.get());
+
+        // other
+        std::shared_ptr<TestClass> sharedPtr4;
+        sharedPtr4 = sharedPtr3;
+        EXPECT_EQ(pointer, sharedPtr4.get());
 
         EXPECT_CALL(*pointer, objectDestroyed()).Times(1);