Changeset 9533

Timestamp:

Mar 2, 2013, 7:15:37 PM (12 years ago)

Author:

landauf

Message:

added more tests

Location:

code/branches/testing

Files:

• src/libraries/util/UtilPrereqs.h (modified) (1 diff)
• src/libraries/util/output/OutputManager.cc (modified) (3 diffs)
• src/libraries/util/output/OutputManager.h (modified) (4 diffs)
• test/util/OutputTest.cc (modified) (3 diffs)
• test/util/output/OutputDefinitionsTest.cc (modified) (1 diff)
• test/util/output/OutputListenerTest.cc (modified) (10 diffs)

code/branches/testing/src/libraries/util/UtilPrereqs.h

@@ -97 +97 @@
     class ScopedSingleton;
     class ScopeListener;
+    template <class T>
+    class SharedPtr;
     class SignalHandler;
     template <class T>

code/branches/testing/src/libraries/util/output/OutputManager.cc

@@ -39 +39 @@
 #include "util/Output.h"
 #include "util/StringUtils.h"
+#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -61 +62 @@
     }
 
+    /*static*/ SharedPtr<OutputManager>& OutputManager::Testing::getInstancePointer()
+    {
+        static SharedPtr<OutputManager> instance(new OutputManager());
+        return instance;
+    }
+
     /**
         @brief Returns the only existing instance of the OutputManager singleton.
@@ -66 +73 @@
     /*static*/ OutputManager& OutputManager::getInstance()
     {
-        static OutputManager instance;
-        return instance;
+        return *OutputManager::Testing::getInstancePointer();
     }
 

code/branches/testing/src/libraries/util/output/OutputManager.h

@@ -65 +65 @@
     {
         public:
+            OutputManager();
+            OutputManager(const OutputManager&);
+            virtual ~OutputManager();
+
             static OutputManager& getInstance();
             static OutputManager& getInstanceAndCreateListeners();
@@ -70 +74 @@
             void pushMessage(OutputLevel level, const OutputContextContainer& context, const std::string& message);
 
-            void registerListener(OutputListener* listener);
-            void unregisterListener(OutputListener* listener);
+            virtual void registerListener(OutputListener* listener);
+            virtual void unregisterListener(OutputListener* listener);
 
             virtual void updatedLevelMask(const OutputListener* listener)
@@ -103 +107 @@
 
         private:
-            OutputManager();
-            OutputManager(const OutputManager&);
-            ~OutputManager();
-
             void updateMasks();
             void updateCombinedLevelMask();
@@ -121 +121 @@
             std::map<std::string, OutputContextContainer> contextContainers_;   ///< Contains all contexts including sub-contexts and their containers
             OutputContextSubID subcontextCounter_;                              ///< Counts the number of sub-contexts (and generates their IDs)
+
+        public:
+            struct _UtilExport Testing
+            {
+                static SharedPtr<OutputManager>& getInstancePointer();
+            };
     };
 }

code/branches/testing/test/util/OutputTest.cc

@@ -12 +12 @@
     }
 
-    TEST(Output, CanUseOrxout)
+    TEST(OutputTest, CanUseOrxout)
     {
         orxout() << "test" << endl;
     }
 
