Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/test/util/output/OutputListenerTest.cc @ 10624

Last change on this file since 10624 was 9545, checked in by landauf, 11 years ago

eol-style native
  • Property svn:eol-style set to native
File size: 13.0 KB
Line 
1#include <gtest/gtest.h>
2#include <gmock/gmock.h>
3#include "util/output/OutputListener.h"
4#include "util/output/OutputManager.h"
5#include "util/SharedPtr.h"
6
7namespace orxonox
8{
9    namespace context
10    {
11        namespace
12        {
13            REGISTER_OUTPUT_CONTEXT(unittest1);
14            REGISTER_OUTPUT_CONTEXT(unittest2);
15            REGISTER_OUTPUT_CONTEXT(unittest3);
16        }
17    }
18
19    namespace
20    {
21        class MockOutputListener : public OutputListener
22        {
23            public:
24                MockOutputListener(bool bRegister = true) : OutputListener(bRegister) {}
25
26                MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
27
28                inline const std::vector<AdditionalContextListener*>& getListeners() const
29                    { return OutputListener::getListeners(); }
30        };
31
32        class MockAdditionalContextListener : public AdditionalContextListener
33        {
34            public:
35                MOCK_METHOD1(updatedLevelMask, void(const OutputListener*));
36                MOCK_METHOD1(updatedAdditionalContextsLevelMask, void(const OutputListener*));
37                MOCK_METHOD1(updatedAdditionalContextsMask, void(const OutputListener*));
38        };
39
40        class MockOutputManager : public OutputManager
41        {
42            public:
43                MOCK_METHOD1(registerListener, void(OutputListener*));
44                MOCK_METHOD1(unregisterListener, void(OutputListener*));
45        };
46    }
47
48    // test default settings
49    TEST(OutputListenerTest, DefaultConstructorAcceptsNothing)
50    {
51        MockOutputListener listener;
52
53        EXPECT_EQ(level::none, listener.getLevelMask());
54        EXPECT_EQ(level::none, listener.getAdditionalContextsLevelMask());
55        EXPECT_EQ(context::none, listener.getAdditionalContextsMask());
56    }
57
58    // test setLevelMax
59    TEST(OutputListenerTest, SetLevelMax)
60    {
61        MockOutputListener listener;
62
63        listener.setLevelMax(level::user_warning);
64
65        OutputLevel mask = listener.getLevelMask();
66
67        EXPECT_FALSE(mask & level::none);
68        EXPECT_TRUE(mask & level::message);
69        EXPECT_TRUE(mask & level::debug_output);
70        EXPECT_TRUE(mask & level::user_error);
71        EXPECT_TRUE(mask & level::user_warning);
72        EXPECT_FALSE(mask & level::user_status);
73    }
74
75    // test setLevelRange
76    TEST(OutputListenerTest, SetLevelRange)
77    {
78        MockOutputListener listener;
79
80        listener.setLevelRange(level::debug_output, level::user_warning);
81
82        OutputLevel mask = listener.getLevelMask();
83
84        EXPECT_FALSE(mask & level::none);
85        EXPECT_FALSE(mask & level::message);
86        EXPECT_TRUE(mask & level::debug_output);
87        EXPECT_TRUE(mask & level::user_error);
88        EXPECT_TRUE(mask & level::user_warning);
89        EXPECT_FALSE(mask & level::user_status);
90    }
91
92    // test setLevelMask
93    TEST(OutputListenerTest, SetLevelMask)
94    {
95        MockOutputListener listener;
96
97        listener.setLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
98
99        OutputLevel mask = listener.getLevelMask();
100
101        EXPECT_FALSE(mask & level::none);
102        EXPECT_FALSE(mask & level::message);
103        EXPECT_TRUE(mask & level::debug_output);
104        EXPECT_FALSE(mask & level::user_error);
105        EXPECT_TRUE(mask & level::user_warning);
106        EXPECT_FALSE(mask & level::user_status);
107    }
108
109    // test setAdditionalContextsLevelMax
110    TEST(OutputListenerTest, SetAdditionalContextsLevelMax)
111    {
112        MockOutputListener listener;
113
114        listener.setAdditionalContextsLevelMax(level::user_warning);
115
116        OutputLevel mask = listener.getAdditionalContextsLevelMask();
117
118        EXPECT_FALSE(mask & level::none);
119        EXPECT_TRUE(mask & level::message);
120        EXPECT_TRUE(mask & level::debug_output);
121        EXPECT_TRUE(mask & level::user_error);
122        EXPECT_TRUE(mask & level::user_warning);
123        EXPECT_FALSE(mask & level::user_status);
124    }
125
126    // test setAdditionalContextsLevelRange
127    TEST(OutputListenerTest, SetAdditionalContextsLevelRange)
128    {
129        MockOutputListener listener;
130
131        listener.setAdditionalContextsLevelRange(level::debug_output, level::user_warning);
132
133        OutputLevel mask = listener.getAdditionalContextsLevelMask();
134
135        EXPECT_FALSE(mask & level::none);
136        EXPECT_FALSE(mask & level::message);
137        EXPECT_TRUE(mask & level::debug_output);
138        EXPECT_TRUE(mask & level::user_error);
139        EXPECT_TRUE(mask & level::user_warning);
140        EXPECT_FALSE(mask & level::user_status);
141    }
142
143    // test setAdditionalContextsLevelMask
144    TEST(OutputListenerTest, SetAdditionalContextsLevelMask)
145    {
146        MockOutputListener listener;
147
148        listener.setAdditionalContextsLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
149
150        OutputLevel mask = listener.getAdditionalContextsLevelMask();
151
152        EXPECT_FALSE(mask & level::none);
153        EXPECT_FALSE(mask & level::message);
154        EXPECT_TRUE(mask & level::debug_output);
155        EXPECT_FALSE(mask & level::user_error);
156        EXPECT_TRUE(mask & level::user_warning);
157        EXPECT_FALSE(mask & level::user_status);
158    }
159
160    // test setAdditionalContextsMask
161    TEST(OutputListenerTest, SetAdditionalContextsMask)
162    {
163        MockOutputListener listener;
164
165        listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest3().mask);
166
167        OutputContextMask mask = listener.getAdditionalContextsMask();
168
169        EXPECT_TRUE(mask & context::unittest1().mask);
170        EXPECT_FALSE(mask & context::unittest2().mask);
171        EXPECT_TRUE(mask & context::unittest3().mask);
172    }
173
174    // test registerListener
175    TEST(OutputListenerTest, RegisterListener)
176    {
177        MockOutputListener outputListener(false);
178        MockAdditionalContextListener additionalContextListener;
179
180        EXPECT_EQ(0u, outputListener.getListeners().size());
181        outputListener.registerListener(&additionalContextListener);
182        EXPECT_EQ(1u, outputListener.getListeners().size());
183        EXPECT_EQ(&additionalContextListener, outputListener.getListeners()[0]);
184    }
185
186    // test unregisterListener
187    TEST(OutputListenerTest, UnregisterListener)
188    {
189        MockOutputListener outputListener(false);
190        MockAdditionalContextListener additionalContextListener;
191
192        outputListener.registerListener(&additionalContextListener);
193        EXPECT_EQ(1u, outputListener.getListeners().size());
194        EXPECT_EQ(&additionalContextListener, outputListener.getListeners()[0]);
195
196        outputListener.unregisterListener(&additionalContextListener);
197        EXPECT_EQ(0u, outputListener.getListeners().size());
198    }
199
200    // test setLevelMask calls OutputManager::updatedLevelMask
201    TEST(OutputListenerTest, SetLevelMaskCallsListeners)
202    {
203        MockOutputListener listener;
204        MockAdditionalContextListener additionalContextListener;
205        listener.registerListener(&additionalContextListener);
206
207        EXPECT_CALL(additionalContextListener, updatedLevelMask(&listener)).Times(1);
208
209        listener.setLevelMask(level::debug_output);
210    }
211
212    // test setAdditionalContextsLevelMask calls OutputManager::updatedAdditionalContextsLevelMask
213    TEST(OutputListenerTest, SetAdditionalContextsLevelMaskCallsListeners)
214    {
215        MockOutputListener listener;
216        MockAdditionalContextListener additionalContextListener;
217        listener.registerListener(&additionalContextListener);
218
219        EXPECT_CALL(additionalContextListener, updatedAdditionalContextsLevelMask(&listener)).Times(1);
220
221        listener.setAdditionalContextsLevelMask(level::debug_output);
222    }
223
224    // test setAdditionalContextsMask calls OutputManager::updatedAdditionalContextsMask
225    TEST(OutputListenerTest, SetAdditionalContextsMaskCallsListeners)
226    {
227        MockOutputListener listener;
228        MockAdditionalContextListener additionalContextListener;
229        listener.registerListener(&additionalContextListener);
230
231        EXPECT_CALL(additionalContextListener, updatedAdditionalContextsMask(&listener)).Times(1);
232
233        listener.setAdditionalContextsMask(context::unittest1().mask);
234    }
235
236    // test acceptsOutput
237    namespace
238    {
239        void testContext(const OutputListener& listener, const OutputContextContainer& context, bool accepted)
240        {
241            EXPECT_TRUE(listener.acceptsOutput(level::message, context));
242            EXPECT_TRUE(listener.acceptsOutput(level::user_error, context));
243            EXPECT_TRUE(listener.acceptsOutput(level::user_warning, context));
244
245            if (accepted)
246            {
247                EXPECT_TRUE(listener.acceptsOutput(level::user_status, context));
248                EXPECT_TRUE(listener.acceptsOutput(level::internal_error, context));
249                EXPECT_TRUE(listener.acceptsOutput(level::internal_info, context));
250            }
251            else
252            {
253                EXPECT_FALSE(listener.acceptsOutput(level::user_status, context));
254                EXPECT_FALSE(listener.acceptsOutput(level::internal_error, context));
255                EXPECT_FALSE(listener.acceptsOutput(level::internal_info, context));
256            }
257
258            EXPECT_FALSE(listener.acceptsOutput(level::verbose, context));
259            EXPECT_FALSE(listener.acceptsOutput(level::verbose_ultra, context));
260        }
261    }
262
263    TEST(OutputListenerTest, AcceptsOutputNoAdditionalContext)
264    {
265        MockOutputListener listener;
266
267        listener.setLevelMax(level::user_warning);
268
269        testContext(listener, context::undefined(), false);
270        testContext(listener, context::unittest1(), false);
271        testContext(listener, context::unittest2(), false);
272    }
273
274    TEST(OutputListenerTest, AcceptsOutputWithAdditionalContext)
275    {
276        MockOutputListener listener;
277
278        listener.setLevelMax(level::user_warning);
279        listener.setAdditionalContextsMask(context::unittest1().mask);
280        listener.setAdditionalContextsLevelMax(level::internal_info);
281
282        testContext(listener, context::undefined(), false);
283        testContext(listener, context::unittest1(), true);
284        testContext(listener, context::unittest2(), false);
285    }
286
287    TEST(OutputListenerTest, AcceptsOutputWithTwoAdditionalContexts)
288    {
289        MockOutputListener listener;
290
291        listener.setLevelMax(level::user_warning);
292
293        listener.setLevelMax(level::user_warning);
294        listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
295        listener.setAdditionalContextsLevelMax(level::internal_info);
296
297        testContext(listener, context::undefined(), false);
298        testContext(listener, context::unittest1(), true);
299        testContext(listener, context::unittest2(), true);
300    }
301
302    // test unfilteredOutput
303    TEST(OutputListenerTest, UnfilteredOutputCallsOutputIfOutputAccepted)
304    {
305        MockOutputListener listener;
306
307        listener.setLevelMax(level::user_warning);
308
309        const OutputLevel& level = level::message;
310        const OutputContextContainer& context = context::undefined();
311
312        EXPECT_TRUE(listener.acceptsOutput(level, context));
313
314        std::vector<std::string> lines;
315        EXPECT_CALL(listener, output(level, context, lines)).Times(1);
316
317        listener.unfilteredOutput(level, context, lines);
318    }
319
320    TEST(OutputListenerTest, UnfilteredOutputDoesNotCallOutputIfOutputNotAccepted)
321    {
322        MockOutputListener listener;
323
324        listener.setLevelMax(level::user_warning);
325
326        const OutputLevel& level = level::verbose;
327        const OutputContextContainer& context = context::undefined();
328
329        EXPECT_FALSE(listener.acceptsOutput(level, context));
330
331        std::vector<std::string> lines;
332        EXPECT_CALL(listener, output(level, context, lines)).Times(0);
333
334        listener.unfilteredOutput(level, context, lines);
335    }
336
337    // Fixture
338    class OutputListenerTestWithMockedOutputManager : public ::testing::Test
339    {
340        public:
341            virtual void SetUp()
342            {
343                this->manager_ = new MockOutputManager();
344                OutputManager::Testing::getInstancePointer() = this->manager_;
345            }
346
347            virtual void TearDown()
348            {
349                OutputManager::Testing::getInstancePointer() = new OutputManager();
350            }
351
352        protected:
353            MockOutputManager* manager_;
354    };
355
356    // test default-constructor calls OutputManager::registerListener
357    TEST_F(OutputListenerTestWithMockedOutputManager, ConstructorRegistersInOutputManager)
358    {
359        EXPECT_CALL(*this->manager_, registerListener(::testing::_)).Times(1);
360        MockOutputListener listener;
361    }
362
363    // test prevent constructor from calling OutputManager::registerListener
364    TEST_F(OutputListenerTestWithMockedOutputManager, PreventRegisteringInOutputManager)
365    {
366        EXPECT_CALL(*this->manager_, registerListener(::testing::_)).Times(0);
367        MockOutputListener listener(false);
368    }
369
370    // test destructor calls OutputManager::unregisterListener
371    TEST_F(OutputListenerTestWithMockedOutputManager, DestructorUnregistersFromOutputManager)
372    {
373        MockOutputListener listener;
374        EXPECT_CALL(*this->manager_, unregisterListener(::testing::_)).Times(1);
375    }
376}
Note: See TracBrowser for help on using the repository browser.