Changeset 11054 for code/branches/cpp11_v3/test/util

Timestamp:

Jan 10, 2016, 1:54:11 PM (9 years ago)

Author:

landauf

Message:

merged branch cpp11_v2 into cpp11_v3

Location:

code/branches/cpp11_v3

Files:

• . (modified) (1 prop)
• test/util/MathTest.cc (modified) (4 diffs)
• test/util/SharedPtrTest.cc (modified) (15 diffs)
• test/util/SingletonTest.cc (modified) (1 diff)
• test/util/SmallObjectAllocatorTest.cc (modified) (4 diffs)
• test/util/output/BaseWriterTest.cc (modified) (1 diff)
• test/util/output/ConsoleWriterTest.cc (modified) (4 diffs)
• test/util/output/LogWriterTest.cc (modified) (5 diffs)
• test/util/output/MemoryWriterTest.cc (modified) (2 diffs)
• test/util/output/OutputListenerTest.cc (modified) (2 diffs)
• test/util/output/OutputManagerTest.cc (modified) (2 diffs)
• test/util/output/OutputStreamTest.cc (modified) (2 diffs)

code/branches/cpp11_v3/test/util/MathTest.cc

@@ -245 +245 @@
 
         // all numbers must satisfy 0 <= <number> < 1
-        for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
+        for (float number : numbers)
         {
-            EXPECT_LE(min, *it);
-            EXPECT_GT(max, *it);
+            EXPECT_LE(min, number);
+            EXPECT_GT(max, number);
         }
     }
@@ -268 +268 @@
 
         // all numbers must satisfy 0 <= <number> < <max>
-        for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
+        for (float number : numbers)
         {
-            EXPECT_LE(min, *it);
-            EXPECT_GT(max, *it);
+            EXPECT_LE(min, number);
+            EXPECT_GT(max, number);
         }
     }
@@ -291 +291 @@
 
         // all numbers must satisfy <min> <= <number> < <max>
-        for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
+        for (float number : numbers)
         {
-            EXPECT_LE(min, *it);
-            EXPECT_GT(max, *it);
+            EXPECT_LE(min, number);
+            EXPECT_GT(max, number);
         }
     }
@@ -315 +315 @@
 
         // all numbers must be either 1 oder -1
-        for (std::set<float>::iterator it = numbers.begin(); it != numbers.end(); ++it)
-            EXPECT_TRUE(*it == 1 || *it == -1);
+        for (float number : numbers)
+            EXPECT_TRUE(number == 1 || number == -1);
     }
 

code/branches/cpp11_v3/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);

code/branches/cpp11_v3/test/util/SingletonTest.cc

@@ -23 +23 @@
         };
 
-        TestSingleton* TestSingleton::singletonPtr_s = NULL;
+        TestSingleton* TestSingleton::singletonPtr_s = nullptr;
         const size_t TestSingleton::MAGIC_VALUE = 0xCAFEBABE;
     }

code/branches/cpp11_v3/test/util/SmallObjectAllocatorTest.cc

@@ -47 +47 @@
         // create an integer
         size_t* pointer = this->create(5);
-        ASSERT_NE((void*)0, pointer);
+        ASSERT_NE((void*)nullptr, pointer);
         EXPECT_EQ(5u, *pointer);
     }
@@ -55 +55 @@
         // create an integer
         size_t* pointer = this->create(5);
-        ASSERT_NE((void*)0, pointer);
+        ASSERT_NE((void*)nullptr, pointer);
         EXPECT_EQ(5u, *pointer);
 
@@ -228 +228 @@
         // create an object
         SmallObject* pointer = this->create(5);
-        ASSERT_NE((void*)0, pointer);
+        ASSERT_NE((void*)nullptr, pointer);
         EXPECT_EQ(5u, pointer->getValue());
         EXPECT_EQ(5u, SmallObject::total_s);
@@ -239 +239 @@
         // create an object
         SmallObject* pointer = this->create(5);
-        ASSERT_NE((void*)0, pointer);
+        ASSERT_NE((void*)nullptr, pointer);
         EXPECT_EQ(5u, pointer->getValue());
         EXPECT_EQ(5u, SmallObject::total_s);

code/branches/cpp11_v3/test/util/output/BaseWriterTest.cc

@@ -30 +30 @@
                 MOCK_METHOD2(printLine, void(const std::string&, OutputLevel));
 
-                virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
+                virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) override
                     { this->BaseWriter::output(level, context, lines); }
         };

code/branches/cpp11_v3/test/util/output/ConsoleWriterTest.cc