-    TEST(Output, OrxoutUsesCorrectOutputLevel)
+    TEST(OutputTest, OrxoutUsesCorrectOutputLevel)
     {
         {
@@ -30 +30 @@
     }
 
-    TEST(Output, OrxoutUsesCorrectOutputContext)
+    TEST(OutputTest, OrxoutUsesCorrectOutputContext)
     {
         const OutputStream& stream = orxout(verbose, context::unittest());
@@ -39 +39 @@
     }
 
-    TEST(Output, OrxoutAcceptsFunctionPointer)
+    TEST(OutputTest, OrxoutAcceptsFunctionPointer)
     {
         const OutputStream& stream = orxout(verbose, context::unittest);

code/branches/testing/test/util/output/OutputDefinitionsTest.cc

@@ -4 +4 @@
 namespace orxonox
 {
-    TEST(OutputDefinitions, Levels)
+    TEST(OutputDefinitionsTest, Levels)
     {
         EXPECT_EQ(0x0000, level::none);

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

@@ -2 +2 @@
 #include <gmock/gmock.h>
 #include "util/output/OutputListener.h"
+#include "util/output/OutputManager.h"
+#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -20 +22 @@
         {
             public:
+                MockOutputListener(bool bRegister = true) : OutputListener(bRegister) {}
+
                 MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
+
+                inline const std::vector<AdditionalContextListener*>& getListeners() const
+                    { return OutputListener::getListeners(); }
         };
+
+        class MockAdditionalContextListener : public AdditionalContextListener
+        {
+            public:
+                MOCK_METHOD1(updatedLevelMask, void(const OutputListener*));
+                MOCK_METHOD1(updatedAdditionalContextsLevelMask, void(const OutputListener*));
+                MOCK_METHOD1(updatedAdditionalContextsMask, void(const OutputListener*));
+        };
+
+        class MockOutputManager : public OutputManager
+        {
+            public:
+                MOCK_METHOD1(registerListener, void(OutputListener*));
+                MOCK_METHOD1(unregisterListener, void(OutputListener*));
+        };
     }
 
     // test default settings
-    TEST(OutputListener, DefaultConstructorAcceptsNothing)
+    TEST(OutputListenerTest, DefaultConstructorAcceptsNothing)
     {
         MockOutputListener listener;
@@ -35 +57 @@
 
     // test setLevelMax
-    TEST(OutputListener, TestSetLevelMax)
+    TEST(OutputListenerTest, SetLevelMax)
     {
         MockOutputListener listener;
@@ -52 +74 @@
 
     // test setLevelRange
-    TEST(OutputListener, TestSetLevelRange)
+    TEST(OutputListenerTest, SetLevelRange)
     {
         MockOutputListener listener;
@@ -69 +91 @@
 
     // test setLevelMask
-    TEST(OutputListener, TestSetLevelMask)
+    TEST(OutputListenerTest, SetLevelMask)
     {
         MockOutputListener listener;
@@ -86 +108 @@
 
     // test setAdditionalContextsLevelMax
-    TEST(OutputListener, TestSetAdditionalContextsLevelMax)
+    TEST(OutputListenerTest, SetAdditionalContextsLevelMax)
     {
         MockOutputListener listener;
@@ -103 +125 @@
 
     // test setAdditionalContextsLevelRange
-    TEST(OutputListener, TestSetAdditionalContextsLevelRange)
+    TEST(OutputListenerTest, SetAdditionalContextsLevelRange)
     {
         MockOutputListener listener;
@@ -120 +142 @@
 
     // test setAdditionalContextsLevelMask
-    TEST(OutputListener, TestSetAdditionalContextsLevelMask)
+    TEST(OutputListenerTest, SetAdditionalContextsLevelMask)
     {
         MockOutputListener listener;
@@ -137 +159 @@
 
     // test setAdditionalContextsMask
-    TEST(OutputListener, TestSetAdditionalContextsMask)
+    TEST(OutputListenerTest, SetAdditionalContextsMask)
     {
         MockOutputListener listener;
@@ -150 +172 @@
     }
 
-    // test setAdditionalContextsLevelMask calls OutputManager::updateCombinedAdditionalContextsLevelMask
-    // test setAdditionalContextsMask calls OutputManager::updateCombinedAdditionalContextsMask
+    // test registerListener
+    TEST(OutputListenerTest, RegisterListener)
+    {
+        MockOutputListener outputListener(false);
+        MockAdditionalContextListener additionalContextListener;
+
+        EXPECT_EQ(0u, outputListener.getListeners().size());
+        outputListener.registerListener(&additionalContextListener);
+        EXPECT_EQ(1u, outputListener.getListeners().size());
+        EXPECT_EQ(&additionalContextListener, outputListener.getListeners()[0]);
+    }
+
+    // test unregisterListener
+    TEST(OutputListenerTest, UnregisterListener)
+    {
+        MockOutputListener outputListener(false);
+        MockAdditionalContextListener additionalContextListener;
+
+        outputListener.registerListener(&additionalContextListener);
+        EXPECT_EQ(1u, outputListener.getListeners().size());
+        EXPECT_EQ(&additionalContextListener, outputListener.getListeners()[0]);
+
+        outputListener.unregisterListener(&additionalContextListener);
+        EXPECT_EQ(0u, outputListener.getListeners().size());
+    }
+
+    // test setLevelMask calls OutputManager::updatedLevelMask
+    TEST(OutputListenerTest, SetLevelMaskCallsListeners)
+    {
+        MockOutputListener listener;
+        MockAdditionalContextListener additionalContextListener;
+        listener.registerListener(&additionalContextListener);
+
+        EXPECT_CALL(additionalContextListener, updatedLevelMask(&listener)).Times(1);
+
+        listener.setLevelMask(level::debug_output);
+    }
+
+    // test setAdditionalContextsLevelMask calls OutputManager::updatedAdditionalContextsLevelMask
+    TEST(OutputListenerTest, SetAdditionalContextsLevelMaskCallsListeners)
+    {
+        MockOutputListener listener;
+        MockAdditionalContextListener additionalContextListener;
+        listener.registerListener(&additionalContextListener);
+
+        EXPECT_CALL(additionalContextListener, updatedAdditionalContextsLevelMask(&listener)).Times(1);
+
+        listener.setAdditionalContextsLevelMask(level::debug_output);
+    }
+
+    // test setAdditionalContextsMask calls OutputManager::updatedAdditionalContextsMask
+    TEST(OutputListenerTest, SetAdditionalContextsMaskCallsListeners)
+    {
+        MockOutputListener listener;
+        MockAdditionalContextListener additionalContextListener;
+        listener.registerListener(&additionalContextListener);
+
+        EXPECT_CALL(additionalContextListener, updatedAdditionalContextsMask(&listener)).Times(1);
+
+        listener.setAdditionalContextsMask(context::unittest1().mask);
+    }
 
     // test acceptsOutput
     // test unfilteredOutput
+
+    // Fixture
+    class OutputListenerTestWithMockedOutputManager : public ::testing::Test
+    {
+        public:
+            virtual void SetUp()
+            {
+                this->manager_ = new MockOutputManager();
+                OutputManager::Testing::getInstancePointer() = this->manager_;
+            }
+
+            virtual void TearDown()
+            {
+                OutputManager::Testing::getInstancePointer() = new OutputManager();
+            }
+
+        protected:
+            MockOutputManager* manager_;
+    };
+
+    // test default-constructor calls OutputManager::registerListener
+    TEST_F(OutputListenerTestWithMockedOutputManager, ConstructorRegistersInOutputManager)
+    {
+        EXPECT_CALL(*this->manager_, registerListener(::testing::_)).Times(1);
+        MockOutputListener listener;
+    }
+
+    // test prevent constructor from calling OutputManager::registerListener
+    TEST_F(OutputListenerTestWithMockedOutputManager, PreventRegisteringInOutputManager)
+    {
+        EXPECT_CALL(*this->manager_, registerListener(::testing::_)).Times(0);
+        MockOutputListener listener(false);
+    }
+
+    // test destructor calls OutputManager::unregisterListener
+    TEST_F(OutputListenerTestWithMockedOutputManager, DestructorUnregistersFromOutputManager)
+    {
+        MockOutputListener listener;
+        EXPECT_CALL(*this->manager_, unregisterListener(::testing::_)).Times(1);
+    }
 }