Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 10, 2013, 7:22:59 PM (12 years ago)
Author:
landauf
Message:

added tests for OutputManager

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/testing/test/util/output/OutputManagerTest.cc

    r9529 r9543  
    11#include <gtest/gtest.h>
     2#include <gmock/gmock.h>
     3
     4#define DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
     5
    26#include "util/Output.h"
     7#include "util/output/OutputManager.h"
     8#include "util/output/OutputListener.h"
    39
    410namespace orxonox
    511{
     12    namespace context
     13    {
     14        namespace
     15        {
     16            REGISTER_OUTPUT_CONTEXT(unittest1);
     17            REGISTER_OUTPUT_CONTEXT(unittest2);
     18            REGISTER_OUTPUT_CONTEXT(unittest3);
     19
     20            REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
     21            REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
     22            REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
     23        }
     24    }
     25
     26    namespace
     27    {
     28        class MockOutputManager : public OutputManager
     29        {
     30            public:
     31                MOCK_METHOD1(updatedLevelMask, void(const OutputListener*));
     32                MOCK_METHOD1(updatedAdditionalContextsLevelMask, void(const OutputListener*));
     33                MOCK_METHOD1(updatedAdditionalContextsMask, void(const OutputListener*));
     34
     35                void originalUpdatedLevelMask(const OutputListener* listener) { this->OutputManager::updatedLevelMask(listener); }
     36                void originalUpdatedAdditionalContextsLevelMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsLevelMask(listener); }
     37                void originalUpdatedAdditionalContextsMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsMask(listener); }
     38        };
     39
     40        class MockOutputListener : public OutputListener
     41        {
     42            public:
     43                MockOutputListener(bool bRegister = true) : OutputListener(bRegister) {}
     44
     45                MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
     46                MOCK_METHOD3(unfilteredOutput, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
     47
     48                inline const std::vector<AdditionalContextListener*>& getListeners() const
     49                    { return OutputListener::getListeners(); }
     50        };
     51    }
     52
     53    // test getInstance does not create listeners
     54    TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
     55    {
     56        EXPECT_TRUE(NULL == &OutputManager::getInstance().getMemoryWriter());
     57        EXPECT_TRUE(NULL == &OutputManager::getInstance().getConsoleWriter());
     58        EXPECT_TRUE(NULL == &OutputManager::getInstance().getLogWriter());
     59    }
     60
     61    // test getInstanceAndCreateListeners creates listeners
     62    TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
     63    {
     64        EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
     65        EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
     66        EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getLogWriter());
     67    }
     68
     69    // test getInstanceAndCreateListeners called again does not re-create listeners
     70    TEST(OutputManagerTest, GetInstanceAndCreateListenersDoesNotCreateDefaultListenersTwice)
     71    {
     72        MemoryWriter* memoryWriter = &OutputManager::getInstanceAndCreateListeners().getMemoryWriter();
     73        ConsoleWriter* consoleWriter = &OutputManager::getInstanceAndCreateListeners().getConsoleWriter();
     74        LogWriter* logWriter = &OutputManager::getInstanceAndCreateListeners().getLogWriter();
     75
     76        EXPECT_TRUE(memoryWriter == &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
     77        EXPECT_TRUE(consoleWriter == &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
     78        EXPECT_TRUE(logWriter == &OutputManager::getInstanceAndCreateListeners().getLogWriter());
     79    }
     80
     81    // test constructor
     82    TEST(OutputManagerTest, MasksAreZeroAfterConstruction)
     83    {
     84        OutputManager manager;
     85        EXPECT_EQ(0u, manager.getCombinedLevelMask());
     86        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
     87        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
     88    }
     89
     90    // test registerListener adds listener to list
     91    TEST(OutputManagerTest, RegisterListenerAddsListenerToList)
     92    {
     93        OutputManager manager;
     94        MockOutputListener listener;
     95        EXPECT_TRUE(manager.getListeners().empty());
     96
     97        manager.registerListener(&listener);
     98
     99        EXPECT_FALSE(manager.getListeners().empty());
     100    }
     101
     102    // test unregisterListener removes listener from list
     103    TEST(OutputManagerTest, UnregisterListenerRemovesListenerFromList)
     104    {
     105        OutputManager manager;
     106        MockOutputListener listener;
     107        manager.registerListener(&listener);
     108        EXPECT_FALSE(manager.getListeners().empty());
     109
     110        manager.unregisterListener(&listener);
     111
     112        EXPECT_TRUE(manager.getListeners().empty());
     113    }
     114
     115    // test registerListener registers manager at listener
     116    TEST(OutputManagerTest, RegisterListenerRegistersManagerAtListener)
     117    {
     118        OutputManager manager;
     119        MockOutputListener listener(false);
     120        EXPECT_TRUE(listener.getListeners().empty());
     121
     122        manager.registerListener(&listener);
     123
     124        EXPECT_FALSE(listener.getListeners().empty());
     125    }
     126
     127    // test unregisterListener unregisters manager from listener
     128    TEST(OutputManagerTest, UnregisterListenerRemovesManagerFromListener)
     129    {
     130        OutputManager manager;
     131        MockOutputListener listener(false);
     132        manager.registerListener(&listener);
     133        EXPECT_FALSE(listener.getListeners().empty());
     134
     135        manager.unregisterListener(&listener);
     136
     137        EXPECT_TRUE(listener.getListeners().empty());
     138    }
     139
     140    // test registerListener adjusts masks
     141    TEST(OutputManagerTest, RegisterListenerAdjustsMasks)
     142    {
     143        OutputManager manager;
     144        EXPECT_EQ(0u, manager.getCombinedLevelMask());
     145        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
     146        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
     147
     148        MockOutputListener listener;
     149        listener.setLevelMask(level::internal_warning);
     150        listener.setAdditionalContextsLevelMask(level::verbose_more);
     151        listener.setAdditionalContextsMask(context::unittest2().mask);
     152
     153        manager.registerListener(&listener);
     154
     155        EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
     156        EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
     157        EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
     158    }
     159
     160    // test unregisterListener adjusts masks
     161    TEST(OutputManagerTest, UnregisterListenerAdjustsMasks)
     162    {
     163        OutputManager manager;
     164        MockOutputListener listener;
     165        listener.setLevelMask(level::internal_warning);
     166        listener.setAdditionalContextsLevelMask(level::verbose_more);
     167        listener.setAdditionalContextsMask(context::unittest2().mask);
     168
     169        manager.registerListener(&listener);
     170
     171        EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
     172        EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
     173        EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
     174
     175        manager.unregisterListener(&listener);
     176
     177        EXPECT_EQ(0u, manager.getCombinedLevelMask());
     178        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
     179        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
     180    }
     181
     182    // test updatedLevelMask updates mask
     183    TEST(OutputManagerTest, UpdatedLevelMask)
     184    {
     185        MockOutputManager manager;
     186        MockOutputListener listener;
     187        manager.registerListener(&listener);
     188
     189        EXPECT_EQ(0u, manager.getCombinedLevelMask());
     190        EXPECT_CALL(manager, updatedLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedLevelMask));
     191
     192        listener.setLevelMask(level::internal_warning);
     193
     194        EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
     195    }
     196
     197    // test updatedAdditionalContextsLevelMask updates mask
     198    TEST(OutputManagerTest, UpdatedAdditionalContextsLevelMask)
     199    {
     200        MockOutputManager manager;
     201        MockOutputListener listener;
     202        manager.registerListener(&listener);
     203
     204        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
     205        EXPECT_CALL(manager, updatedAdditionalContextsLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsLevelMask));
     206
     207        listener.setAdditionalContextsLevelMask(level::internal_warning);
     208
     209        EXPECT_EQ(level::internal_warning, manager.getCombinedAdditionalContextsLevelMask());
     210    }
     211
     212    // test updatedAdditionalContextsMask updates mask
     213    TEST(OutputManagerTest, UpdatedAdditionalContextsMask)
     214    {
     215        MockOutputManager manager;
     216        MockOutputListener listener;
     217        manager.registerListener(&listener);
     218
     219        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
     220        EXPECT_CALL(manager, updatedAdditionalContextsMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsMask));
     221
     222        listener.setAdditionalContextsMask(context::unittest2().mask);
     223
     224        EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
     225    }
     226
     227    // test combines masks of all listeners
     228    TEST(OutputManagerTest, CombinesMasksOfAllListeners)
     229    {
     230        OutputManager manager;
     231        EXPECT_EQ(0u, manager.getCombinedLevelMask());
     232        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
     233        EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
     234
     235        MockOutputListener listener1;
     236        listener1.setLevelMask(level::user_error);
     237        listener1.setAdditionalContextsLevelMask(level::verbose);
     238        listener1.setAdditionalContextsMask(context::unittest1().mask);
     239        manager.registerListener(&listener1);
     240
     241        MockOutputListener listener2;
     242        listener2.setLevelMask(level::user_warning);
     243        listener2.setAdditionalContextsLevelMask(level::verbose_more);
     244        listener2.setAdditionalContextsMask(context::unittest2().mask);
     245        manager.registerListener(&listener2);
     246
     247        MockOutputListener listener3;
     248        listener3.setLevelMask(level::internal_warning);
     249        listener3.setAdditionalContextsLevelMask(level::verbose_ultra);
     250        listener3.setAdditionalContextsMask(context::unittest3().mask);
     251        manager.registerListener(&listener3);
     252
     253        EXPECT_EQ(level::user_error | level::user_warning | level::internal_warning, manager.getCombinedLevelMask());
     254        EXPECT_EQ(level::verbose | level::verbose_more | level::verbose_ultra, manager.getCombinedAdditionalContextsLevelMask());
     255        EXPECT_EQ(context::unittest1().mask | context::unittest2().mask | context::unittest3().mask, manager.getCombinedAdditionalContextsMask());
     256    }
     257
     258    // test acceptsOutput
     259    TEST(OutputManagerTest, AcceptsOutput)
     260    {
     261        OutputManager manager;
     262        MockOutputListener listener;
     263        listener.setLevelMask(level::internal_warning);
     264        listener.setAdditionalContextsLevelMask(level::verbose_more);
     265        listener.setAdditionalContextsMask(context::unittest2().mask);
     266
     267        manager.registerListener(&listener);
     268
     269        EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::undefined()));
     270        EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::undefined()));
     271        EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::undefined()));
     272        EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::undefined()));
     273        EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::undefined()));
     274        EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::undefined()));
     275
     276        EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest1()));
     277        EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest1()));
     278        EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest1()));
     279        EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest1()));
     280        EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::unittest1()));
     281        EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest1()));
     282
     283        EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest2()));
     284        EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest2()));
     285        EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest2()));
     286        EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest2()));
     287        EXPECT_TRUE(manager.acceptsOutput(level::verbose_more, context::unittest2()));
     288        EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest2()));
     289    }
     290
     291    // test pushMessage sends lines to listeners
     292    TEST(OutputManagerTest, PushMessageSendsLinesToListeners)
     293    {
     294        OutputManager manager;
     295        MockOutputListener listener;
     296        manager.registerListener(&listener);
     297
     298        std::vector<std::string> lines;
     299        lines.push_back("some output");
     300
     301        EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
     302
     303        manager.pushMessage(level::user_status, context::unittest1(), "some output");
     304    }
     305
     306    // test pushMessage splits lines by \n
     307    TEST(OutputManagerTest, PushMessageSplitsTextAtNewlineChar)
     308    {
     309        OutputManager manager;
     310        MockOutputListener listener;
     311        manager.registerListener(&listener);
     312
     313        std::vector<std::string> lines;
     314        lines.push_back("some output");
     315        lines.push_back("and some more output");
     316        lines.push_back("!!!");
     317
     318        EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
     319
     320        manager.pushMessage(level::user_status, context::unittest1(), "some output\nand some more output\n!!!");
     321    }
     322
     323    // test registerContext for new context
     324    TEST(OutputManagerTest, RegisterNewContext)
     325    {
     326        OutputManager manager;
     327        OutputContextContainer container = manager.registerContext("whatever");
     328        EXPECT_EQ("whatever", container.name);
     329        EXPECT_EQ(0, container.sub_id);
     330    }
     331
     332    // test registerContext for existing context
     333    TEST(OutputManagerTest, RegisterContextTwice)
     334    {
     335        OutputManager manager;
     336        OutputContextContainer container1 = manager.registerContext("whatever");
     337        OutputContextContainer container2 = manager.registerContext("whatever");
     338        EXPECT_EQ("whatever", container1.name);
     339        EXPECT_EQ(0, container1.sub_id);
     340        EXPECT_EQ(container1, container2);
     341    }
     342
     343    // test registerContext for multiple contexts
     344    TEST(OutputManagerTest, RegisterMultipleContexts)
     345    {
     346        OutputManager manager;
     347        OutputContextContainer container1 = manager.registerContext("whatever");
     348        OutputContextContainer container2 = manager.registerContext("asdf");
     349        EXPECT_EQ("whatever", container1.name);
     350        EXPECT_EQ(0, container1.sub_id);
     351        EXPECT_EQ("asdf", container2.name);
     352        EXPECT_EQ(0, container2.sub_id);
     353        EXPECT_NE(container1.mask, container2.mask);
     354    }
     355
     356    // test registerContext for new subcontext
     357    TEST(OutputManagerTest, RegisterNewSubcontext)
     358    {
     359        OutputManager manager;
     360        OutputContextContainer container = manager.registerContext("base", "subcontext");
     361        EXPECT_EQ("base::subcontext", container.name);
     362        EXPECT_NE(0, container.sub_id);
     363    }
     364
     365    // test registerContext for existing subcontext
     366    TEST(OutputManagerTest, RegisterSubcontextTwice)
     367    {
     368        OutputManager manager;
     369        OutputContextContainer container1 = manager.registerContext("base", "subcontext");
     370        OutputContextContainer container2 = manager.registerContext("base", "subcontext");
     371        EXPECT_EQ("base::subcontext", container1.name);
     372        EXPECT_NE(0, container1.sub_id);
     373        EXPECT_EQ(container1, container2);
     374    }
     375
     376    // test registerContext for multiple subcontexts
     377    TEST(OutputManagerTest, RegisterMultipleSubcontexts)
     378    {
     379        OutputManager manager;
     380        OutputContextContainer container1 = manager.registerContext("base", "subcontext");
     381        OutputContextContainer container2 = manager.registerContext("base", "meh");
     382        EXPECT_EQ("base::subcontext", container1.name);
     383        EXPECT_NE(0, container1.sub_id);
     384        EXPECT_EQ("base::meh", container2.name);
     385        EXPECT_NE(0, container2.sub_id);
     386        EXPECT_EQ(container1.mask, container2.mask);
     387        EXPECT_NE(container1.sub_id, container2.sub_id);
     388    }
     389
     390    // test subcontext has mask of base context
     391    TEST(OutputManagerTest, SubcontextHasMaskOfBaseContext)
     392    {
     393        OutputManager manager;
     394        OutputContextContainer container1 = manager.registerContext("base", "subcontext");
     395        EXPECT_EQ("base::subcontext", container1.name);
     396        EXPECT_NE(0, container1.sub_id);
     397
     398        OutputContextContainer container2 = manager.registerContext("base");
     399        EXPECT_EQ("base", container2.name);
     400        EXPECT_EQ(0, container2.sub_id);
     401
     402        EXPECT_EQ(container1.mask, container2.mask);
     403    }
     404
     405    // test getLevelName
     406    TEST(OutputManagerTest, GetLevelName)
     407    {
     408        OutputManager manager;
     409        EXPECT_EQ("Debug", manager.getLevelName(level::debug_output));
     410        EXPECT_EQ("Error", manager.getLevelName(level::user_error));
     411        EXPECT_EQ("Status", manager.getLevelName(level::user_status));
     412        EXPECT_EQ("Warning (internal)", manager.getLevelName(level::internal_warning));
     413        EXPECT_EQ("Info (internal)", manager.getLevelName(level::internal_info));
     414        EXPECT_EQ("Verbose", manager.getLevelName(level::verbose));
     415    }
     416
     417    // test getDefaultPrefix for undefined context
     418    TEST(OutputManagerTest, GetDefaultPrefixWithoutContext)
     419    {
     420        OutputManager manager;
     421        std::string prefix = manager.getDefaultPrefix(level::debug_output, context::undefined());
     422        EXPECT_EQ(manager.getLevelName(level::debug_output) + ": ", prefix);
     423    }
     424
     425    // test getDefaultPrefix for regular context
     426    TEST(OutputManagerTest, GetDefaultPrefixWithContext)
     427    {
     428        OutputManager manager;
     429        std::string prefix = manager.getDefaultPrefix(level::debug_output, context::unittest1());
     430        EXPECT_EQ(manager.getLevelName(level::debug_output) + ": [unittest1] ", prefix);
     431    }
    6432}
Note: See TracChangeset for help on using the changeset viewer.