@@ -3 +3 @@
 #include "util/output/ConsoleWriter.h"
 #include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -13 +12 @@
         {
             public:
-                virtual void SetUp()
+                virtual void SetUp() override
                 {
                     // reset output manager
-                    OutputManager::Testing::getInstancePointer() = new OutputManager();
+                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
                 }
 
-                virtual void TearDown()
+                virtual void TearDown() override
                 {
                 }
@@ -27 +26 @@
     TEST_F(ConsoleWriterTest, Disable)
     {
-        std::ostream stream(NULL);
+        std::ostream stream(nullptr);
         EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
         ConsoleWriter writer(stream);
@@ -37 +36 @@
     TEST_F(ConsoleWriterTest, Enable)
     {
-        std::ostream stream(NULL);
+        std::ostream stream(nullptr);
         ConsoleWriter writer(stream);
         writer.disable();

code/branches/cpp11_v3/test/util/output/LogWriterTest.cc

@@ -4 +4 @@
 #include "util/Convert.h"
 #include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -13 +12 @@
         {
             public:
-                virtual void printLine(const std::string& line, OutputLevel level)
+                virtual void printLine(const std::string& line, OutputLevel level) override
                     { this->LogWriter::printLine(line, level); }
         };
@@ -21 +20 @@
         {
             public:
-                virtual void SetUp()
+                virtual void SetUp() override
                 {
                     // reset output manager
-                    OutputManager::Testing::getInstancePointer() = new OutputManager();
+                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
                 }
 
-                virtual void TearDown()
+                virtual void TearDown() override
                 {
                 }
@@ -138 +137 @@
         std::string line = getLineWhichContains(path, "myothertestoutput");
         EXPECT_FALSE(line.empty());
+        ASSERT_TRUE(line.length() > 12);
+
         EXPECT_TRUE(isdigit(line[0]));
         EXPECT_TRUE(isdigit(line[1]));
@@ -146 +147 @@
         EXPECT_TRUE(isdigit(line[6]));
         EXPECT_TRUE(isdigit(line[7]));
-        EXPECT_EQ(' ', line[8]);
+        EXPECT_EQ(':', line[8]);
+        EXPECT_TRUE(isdigit(line[9]));
+        EXPECT_TRUE(isdigit(line[10]));
+        EXPECT_TRUE(isdigit(line[11]));
+        EXPECT_EQ(' ', line[12]);
     }
 

code/branches/cpp11_v3/test/util/output/MemoryWriterTest.cc

@@ -4 +4 @@
 #include "util/output/MemoryWriter.h"
 #include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -20 +19 @@
         {
             public:
-                virtual void SetUp()
+                virtual void SetUp() override
                 {
                     // reset output manager
-                    OutputManager::Testing::getInstancePointer() = new OutputManager();
+                    OutputManager::Testing::getInstancePointer().reset(new OutputManager());
                 }
 
-                virtual void TearDown()
+                virtual void TearDown() override
                 {
                 }

code/branches/cpp11_v3/test/util/output/OutputListenerTest.cc

@@ -3 +3 @@
 #include "util/output/OutputListener.h"
 #include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -342 +341 @@
             {
                 this->manager_ = new MockOutputManager();
-                OutputManager::Testing::getInstancePointer() = this->manager_;
+                OutputManager::Testing::getInstancePointer().reset(this->manager_);
             }
 
             virtual void TearDown()
             {
-                OutputManager::Testing::getInstancePointer() = new OutputManager();
+                OutputManager::Testing::getInstancePointer().reset(new OutputManager());
             }
 

code/branches/cpp11_v3/test/util/output/OutputManagerTest.cc

@@ -54 +54 @@
     TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
     {
-        EXPECT_TRUE(NULL == OutputManager::getInstance().getMemoryWriter());
-        EXPECT_TRUE(NULL == OutputManager::getInstance().getConsoleWriter());
-        EXPECT_TRUE(NULL == OutputManager::getInstance().getLogWriter());
+        EXPECT_TRUE(nullptr == OutputManager::getInstance().getMemoryWriter());
+        EXPECT_TRUE(nullptr == OutputManager::getInstance().getConsoleWriter());
+        EXPECT_TRUE(nullptr == OutputManager::getInstance().getLogWriter());
     }
 
@@ -62 +62 @@
     TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
     {
-        EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
-        EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
-        EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getLogWriter());
+        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
+        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
+        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getLogWriter());
     }
 

code/branches/cpp11_v3/test/util/output/OutputStreamTest.cc

@@ -8 +8 @@
 #include "util/output/OutputManager.h"
 #include "util/output/MemoryWriter.h"
-#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -88 +87 @@
             {
                 this->manager_ = new MockOutputManager();
-                OutputManager::Testing::getInstancePointer() = this->manager_;
+                OutputManager::Testing::getInstancePointer().reset(this->manager_);
             }
 
             virtual void TearDown()
             {
-                OutputManager::Testing::getInstancePointer() = new OutputManager();
+                OutputManager::Testing::getInstancePointer().reset(new OutputManager());
             }