[Orxonox-commit 4876] r9545 - in code/branches/testing/test/util: . output
landauf at orxonox.net
landauf at orxonox.net
Mon Mar 11 23:17:42 CET 2013
Author: landauf
Date: 2013-03-11 23:17:42 +0100 (Mon, 11 Mar 2013)
New Revision: 9545
Modified:
code/branches/testing/test/util/MultiTypeTest.cc
code/branches/testing/test/util/OutputTest.cc
code/branches/testing/test/util/output/BaseWriterTest.cc
code/branches/testing/test/util/output/ConsoleWriterTest.cc
code/branches/testing/test/util/output/LogWriterTest.cc
code/branches/testing/test/util/output/MemoryWriterTest.cc
code/branches/testing/test/util/output/OutputDefinitionsTest.cc
code/branches/testing/test/util/output/OutputListenerTest.cc
code/branches/testing/test/util/output/OutputManagerTest.cc
code/branches/testing/test/util/output/OutputStreamTest.cc
code/branches/testing/test/util/output/SubcontextOutputListenerTest.cc
Log:
eol-style native
Modified: code/branches/testing/test/util/MultiTypeTest.cc
===================================================================
--- code/branches/testing/test/util/MultiTypeTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/MultiTypeTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,698 +1,698 @@
-#include <gtest/gtest.h>
-#include "util/MultiType.h"
-
-namespace orxonox
-{
- // x constructor()
- // x constructor(value)
- // x constructor(other)
-
- // x assignment(value)
- // ? assignment(pointer)
- // x assignment(other)
-
- // x set(value)
- // ? set(pointer)
- // x force<type>(value)
-
- // x convert<type>()
- // x reset
- // x reset<type>()
- // x resetValue
-
- // x isType<type>()
-
- // x (type) conversion
- // ? (pointer class) conversion
- // x getValue(pointer)
- // x get<type>()
- // ? getPointer()
-
- // x lastConversionSuccessful()
- // x null()
-
- /////////////////////////
- // Default Constructor //
- /////////////////////////
- TEST(MultiType, DefaultConstructor)
- {
- MultiType mt;
- EXPECT_TRUE(mt.null());
- EXPECT_TRUE(mt.isType<void>());
- }
-
- /////////////////
- // Constructor //
- /////////////////
- TEST(MultiType, ValueChar) { char value = -100; MultiType mt(value); EXPECT_TRUE(mt.isType<char>()); EXPECT_EQ(-100, mt.get<char>()); }
- TEST(MultiType, ValueUnsignedChar) { unsigned char value = 255u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned char>()); EXPECT_EQ(255u, mt.get<unsigned char>()); }
- TEST(MultiType, ValueShort) { short value = -10000; MultiType mt(value); EXPECT_TRUE(mt.isType<short>()); EXPECT_EQ(-10000, mt.get<short>()); }
- TEST(MultiType, ValueUnsignedShort) { unsigned short value = 65535u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned short>()); EXPECT_EQ(65535u, mt.get<unsigned short>()); }
- TEST(MultiType, ValueInt) { int value = -1000000000; MultiType mt(value); EXPECT_TRUE(mt.isType<int>()); EXPECT_EQ(-1000000000, mt.get<int>()); }
- TEST(MultiType, ValueUnsignedInt) { unsigned int value = 4000000000u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned int>()); EXPECT_EQ(4000000000u, mt.get<unsigned int>()); }
- TEST(MultiType, ValueLong) { long value = -1000000000; MultiType mt(value); EXPECT_TRUE(mt.isType<long>()); EXPECT_EQ(-1000000000, mt.get<long>()); }
- TEST(MultiType, ValueUnsignedLong) { unsigned long value = 4000000000u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned long>()); EXPECT_EQ(4000000000u, mt.get<unsigned long>()); }
- TEST(MultiType, ValueLongLong) { long long value = -1000000000000000000L; MultiType mt(value); EXPECT_TRUE(mt.isType<long long>()); EXPECT_EQ(-1000000000000000000L, mt.get<long long>()); }
- TEST(MultiType, ValueUnsignedLongLong) { unsigned long long value = 4000000000000000000UL; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned long long>()); EXPECT_EQ(4000000000000000000UL, mt.get<unsigned long long>()); }
- TEST(MultiType, ValueFloat) { float value = 0.123456f; MultiType mt(value); EXPECT_TRUE(mt.isType<float>()); EXPECT_EQ(0.123456f, mt.get<float>()); }
- TEST(MultiType, ValueDouble) { double value = 0.123456789; MultiType mt(value); EXPECT_TRUE(mt.isType<double>()); EXPECT_EQ(0.123456789, mt.get<double>()); }
- TEST(MultiType, ValueLongDouble) { long double value = 0.123456789123456789; MultiType mt(value); EXPECT_TRUE(mt.isType<long double>()); EXPECT_EQ(0.123456789123456789, mt.get<long double>()); }
- TEST(MultiType, ValueBool) { bool value = true; MultiType mt(value); EXPECT_TRUE(mt.isType<bool>()); EXPECT_EQ(true, mt.get<bool>()); }
- TEST(MultiType, ValueVoidpointer) { int* pointer = new int; void* value = pointer; MultiType mt(value); EXPECT_TRUE(mt.isType<void*>()); EXPECT_EQ(value, mt.get<void*>()); delete pointer; }
- TEST(MultiType, ValueString) { std::string value = "Hello World"; MultiType mt(value); EXPECT_TRUE(mt.isType<std::string>()); EXPECT_EQ("Hello World", mt.get<std::string>()); }
- TEST(MultiType, ValueVector2) { Vector2 value = Vector2(11, 22); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector2>()); EXPECT_EQ(Vector2(11, 22), mt.get<Vector2>()); }
- TEST(MultiType, ValueVector3) { Vector3 value = Vector3(11, 22, 33); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector3>()); EXPECT_EQ(Vector3(11, 22, 33), mt.get<Vector3>()); }
- TEST(MultiType, ValueVector4) { Vector4 value = Vector4(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector4>()); EXPECT_EQ(Vector4(11, 22, 33, 44), mt.get<Vector4>()); }
- TEST(MultiType, ValueColourValue) { ColourValue value = ColourValue(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<ColourValue>()); EXPECT_EQ(ColourValue(11, 22, 33, 44), mt.get<ColourValue>()); }
- TEST(MultiType, ValueQuaternion) { Quaternion value = Quaternion(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<Quaternion>()); EXPECT_EQ(Quaternion(11, 22, 33, 44), mt.get<Quaternion>()); }
- TEST(MultiType, ValueRadian) { Radian value = Radian(0.123); MultiType mt(value); EXPECT_TRUE(mt.isType<Radian>()); EXPECT_EQ(Radian(0.123), mt.get<Radian>()); }
- TEST(MultiType, ValueDegree) { Degree value = Degree(123); MultiType mt(value); EXPECT_TRUE(mt.isType<Degree>()); EXPECT_EQ(Degree(123), mt.get<Degree>()); }
- TEST(MultiType, ValueMbool) { mbool value = mbool(true); MultiType mt(value); EXPECT_TRUE(mt.isType<bool>()); EXPECT_EQ(mbool(true), mt.get<bool>()); }
- TEST(MultiType, ValueCharPointer) { const char* value = "Hello World"; MultiType mt(value); EXPECT_TRUE(mt.isType<std::string>()); EXPECT_EQ("Hello World", mt.get<std::string>()); }
-
- //////////////////////
- // Copy-Constructor //
- //////////////////////
- TEST(MultiType, CopyConstructorEmpty)
- {
- MultiType mt1;
- MultiType mt2(mt1);
-
- EXPECT_TRUE(mt2.null());
- }
-
- TEST(MultiType, CopyConstructorFloat)
- {
- MultiType mt1(0.1234f);
- MultiType mt2(mt1);
-
- EXPECT_TRUE(mt2.isType<float>());
- EXPECT_EQ(0.1234f, mt2.get<float>());
- }
-
- //////////////////////
- // Assignment Value //
- //////////////////////
- TEST(MultiType, AssignmentIntToEmpty)
- {
- MultiType mt;
-
- EXPECT_TRUE(mt.null());
-
- mt = 55;
-
- EXPECT_FALSE(mt.null());
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(55, mt.get<int>());
- }
-
- TEST(MultiType, AssignmentFloatToInt)
- {
- MultiType mt(66);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(66, mt.get<int>());
-
- mt = 77.7f; // will be converted to int
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(77, mt.get<int>());
- EXPECT_EQ(77.0f, mt.get<float>());
- }
-
- TEST(MultiType, AssignmentFloatToFloat)
- {
- MultiType mt(66.6f);
-
- EXPECT_TRUE(mt.isType<float>());
- EXPECT_EQ(66, mt.get<int>());
- EXPECT_EQ(66.6f, mt.get<float>());
-
- mt = 77.7f;
-
- EXPECT_TRUE(mt.isType<float>());
- EXPECT_EQ(77, mt.get<int>());
- EXPECT_EQ(77.7f, mt.get<float>());
- }
-
- TEST(MultiType, AssignmentFloatToVector3)
- {
- MultiType mt(Vector3(1, 2, 3));
-
- EXPECT_TRUE(mt.isType<Vector3>());
- EXPECT_EQ(Vector3(1, 2, 3), mt.get<Vector3>());
- EXPECT_TRUE(mt.lastConversionSuccessful());
-
- mt = 77.7f;
-
- EXPECT_TRUE(mt.isType<Vector3>());
- EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
- EXPECT_FALSE(mt.lastConversionSuccessful());
- }
-
- //////////////////////
- // Assignment Other //
- //////////////////////
- TEST(MultiType, AssignmentOther)
- {
- MultiType mt1(33);
- MultiType mt2(44.4f);
-
- EXPECT_TRUE(mt1.isType<int>());
- EXPECT_TRUE(mt2.isType<float>());
-
- EXPECT_EQ(33, mt1.get<int>());
- EXPECT_EQ(33.0f, mt1.get<float>());
- EXPECT_EQ(44.4f, mt2.get<float>());
-
- mt1 = mt2;
-
- EXPECT_TRUE(mt1.isType<int>());
- EXPECT_TRUE(mt2.isType<float>());
-
- EXPECT_EQ(44, mt1.get<int>());
- EXPECT_EQ(44.0f, mt1.get<float>());
- EXPECT_EQ(44.4f, mt2.get<float>());
- }
-
- ////////////////
- // set(value) //
- ////////////////
- TEST(MultiType, SetValueBoolToEmpty)
- {
- MultiType mt;
-
- mt.set(true);
-
- EXPECT_TRUE(mt.isType<bool>());
- EXPECT_EQ(true, mt.get<bool>());
- }
-
- TEST(MultiType, SetValueIntToString)
- {
- MultiType mt("Hello");
-
- EXPECT_TRUE(mt.isType<std::string>());
- EXPECT_EQ("Hello", mt.get<std::string>());
-
- mt.set(1234);
-
- EXPECT_TRUE(mt.isType<std::string>());
- EXPECT_EQ("1234", mt.get<std::string>());
- }
-
- //////////////////////
- // force<type>(value) //
- //////////////////////
- TEST(MultiType, SetValueWithTypeIntToString)
- {
- MultiType mt("Hello");
-
- EXPECT_TRUE(mt.isType<std::string>());
- EXPECT_EQ("Hello", mt.get<std::string>());
-
- mt.force<int>(1234);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(1234, mt.get<int>());
- }
-
- TEST(MultiType, SetValueWithTypeIntAsStringToString)
- {
- MultiType mt("Hello");
-
- EXPECT_TRUE(mt.isType<std::string>());
- EXPECT_EQ("Hello", mt.get<std::string>());
-
- mt.force<int>("1234");
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(1234, mt.get<int>());
- }
-
- TEST(MultiType, SetValueWithTypeIntToInt)
- {
- MultiType mt(4321);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(4321, mt.get<int>());
-
- mt.force<int>(1234);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(1234, mt.get<int>());
- }
-
- /////////////////////
- // convert<type>() //
- /////////////////////
- TEST(MultiType, ConvertEmptyToInt)
- {
- MultiType mt;
- mt.convert<int>();
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(0, mt.get<int>());
- }
-
- TEST(MultiType, ConvertFloatToInt)
- {
- MultiType mt(1.234f);
-
- EXPECT_TRUE(mt.isType<float>());
- EXPECT_EQ(1.234f, mt.get<float>());
- EXPECT_EQ(1, mt.get<int>());
-
- mt.convert<int>();
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(1.0f, mt.get<float>());
- EXPECT_EQ(1, mt.get<int>());
- }
-
- TEST(MultiType, ConvertFloatToVector3)
- {
- MultiType mt(1.234f);
-
- EXPECT_TRUE(mt.isType<float>());
- EXPECT_EQ(1.234f, mt.get<float>());
- EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
-
- mt.convert<Vector3>();
-
- EXPECT_TRUE(mt.isType<Vector3>());
- EXPECT_EQ(0.0f, mt.get<float>());
- EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
-
- EXPECT_FALSE(mt.lastConversionSuccessful());
- }
-
- ///////////
- // reset //
- ///////////
- TEST(MultiType, Reset)
- {
- MultiType mt(10);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.null());
- EXPECT_EQ(10, mt.get<int>());
-
- mt.reset();
-
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_TRUE(mt.isType<void>());
- EXPECT_TRUE(mt.null());
- EXPECT_EQ(0, mt.get<int>());
- }
-
- ///////////////////
- // reset<type>() //
- ///////////////////
- TEST(MultiType, SetType)
- {
- MultiType mt(10);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_EQ(10, mt.get<int>());
-
- mt.reset<float>();
-
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_TRUE(mt.isType<float>());
- EXPECT_EQ(0, mt.get<int>());
- }
-
- ////////////////
- // resetValue //
- ////////////////
- TEST(MultiType, resetValue)
- {
- MultiType mt(10);
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(10, mt.get<int>());
-
- mt.resetValue();
-
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_EQ(0, mt.get<int>());
- }
-
- /////////////////////
- // type operator() //
- /////////////////////
- TEST(MultiType, ConversionOperatorFloatToFloat)
- {
- MultiType mt(12.34f);
- float value = mt;
- EXPECT_EQ(12.34f, value);
- }
-
- TEST(MultiType, ConversionOperatorFloatToInt)
- {
- MultiType mt(12.34f);
- int value = mt;
- EXPECT_EQ(12, value);
- }
-
- TEST(MultiType, ConversionOperatorIntToFloat)
- {
- MultiType mt(123);
- float value = mt;
- EXPECT_EQ(123, value);
- }
-
- TEST(MultiType, ConversionOperatorIntToString)
- {
- MultiType mt(123);
- std::string value = mt;
- EXPECT_EQ("123", value);
- }
-
- TEST(MultiType, ConversionOperatorStringToInt)
- {
- MultiType mt("321");
- int value = mt;
- EXPECT_EQ(321, value);
- }
-
- namespace
- {
- void helper_function(const std::string& a, float b, int c)
- {
- EXPECT_EQ("555.555", a);
- EXPECT_EQ(555.555f, b);
- EXPECT_EQ(555, c);
- }
- }
-
- TEST(MultiType, ConversionOperatorPassToFunction)
- {
- MultiType mt("555.555");
-
- helper_function(mt, mt, mt);
- }
-
- ///////////////////////
- // getValue(pointer) //
- ///////////////////////
- TEST(MultiType, GetValueIntToInt)
- {
- MultiType mt(33);
-
- int value = 0;
- EXPECT_TRUE(mt.getValue(&value));
- EXPECT_EQ(33, value);
- }
-
- TEST(MultiType, GetValueIntToFloat)
- {
- MultiType mt(33);
-
- float value = 0;
- EXPECT_TRUE(mt.getValue(&value));
- EXPECT_EQ(33.0f, value);
- }
-
- TEST(MultiType, GetValueIntToVector3)
- {
- MultiType mt(33);
-
- Vector3 value = Vector3::ZERO;
- EXPECT_FALSE(mt.getValue(&value));
- EXPECT_EQ(Vector3::ZERO, value);
- }
-
- //////////////
- // get<type>() //
- //////////////
- TEST(MultiType, GetValueFromInt)
- {
- MultiType mt(256);
-
- EXPECT_EQ(0, mt.get<char>());
- EXPECT_EQ(0u, mt.get<unsigned char>());
- EXPECT_EQ(256, mt.get<short>());
- EXPECT_EQ(256u, mt.get<unsigned short>());
- EXPECT_EQ(256, mt.get<int>());
- EXPECT_EQ(256u, mt.get<unsigned int>());
- EXPECT_EQ(256, mt.get<long>());
- EXPECT_EQ(256u, mt.get<unsigned long>());
- EXPECT_EQ(256, mt.get<long long>());
- EXPECT_EQ(256u, mt.get<unsigned long long>());
- EXPECT_EQ(256.0f, mt.get<float>());
- EXPECT_EQ(256.0, mt.get<double>());
- EXPECT_EQ(256.0, mt.get<long double>());
- EXPECT_TRUE(mt.get<bool>());
- EXPECT_EQ("256", mt.get<std::string>());
- }
-
- TEST(MultiType, GetValueFromFloat)
- {
- MultiType mt(128.821);
-
- EXPECT_EQ(-128, mt.get<char>());
- EXPECT_EQ(128u, mt.get<unsigned char>());
- EXPECT_EQ(128, mt.get<short>());
- EXPECT_EQ(128u, mt.get<unsigned short>());
- EXPECT_EQ(128, mt.get<int>());
- EXPECT_EQ(128u, mt.get<unsigned int>());
- EXPECT_EQ(128, mt.get<long>());
- EXPECT_EQ(128u, mt.get<unsigned long>());
- EXPECT_EQ(128, mt.get<long long>());
- EXPECT_EQ(128u, mt.get<unsigned long long>());
- EXPECT_EQ(128.821f, mt.get<float>());
- EXPECT_EQ(128.821, mt.get<double>());
- EXPECT_EQ(128.821, mt.get<long double>());
- EXPECT_TRUE(mt.get<bool>());
- EXPECT_EQ("128.821", mt.get<std::string>());
- }
-
- TEST(MultiType, GetValueFromString)
- {
- MultiType mt("0.123");
-
- EXPECT_EQ('0', mt.get<char>());
- EXPECT_EQ('0', mt.get<unsigned char>());
- EXPECT_EQ(0, mt.get<short>());
- EXPECT_EQ(0u, mt.get<unsigned short>());
- EXPECT_EQ(0, mt.get<int>());
- EXPECT_EQ(0u, mt.get<unsigned int>());
- EXPECT_EQ(0, mt.get<long>());
- EXPECT_EQ(0u, mt.get<unsigned long>());
- EXPECT_EQ(0, mt.get<long long>());
- EXPECT_EQ(0u, mt.get<unsigned long long>());
- EXPECT_EQ(0.123f, mt.get<float>());
- EXPECT_EQ(0.123, mt.get<double>());
- EXPECT_DOUBLE_EQ(0.123, mt.get<long double>());
- EXPECT_FALSE(mt.get<bool>());
- EXPECT_EQ("0.123", mt.get<std::string>());
- }
-
- ////////////////////
- // isType<type>() //
- ////////////////////
- TEST(MultiType, IsTypeInt)
- {
- MultiType mt(1);
-
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.isType<char>());
- EXPECT_FALSE(mt.isType<unsigned char>());
- EXPECT_FALSE(mt.isType<short>());
- EXPECT_FALSE(mt.isType<unsigned short>());
- EXPECT_TRUE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<unsigned int>());
- EXPECT_FALSE(mt.isType<long>());
- EXPECT_FALSE(mt.isType<unsigned long>());
- EXPECT_FALSE(mt.isType<long long>());
- EXPECT_FALSE(mt.isType<unsigned long long>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_FALSE(mt.isType<double>());
- EXPECT_FALSE(mt.isType<long double>());
- EXPECT_FALSE(mt.isType<bool>());
- EXPECT_FALSE(mt.isType<void*>());
- EXPECT_FALSE(mt.isType<std::string>());
- EXPECT_FALSE(mt.isType<orxonox::Vector2>());
- EXPECT_FALSE(mt.isType<orxonox::Vector3>());
- EXPECT_FALSE(mt.isType<orxonox::Vector4>());
- EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
- EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
- EXPECT_FALSE(mt.isType<orxonox::Radian>());
- EXPECT_FALSE(mt.isType<orxonox::Degree>());
- }
-
- TEST(MultiType, IsTypeUnsignedInt)
- {
- MultiType mt(1u);
-
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.isType<char>());
- EXPECT_FALSE(mt.isType<unsigned char>());
- EXPECT_FALSE(mt.isType<short>());
- EXPECT_FALSE(mt.isType<unsigned short>());
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_TRUE(mt.isType<unsigned int>());
- EXPECT_FALSE(mt.isType<long>());
- EXPECT_FALSE(mt.isType<unsigned long>());
- EXPECT_FALSE(mt.isType<long long>());
- EXPECT_FALSE(mt.isType<unsigned long long>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_FALSE(mt.isType<double>());
- EXPECT_FALSE(mt.isType<long double>());
- EXPECT_FALSE(mt.isType<bool>());
- EXPECT_FALSE(mt.isType<void*>());
- EXPECT_FALSE(mt.isType<std::string>());
- EXPECT_FALSE(mt.isType<orxonox::Vector2>());
- EXPECT_FALSE(mt.isType<orxonox::Vector3>());
- EXPECT_FALSE(mt.isType<orxonox::Vector4>());
- EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
- EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
- EXPECT_FALSE(mt.isType<orxonox::Radian>());
- EXPECT_FALSE(mt.isType<orxonox::Degree>());
- }
-
- TEST(MultiType, IsTypeDouble)
- {
- MultiType mt(1.0);
-
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.isType<char>());
- EXPECT_FALSE(mt.isType<unsigned char>());
- EXPECT_FALSE(mt.isType<short>());
- EXPECT_FALSE(mt.isType<unsigned short>());
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<unsigned int>());
- EXPECT_FALSE(mt.isType<long>());
- EXPECT_FALSE(mt.isType<unsigned long>());
- EXPECT_FALSE(mt.isType<long long>());
- EXPECT_FALSE(mt.isType<unsigned long long>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_TRUE(mt.isType<double>());
- EXPECT_FALSE(mt.isType<long double>());
- EXPECT_FALSE(mt.isType<bool>());
- EXPECT_FALSE(mt.isType<void*>());
- EXPECT_FALSE(mt.isType<std::string>());
- EXPECT_FALSE(mt.isType<orxonox::Vector2>());
- EXPECT_FALSE(mt.isType<orxonox::Vector3>());
- EXPECT_FALSE(mt.isType<orxonox::Vector4>());
- EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
- EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
- EXPECT_FALSE(mt.isType<orxonox::Radian>());
- EXPECT_FALSE(mt.isType<orxonox::Degree>());
- }
-
- TEST(MultiType, IsTypeString)
- {
- MultiType mt("1");
-
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.isType<char>());
- EXPECT_FALSE(mt.isType<unsigned char>());
- EXPECT_FALSE(mt.isType<short>());
- EXPECT_FALSE(mt.isType<unsigned short>());
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<unsigned int>());
- EXPECT_FALSE(mt.isType<long>());
- EXPECT_FALSE(mt.isType<unsigned long>());
- EXPECT_FALSE(mt.isType<long long>());
- EXPECT_FALSE(mt.isType<unsigned long long>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_FALSE(mt.isType<double>());
- EXPECT_FALSE(mt.isType<long double>());
- EXPECT_FALSE(mt.isType<bool>());
- EXPECT_FALSE(mt.isType<void*>());
- EXPECT_TRUE(mt.isType<std::string>());
- EXPECT_FALSE(mt.isType<orxonox::Vector2>());
- EXPECT_FALSE(mt.isType<orxonox::Vector3>());
- EXPECT_FALSE(mt.isType<orxonox::Vector4>());
- EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
- EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
- EXPECT_FALSE(mt.isType<orxonox::Radian>());
- EXPECT_FALSE(mt.isType<orxonox::Degree>());
- }
-
- TEST(MultiType, IsTypeDegree)
- {
- MultiType mt(Degree(1));
-
- EXPECT_FALSE(mt.isType<void>());
- EXPECT_FALSE(mt.isType<char>());
- EXPECT_FALSE(mt.isType<unsigned char>());
- EXPECT_FALSE(mt.isType<short>());
- EXPECT_FALSE(mt.isType<unsigned short>());
- EXPECT_FALSE(mt.isType<int>());
- EXPECT_FALSE(mt.isType<unsigned int>());
- EXPECT_FALSE(mt.isType<long>());
- EXPECT_FALSE(mt.isType<unsigned long>());
- EXPECT_FALSE(mt.isType<long long>());
- EXPECT_FALSE(mt.isType<unsigned long long>());
- EXPECT_FALSE(mt.isType<float>());
- EXPECT_FALSE(mt.isType<double>());
- EXPECT_FALSE(mt.isType<long double>());
- EXPECT_FALSE(mt.isType<bool>());
- EXPECT_FALSE(mt.isType<void*>());
- EXPECT_FALSE(mt.isType<std::string>());
- EXPECT_FALSE(mt.isType<orxonox::Vector2>());
- EXPECT_FALSE(mt.isType<orxonox::Vector3>());
- EXPECT_FALSE(mt.isType<orxonox::Vector4>());
- EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
- EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
- EXPECT_FALSE(mt.isType<orxonox::Radian>());
- EXPECT_TRUE(mt.isType<orxonox::Degree>());
- }
-
- ////////////////////////////////
- // lastConversionSuccessful() //
- ////////////////////////////////
- TEST(MultiType, LastConversionSuccessful)
- {
- MultiType mt;
-
- EXPECT_TRUE(mt.lastConversionSuccessful());
-
- mt = 5.55;
-
- EXPECT_TRUE(mt.lastConversionSuccessful());
-
- mt.convert<int>();
-
- EXPECT_TRUE(mt.lastConversionSuccessful());
-
- mt.convert<Vector3>();
-
- EXPECT_FALSE(mt.lastConversionSuccessful());
-
- mt.convert<std::string>();
-
- EXPECT_TRUE(mt.lastConversionSuccessful());
- }
-
- ////////////
- // null() //
- ////////////
- TEST(MultiType, Null1)
- {
- MultiType mt;
-
- EXPECT_TRUE(mt.null());
-
- mt = 5;
-
- EXPECT_FALSE(mt.null());
- }
-
- TEST(MultiType, Null2)
- {
- MultiType mt(5);
-
- EXPECT_FALSE(mt.null());
-
- mt.reset();
-
- EXPECT_TRUE(mt.null());
- }
-}
+#include <gtest/gtest.h>
+#include "util/MultiType.h"
+
+namespace orxonox
+{
+ // x constructor()
+ // x constructor(value)
+ // x constructor(other)
+
+ // x assignment(value)
+ // ? assignment(pointer)
+ // x assignment(other)
+
+ // x set(value)
+ // ? set(pointer)
+ // x force<type>(value)
+
+ // x convert<type>()
+ // x reset
+ // x reset<type>()
+ // x resetValue
+
+ // x isType<type>()
+
+ // x (type) conversion
+ // ? (pointer class) conversion
+ // x getValue(pointer)
+ // x get<type>()
+ // ? getPointer()
+
+ // x lastConversionSuccessful()
+ // x null()
+
+ /////////////////////////
+ // Default Constructor //
+ /////////////////////////
+ TEST(MultiType, DefaultConstructor)
+ {
+ MultiType mt;
+ EXPECT_TRUE(mt.null());
+ EXPECT_TRUE(mt.isType<void>());
+ }
+
+ /////////////////
+ // Constructor //
+ /////////////////
+ TEST(MultiType, ValueChar) { char value = -100; MultiType mt(value); EXPECT_TRUE(mt.isType<char>()); EXPECT_EQ(-100, mt.get<char>()); }
+ TEST(MultiType, ValueUnsignedChar) { unsigned char value = 255u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned char>()); EXPECT_EQ(255u, mt.get<unsigned char>()); }
+ TEST(MultiType, ValueShort) { short value = -10000; MultiType mt(value); EXPECT_TRUE(mt.isType<short>()); EXPECT_EQ(-10000, mt.get<short>()); }
+ TEST(MultiType, ValueUnsignedShort) { unsigned short value = 65535u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned short>()); EXPECT_EQ(65535u, mt.get<unsigned short>()); }
+ TEST(MultiType, ValueInt) { int value = -1000000000; MultiType mt(value); EXPECT_TRUE(mt.isType<int>()); EXPECT_EQ(-1000000000, mt.get<int>()); }
+ TEST(MultiType, ValueUnsignedInt) { unsigned int value = 4000000000u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned int>()); EXPECT_EQ(4000000000u, mt.get<unsigned int>()); }
+ TEST(MultiType, ValueLong) { long value = -1000000000; MultiType mt(value); EXPECT_TRUE(mt.isType<long>()); EXPECT_EQ(-1000000000, mt.get<long>()); }
+ TEST(MultiType, ValueUnsignedLong) { unsigned long value = 4000000000u; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned long>()); EXPECT_EQ(4000000000u, mt.get<unsigned long>()); }
+ TEST(MultiType, ValueLongLong) { long long value = -1000000000000000000L; MultiType mt(value); EXPECT_TRUE(mt.isType<long long>()); EXPECT_EQ(-1000000000000000000L, mt.get<long long>()); }
+ TEST(MultiType, ValueUnsignedLongLong) { unsigned long long value = 4000000000000000000UL; MultiType mt(value); EXPECT_TRUE(mt.isType<unsigned long long>()); EXPECT_EQ(4000000000000000000UL, mt.get<unsigned long long>()); }
+ TEST(MultiType, ValueFloat) { float value = 0.123456f; MultiType mt(value); EXPECT_TRUE(mt.isType<float>()); EXPECT_EQ(0.123456f, mt.get<float>()); }
+ TEST(MultiType, ValueDouble) { double value = 0.123456789; MultiType mt(value); EXPECT_TRUE(mt.isType<double>()); EXPECT_EQ(0.123456789, mt.get<double>()); }
+ TEST(MultiType, ValueLongDouble) { long double value = 0.123456789123456789; MultiType mt(value); EXPECT_TRUE(mt.isType<long double>()); EXPECT_EQ(0.123456789123456789, mt.get<long double>()); }
+ TEST(MultiType, ValueBool) { bool value = true; MultiType mt(value); EXPECT_TRUE(mt.isType<bool>()); EXPECT_EQ(true, mt.get<bool>()); }
+ TEST(MultiType, ValueVoidpointer) { int* pointer = new int; void* value = pointer; MultiType mt(value); EXPECT_TRUE(mt.isType<void*>()); EXPECT_EQ(value, mt.get<void*>()); delete pointer; }
+ TEST(MultiType, ValueString) { std::string value = "Hello World"; MultiType mt(value); EXPECT_TRUE(mt.isType<std::string>()); EXPECT_EQ("Hello World", mt.get<std::string>()); }
+ TEST(MultiType, ValueVector2) { Vector2 value = Vector2(11, 22); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector2>()); EXPECT_EQ(Vector2(11, 22), mt.get<Vector2>()); }
+ TEST(MultiType, ValueVector3) { Vector3 value = Vector3(11, 22, 33); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector3>()); EXPECT_EQ(Vector3(11, 22, 33), mt.get<Vector3>()); }
+ TEST(MultiType, ValueVector4) { Vector4 value = Vector4(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<Vector4>()); EXPECT_EQ(Vector4(11, 22, 33, 44), mt.get<Vector4>()); }
+ TEST(MultiType, ValueColourValue) { ColourValue value = ColourValue(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<ColourValue>()); EXPECT_EQ(ColourValue(11, 22, 33, 44), mt.get<ColourValue>()); }
+ TEST(MultiType, ValueQuaternion) { Quaternion value = Quaternion(11, 22, 33, 44); MultiType mt(value); EXPECT_TRUE(mt.isType<Quaternion>()); EXPECT_EQ(Quaternion(11, 22, 33, 44), mt.get<Quaternion>()); }
+ TEST(MultiType, ValueRadian) { Radian value = Radian(0.123); MultiType mt(value); EXPECT_TRUE(mt.isType<Radian>()); EXPECT_EQ(Radian(0.123), mt.get<Radian>()); }
+ TEST(MultiType, ValueDegree) { Degree value = Degree(123); MultiType mt(value); EXPECT_TRUE(mt.isType<Degree>()); EXPECT_EQ(Degree(123), mt.get<Degree>()); }
+ TEST(MultiType, ValueMbool) { mbool value = mbool(true); MultiType mt(value); EXPECT_TRUE(mt.isType<bool>()); EXPECT_EQ(mbool(true), mt.get<bool>()); }
+ TEST(MultiType, ValueCharPointer) { const char* value = "Hello World"; MultiType mt(value); EXPECT_TRUE(mt.isType<std::string>()); EXPECT_EQ("Hello World", mt.get<std::string>()); }
+
+ //////////////////////
+ // Copy-Constructor //
+ //////////////////////
+ TEST(MultiType, CopyConstructorEmpty)
+ {
+ MultiType mt1;
+ MultiType mt2(mt1);
+
+ EXPECT_TRUE(mt2.null());
+ }
+
+ TEST(MultiType, CopyConstructorFloat)
+ {
+ MultiType mt1(0.1234f);
+ MultiType mt2(mt1);
+
+ EXPECT_TRUE(mt2.isType<float>());
+ EXPECT_EQ(0.1234f, mt2.get<float>());
+ }
+
+ //////////////////////
+ // Assignment Value //
+ //////////////////////
+ TEST(MultiType, AssignmentIntToEmpty)
+ {
+ MultiType mt;
+
+ EXPECT_TRUE(mt.null());
+
+ mt = 55;
+
+ EXPECT_FALSE(mt.null());
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(55, mt.get<int>());
+ }
+
+ TEST(MultiType, AssignmentFloatToInt)
+ {
+ MultiType mt(66);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(66, mt.get<int>());
+
+ mt = 77.7f; // will be converted to int
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(77, mt.get<int>());
+ EXPECT_EQ(77.0f, mt.get<float>());
+ }
+
+ TEST(MultiType, AssignmentFloatToFloat)
+ {
+ MultiType mt(66.6f);
+
+ EXPECT_TRUE(mt.isType<float>());
+ EXPECT_EQ(66, mt.get<int>());
+ EXPECT_EQ(66.6f, mt.get<float>());
+
+ mt = 77.7f;
+
+ EXPECT_TRUE(mt.isType<float>());
+ EXPECT_EQ(77, mt.get<int>());
+ EXPECT_EQ(77.7f, mt.get<float>());
+ }
+
+ TEST(MultiType, AssignmentFloatToVector3)
+ {
+ MultiType mt(Vector3(1, 2, 3));
+
+ EXPECT_TRUE(mt.isType<Vector3>());
+ EXPECT_EQ(Vector3(1, 2, 3), mt.get<Vector3>());
+ EXPECT_TRUE(mt.lastConversionSuccessful());
+
+ mt = 77.7f;
+
+ EXPECT_TRUE(mt.isType<Vector3>());
+ EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
+ EXPECT_FALSE(mt.lastConversionSuccessful());
+ }
+
+ //////////////////////
+ // Assignment Other //
+ //////////////////////
+ TEST(MultiType, AssignmentOther)
+ {
+ MultiType mt1(33);
+ MultiType mt2(44.4f);
+
+ EXPECT_TRUE(mt1.isType<int>());
+ EXPECT_TRUE(mt2.isType<float>());
+
+ EXPECT_EQ(33, mt1.get<int>());
+ EXPECT_EQ(33.0f, mt1.get<float>());
+ EXPECT_EQ(44.4f, mt2.get<float>());
+
+ mt1 = mt2;
+
+ EXPECT_TRUE(mt1.isType<int>());
+ EXPECT_TRUE(mt2.isType<float>());
+
+ EXPECT_EQ(44, mt1.get<int>());
+ EXPECT_EQ(44.0f, mt1.get<float>());
+ EXPECT_EQ(44.4f, mt2.get<float>());
+ }
+
+ ////////////////
+ // set(value) //
+ ////////////////
+ TEST(MultiType, SetValueBoolToEmpty)
+ {
+ MultiType mt;
+
+ mt.set(true);
+
+ EXPECT_TRUE(mt.isType<bool>());
+ EXPECT_EQ(true, mt.get<bool>());
+ }
+
+ TEST(MultiType, SetValueIntToString)
+ {
+ MultiType mt("Hello");
+
+ EXPECT_TRUE(mt.isType<std::string>());
+ EXPECT_EQ("Hello", mt.get<std::string>());
+
+ mt.set(1234);
+
+ EXPECT_TRUE(mt.isType<std::string>());
+ EXPECT_EQ("1234", mt.get<std::string>());
+ }
+
+ //////////////////////
+ // force<type>(value) //
+ //////////////////////
+ TEST(MultiType, SetValueWithTypeIntToString)
+ {
+ MultiType mt("Hello");
+
+ EXPECT_TRUE(mt.isType<std::string>());
+ EXPECT_EQ("Hello", mt.get<std::string>());
+
+ mt.force<int>(1234);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(1234, mt.get<int>());
+ }
+
+ TEST(MultiType, SetValueWithTypeIntAsStringToString)
+ {
+ MultiType mt("Hello");
+
+ EXPECT_TRUE(mt.isType<std::string>());
+ EXPECT_EQ("Hello", mt.get<std::string>());
+
+ mt.force<int>("1234");
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(1234, mt.get<int>());
+ }
+
+ TEST(MultiType, SetValueWithTypeIntToInt)
+ {
+ MultiType mt(4321);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(4321, mt.get<int>());
+
+ mt.force<int>(1234);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(1234, mt.get<int>());
+ }
+
+ /////////////////////
+ // convert<type>() //
+ /////////////////////
+ TEST(MultiType, ConvertEmptyToInt)
+ {
+ MultiType mt;
+ mt.convert<int>();
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(0, mt.get<int>());
+ }
+
+ TEST(MultiType, ConvertFloatToInt)
+ {
+ MultiType mt(1.234f);
+
+ EXPECT_TRUE(mt.isType<float>());
+ EXPECT_EQ(1.234f, mt.get<float>());
+ EXPECT_EQ(1, mt.get<int>());
+
+ mt.convert<int>();
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(1.0f, mt.get<float>());
+ EXPECT_EQ(1, mt.get<int>());
+ }
+
+ TEST(MultiType, ConvertFloatToVector3)
+ {
+ MultiType mt(1.234f);
+
+ EXPECT_TRUE(mt.isType<float>());
+ EXPECT_EQ(1.234f, mt.get<float>());
+ EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
+
+ mt.convert<Vector3>();
+
+ EXPECT_TRUE(mt.isType<Vector3>());
+ EXPECT_EQ(0.0f, mt.get<float>());
+ EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
+
+ EXPECT_FALSE(mt.lastConversionSuccessful());
+ }
+
+ ///////////
+ // reset //
+ ///////////
+ TEST(MultiType, Reset)
+ {
+ MultiType mt(10);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.null());
+ EXPECT_EQ(10, mt.get<int>());
+
+ mt.reset();
+
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_TRUE(mt.isType<void>());
+ EXPECT_TRUE(mt.null());
+ EXPECT_EQ(0, mt.get<int>());
+ }
+
+ ///////////////////
+ // reset<type>() //
+ ///////////////////
+ TEST(MultiType, SetType)
+ {
+ MultiType mt(10);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_EQ(10, mt.get<int>());
+
+ mt.reset<float>();
+
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_TRUE(mt.isType<float>());
+ EXPECT_EQ(0, mt.get<int>());
+ }
+
+ ////////////////
+ // resetValue //
+ ////////////////
+ TEST(MultiType, resetValue)
+ {
+ MultiType mt(10);
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(10, mt.get<int>());
+
+ mt.resetValue();
+
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_EQ(0, mt.get<int>());
+ }
+
+ /////////////////////
+ // type operator() //
+ /////////////////////
+ TEST(MultiType, ConversionOperatorFloatToFloat)
+ {
+ MultiType mt(12.34f);
+ float value = mt;
+ EXPECT_EQ(12.34f, value);
+ }
+
+ TEST(MultiType, ConversionOperatorFloatToInt)
+ {
+ MultiType mt(12.34f);
+ int value = mt;
+ EXPECT_EQ(12, value);
+ }
+
+ TEST(MultiType, ConversionOperatorIntToFloat)
+ {
+ MultiType mt(123);
+ float value = mt;
+ EXPECT_EQ(123, value);
+ }
+
+ TEST(MultiType, ConversionOperatorIntToString)
+ {
+ MultiType mt(123);
+ std::string value = mt;
+ EXPECT_EQ("123", value);
+ }
+
+ TEST(MultiType, ConversionOperatorStringToInt)
+ {
+ MultiType mt("321");
+ int value = mt;
+ EXPECT_EQ(321, value);
+ }
+
+ namespace
+ {
+ void helper_function(const std::string& a, float b, int c)
+ {
+ EXPECT_EQ("555.555", a);
+ EXPECT_EQ(555.555f, b);
+ EXPECT_EQ(555, c);
+ }
+ }
+
+ TEST(MultiType, ConversionOperatorPassToFunction)
+ {
+ MultiType mt("555.555");
+
+ helper_function(mt, mt, mt);
+ }
+
+ ///////////////////////
+ // getValue(pointer) //
+ ///////////////////////
+ TEST(MultiType, GetValueIntToInt)
+ {
+ MultiType mt(33);
+
+ int value = 0;
+ EXPECT_TRUE(mt.getValue(&value));
+ EXPECT_EQ(33, value);
+ }
+
+ TEST(MultiType, GetValueIntToFloat)
+ {
+ MultiType mt(33);
+
+ float value = 0;
+ EXPECT_TRUE(mt.getValue(&value));
+ EXPECT_EQ(33.0f, value);
+ }
+
+ TEST(MultiType, GetValueIntToVector3)
+ {
+ MultiType mt(33);
+
+ Vector3 value = Vector3::ZERO;
+ EXPECT_FALSE(mt.getValue(&value));
+ EXPECT_EQ(Vector3::ZERO, value);
+ }
+
+ //////////////
+ // get<type>() //
+ //////////////
+ TEST(MultiType, GetValueFromInt)
+ {
+ MultiType mt(256);
+
+ EXPECT_EQ(0, mt.get<char>());
+ EXPECT_EQ(0u, mt.get<unsigned char>());
+ EXPECT_EQ(256, mt.get<short>());
+ EXPECT_EQ(256u, mt.get<unsigned short>());
+ EXPECT_EQ(256, mt.get<int>());
+ EXPECT_EQ(256u, mt.get<unsigned int>());
+ EXPECT_EQ(256, mt.get<long>());
+ EXPECT_EQ(256u, mt.get<unsigned long>());
+ EXPECT_EQ(256, mt.get<long long>());
+ EXPECT_EQ(256u, mt.get<unsigned long long>());
+ EXPECT_EQ(256.0f, mt.get<float>());
+ EXPECT_EQ(256.0, mt.get<double>());
+ EXPECT_EQ(256.0, mt.get<long double>());
+ EXPECT_TRUE(mt.get<bool>());
+ EXPECT_EQ("256", mt.get<std::string>());
+ }
+
+ TEST(MultiType, GetValueFromFloat)
+ {
+ MultiType mt(128.821);
+
+ EXPECT_EQ(-128, mt.get<char>());
+ EXPECT_EQ(128u, mt.get<unsigned char>());
+ EXPECT_EQ(128, mt.get<short>());
+ EXPECT_EQ(128u, mt.get<unsigned short>());
+ EXPECT_EQ(128, mt.get<int>());
+ EXPECT_EQ(128u, mt.get<unsigned int>());
+ EXPECT_EQ(128, mt.get<long>());
+ EXPECT_EQ(128u, mt.get<unsigned long>());
+ EXPECT_EQ(128, mt.get<long long>());
+ EXPECT_EQ(128u, mt.get<unsigned long long>());
+ EXPECT_EQ(128.821f, mt.get<float>());
+ EXPECT_EQ(128.821, mt.get<double>());
+ EXPECT_EQ(128.821, mt.get<long double>());
+ EXPECT_TRUE(mt.get<bool>());
+ EXPECT_EQ("128.821", mt.get<std::string>());
+ }
+
+ TEST(MultiType, GetValueFromString)
+ {
+ MultiType mt("0.123");
+
+ EXPECT_EQ('0', mt.get<char>());
+ EXPECT_EQ('0', mt.get<unsigned char>());
+ EXPECT_EQ(0, mt.get<short>());
+ EXPECT_EQ(0u, mt.get<unsigned short>());
+ EXPECT_EQ(0, mt.get<int>());
+ EXPECT_EQ(0u, mt.get<unsigned int>());
+ EXPECT_EQ(0, mt.get<long>());
+ EXPECT_EQ(0u, mt.get<unsigned long>());
+ EXPECT_EQ(0, mt.get<long long>());
+ EXPECT_EQ(0u, mt.get<unsigned long long>());
+ EXPECT_EQ(0.123f, mt.get<float>());
+ EXPECT_EQ(0.123, mt.get<double>());
+ EXPECT_DOUBLE_EQ(0.123, mt.get<long double>());
+ EXPECT_FALSE(mt.get<bool>());
+ EXPECT_EQ("0.123", mt.get<std::string>());
+ }
+
+ ////////////////////
+ // isType<type>() //
+ ////////////////////
+ TEST(MultiType, IsTypeInt)
+ {
+ MultiType mt(1);
+
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.isType<char>());
+ EXPECT_FALSE(mt.isType<unsigned char>());
+ EXPECT_FALSE(mt.isType<short>());
+ EXPECT_FALSE(mt.isType<unsigned short>());
+ EXPECT_TRUE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<unsigned int>());
+ EXPECT_FALSE(mt.isType<long>());
+ EXPECT_FALSE(mt.isType<unsigned long>());
+ EXPECT_FALSE(mt.isType<long long>());
+ EXPECT_FALSE(mt.isType<unsigned long long>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_FALSE(mt.isType<double>());
+ EXPECT_FALSE(mt.isType<long double>());
+ EXPECT_FALSE(mt.isType<bool>());
+ EXPECT_FALSE(mt.isType<void*>());
+ EXPECT_FALSE(mt.isType<std::string>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector2>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector3>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector4>());
+ EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
+ EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
+ EXPECT_FALSE(mt.isType<orxonox::Radian>());
+ EXPECT_FALSE(mt.isType<orxonox::Degree>());
+ }
+
+ TEST(MultiType, IsTypeUnsignedInt)
+ {
+ MultiType mt(1u);
+
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.isType<char>());
+ EXPECT_FALSE(mt.isType<unsigned char>());
+ EXPECT_FALSE(mt.isType<short>());
+ EXPECT_FALSE(mt.isType<unsigned short>());
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_TRUE(mt.isType<unsigned int>());
+ EXPECT_FALSE(mt.isType<long>());
+ EXPECT_FALSE(mt.isType<unsigned long>());
+ EXPECT_FALSE(mt.isType<long long>());
+ EXPECT_FALSE(mt.isType<unsigned long long>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_FALSE(mt.isType<double>());
+ EXPECT_FALSE(mt.isType<long double>());
+ EXPECT_FALSE(mt.isType<bool>());
+ EXPECT_FALSE(mt.isType<void*>());
+ EXPECT_FALSE(mt.isType<std::string>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector2>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector3>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector4>());
+ EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
+ EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
+ EXPECT_FALSE(mt.isType<orxonox::Radian>());
+ EXPECT_FALSE(mt.isType<orxonox::Degree>());
+ }
+
+ TEST(MultiType, IsTypeDouble)
+ {
+ MultiType mt(1.0);
+
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.isType<char>());
+ EXPECT_FALSE(mt.isType<unsigned char>());
+ EXPECT_FALSE(mt.isType<short>());
+ EXPECT_FALSE(mt.isType<unsigned short>());
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<unsigned int>());
+ EXPECT_FALSE(mt.isType<long>());
+ EXPECT_FALSE(mt.isType<unsigned long>());
+ EXPECT_FALSE(mt.isType<long long>());
+ EXPECT_FALSE(mt.isType<unsigned long long>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_TRUE(mt.isType<double>());
+ EXPECT_FALSE(mt.isType<long double>());
+ EXPECT_FALSE(mt.isType<bool>());
+ EXPECT_FALSE(mt.isType<void*>());
+ EXPECT_FALSE(mt.isType<std::string>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector2>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector3>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector4>());
+ EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
+ EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
+ EXPECT_FALSE(mt.isType<orxonox::Radian>());
+ EXPECT_FALSE(mt.isType<orxonox::Degree>());
+ }
+
+ TEST(MultiType, IsTypeString)
+ {
+ MultiType mt("1");
+
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.isType<char>());
+ EXPECT_FALSE(mt.isType<unsigned char>());
+ EXPECT_FALSE(mt.isType<short>());
+ EXPECT_FALSE(mt.isType<unsigned short>());
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<unsigned int>());
+ EXPECT_FALSE(mt.isType<long>());
+ EXPECT_FALSE(mt.isType<unsigned long>());
+ EXPECT_FALSE(mt.isType<long long>());
+ EXPECT_FALSE(mt.isType<unsigned long long>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_FALSE(mt.isType<double>());
+ EXPECT_FALSE(mt.isType<long double>());
+ EXPECT_FALSE(mt.isType<bool>());
+ EXPECT_FALSE(mt.isType<void*>());
+ EXPECT_TRUE(mt.isType<std::string>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector2>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector3>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector4>());
+ EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
+ EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
+ EXPECT_FALSE(mt.isType<orxonox::Radian>());
+ EXPECT_FALSE(mt.isType<orxonox::Degree>());
+ }
+
+ TEST(MultiType, IsTypeDegree)
+ {
+ MultiType mt(Degree(1));
+
+ EXPECT_FALSE(mt.isType<void>());
+ EXPECT_FALSE(mt.isType<char>());
+ EXPECT_FALSE(mt.isType<unsigned char>());
+ EXPECT_FALSE(mt.isType<short>());
+ EXPECT_FALSE(mt.isType<unsigned short>());
+ EXPECT_FALSE(mt.isType<int>());
+ EXPECT_FALSE(mt.isType<unsigned int>());
+ EXPECT_FALSE(mt.isType<long>());
+ EXPECT_FALSE(mt.isType<unsigned long>());
+ EXPECT_FALSE(mt.isType<long long>());
+ EXPECT_FALSE(mt.isType<unsigned long long>());
+ EXPECT_FALSE(mt.isType<float>());
+ EXPECT_FALSE(mt.isType<double>());
+ EXPECT_FALSE(mt.isType<long double>());
+ EXPECT_FALSE(mt.isType<bool>());
+ EXPECT_FALSE(mt.isType<void*>());
+ EXPECT_FALSE(mt.isType<std::string>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector2>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector3>());
+ EXPECT_FALSE(mt.isType<orxonox::Vector4>());
+ EXPECT_FALSE(mt.isType<orxonox::ColourValue>());
+ EXPECT_FALSE(mt.isType<orxonox::Quaternion>());
+ EXPECT_FALSE(mt.isType<orxonox::Radian>());
+ EXPECT_TRUE(mt.isType<orxonox::Degree>());
+ }
+
+ ////////////////////////////////
+ // lastConversionSuccessful() //
+ ////////////////////////////////
+ TEST(MultiType, LastConversionSuccessful)
+ {
+ MultiType mt;
+
+ EXPECT_TRUE(mt.lastConversionSuccessful());
+
+ mt = 5.55;
+
+ EXPECT_TRUE(mt.lastConversionSuccessful());
+
+ mt.convert<int>();
+
+ EXPECT_TRUE(mt.lastConversionSuccessful());
+
+ mt.convert<Vector3>();
+
+ EXPECT_FALSE(mt.lastConversionSuccessful());
+
+ mt.convert<std::string>();
+
+ EXPECT_TRUE(mt.lastConversionSuccessful());
+ }
+
+ ////////////
+ // null() //
+ ////////////
+ TEST(MultiType, Null1)
+ {
+ MultiType mt;
+
+ EXPECT_TRUE(mt.null());
+
+ mt = 5;
+
+ EXPECT_FALSE(mt.null());
+ }
+
+ TEST(MultiType, Null2)
+ {
+ MultiType mt(5);
+
+ EXPECT_FALSE(mt.null());
+
+ mt.reset();
+
+ EXPECT_TRUE(mt.null());
+ }
+}
Property changes on: code/branches/testing/test/util/MultiTypeTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/OutputTest.cc
===================================================================
--- code/branches/testing/test/util/OutputTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/OutputTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,49 +1,49 @@
-#include <gtest/gtest.h>
-#include "util/Output.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest);
- }
- }
-
- TEST(OutputTest, CanUseOrxout)
- {
- orxout() << "test" << endl;
- }
-
- TEST(OutputTest, OrxoutUsesCorrectOutputLevel)
- {
- {
- const OutputStream& stream = orxout(internal_warning);
- EXPECT_EQ(internal_warning, stream.getOutputLevel());
- }
-
- {
- const OutputStream& stream = orxout(debug_output);
- EXPECT_EQ(debug_output, stream.getOutputLevel());
- }
- }
-
- TEST(OutputTest, OrxoutUsesCorrectOutputContext)
- {
- const OutputStream& stream = orxout(verbose, context::unittest());
- EXPECT_EQ(verbose, stream.getOutputLevel());
- EXPECT_EQ(context::unittest().mask, stream.getOutputContext()->mask);
- EXPECT_EQ(context::unittest().name, stream.getOutputContext()->name);
- EXPECT_EQ(context::unittest().sub_id, stream.getOutputContext()->sub_id);
- }
-
- TEST(OutputTest, OrxoutAcceptsFunctionPointer)
- {
- const OutputStream& stream = orxout(verbose, context::unittest);
- EXPECT_EQ(verbose, stream.getOutputLevel());
- EXPECT_EQ(context::unittest().mask, stream.getOutputContext()->mask);
- EXPECT_EQ(context::unittest().name, stream.getOutputContext()->name);
- EXPECT_EQ(context::unittest().sub_id, stream.getOutputContext()->sub_id);
- }
-}
+#include <gtest/gtest.h>
+#include "util/Output.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest);
+ }
+ }
+
+ TEST(OutputTest, CanUseOrxout)
+ {
+ orxout() << "test" << endl;
+ }
+
+ TEST(OutputTest, OrxoutUsesCorrectOutputLevel)
+ {
+ {
+ const OutputStream& stream = orxout(internal_warning);
+ EXPECT_EQ(internal_warning, stream.getOutputLevel());
+ }
+
+ {
+ const OutputStream& stream = orxout(debug_output);
+ EXPECT_EQ(debug_output, stream.getOutputLevel());
+ }
+ }
+
+ TEST(OutputTest, OrxoutUsesCorrectOutputContext)
+ {
+ const OutputStream& stream = orxout(verbose, context::unittest());
+ EXPECT_EQ(verbose, stream.getOutputLevel());
+ EXPECT_EQ(context::unittest().mask, stream.getOutputContext()->mask);
+ EXPECT_EQ(context::unittest().name, stream.getOutputContext()->name);
+ EXPECT_EQ(context::unittest().sub_id, stream.getOutputContext()->sub_id);
+ }
+
+ TEST(OutputTest, OrxoutAcceptsFunctionPointer)
+ {
+ const OutputStream& stream = orxout(verbose, context::unittest);
+ EXPECT_EQ(verbose, stream.getOutputLevel());
+ EXPECT_EQ(context::unittest().mask, stream.getOutputContext()->mask);
+ EXPECT_EQ(context::unittest().name, stream.getOutputContext()->name);
+ EXPECT_EQ(context::unittest().sub_id, stream.getOutputContext()->sub_id);
+ }
+}
Property changes on: code/branches/testing/test/util/OutputTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/BaseWriterTest.cc
===================================================================
--- code/branches/testing/test/util/output/BaseWriterTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/BaseWriterTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,176 +1,176 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-#include "util/Output.h"
-#include "util/output/BaseWriter.h"
-#include "util/output/OutputManager.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest1);
- REGISTER_OUTPUT_CONTEXT(unittest2);
- REGISTER_OUTPUT_CONTEXT(unittest3);
-
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
- }
- }
-
- namespace
- {
- class MockBaseWriter : public BaseWriter
- {
- public:
- MockBaseWriter(const std::string& name, bool bRegister = true) : BaseWriter(name, bRegister) {}
-
- MOCK_METHOD2(printLine, void(const std::string&, OutputLevel));
-
- virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
- { this->BaseWriter::output(level, context, lines); }
- };
- }
-
- // test getName
- TEST(BaseWriterTest, GetName)
- {
- MockBaseWriter writer("mytestname");
- EXPECT_EQ("mytestname", writer.getName());
- }
-
- // test configurable names contain name
- TEST(BaseWriterTest, ConfigurableNamesContainName)
- {
- MockBaseWriter writer("mytestname");
- EXPECT_NE(writer.getConfigurableMaxLevelName().find(writer.getName()), std::string::npos);
- EXPECT_NE(writer.getConfigurableAdditionalContextsMaxLevelName().find(writer.getName()), std::string::npos);
- EXPECT_NE(writer.getConfigurableAdditionalContextsName().find(writer.getName()), std::string::npos);
-
- // but the section name is 'static' (does not contain the name)
- EXPECT_EQ(writer.getConfigurableSectionName().find(writer.getName()), std::string::npos);
- }
-
- // output calls printLine for each line
- TEST(BaseWriterTest, OutputCallsPrintLine)
- {
- MockBaseWriter writer("mytestname");
-
- std::vector<std::string> lines;
- lines.push_back("line1");
- lines.push_back("line2");
-
- EXPECT_CALL(writer, printLine(::testing::_, level::debug_output)).Times(2);
-
- writer.output(level::debug_output, context::undefined(), lines);
- }
-
- // output adds prefix to first line
- TEST(BaseWriterTest, OutputAddsPrefixToFirstLine)
- {
- MockBaseWriter writer("mytestname");
-
- std::vector<std::string> lines;
- lines.push_back("line1");
-
- std::string prefix = OutputManager::getInstance().getDefaultPrefix(level::debug_output, context::undefined());
- EXPECT_CALL(writer, printLine(prefix + "line1", level::debug_output));
-
- writer.output(level::debug_output, context::undefined(), lines);
- }
-
- // setLevelMax sets level max
- void testLevelMaxUserWarning(OutputLevel mask)
- {
- EXPECT_FALSE(mask & level::none);
- EXPECT_TRUE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_TRUE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- EXPECT_FALSE(mask & level::verbose);
- }
-
- TEST(BaseWriterTest, SetLevelMax)
- {
- MockBaseWriter writer("mytestname");
-
- writer.setLevelMax(level::user_warning);
- testLevelMaxUserWarning(writer.getLevelMask());
- }
-
- // setAdditionalContextsLevelMax sets additional contexts level max
- TEST(BaseWriterTest, SetAdditionalContextsLevelMax)
- {
- MockBaseWriter writer("mytestname");
-
- writer.setAdditionalContextsLevelMax(level::user_warning);
- testLevelMaxUserWarning(writer.getAdditionalContextsLevelMask());
- }
-
- // changedConfigurableLevel sets max level to configurableMaxLevel_
- TEST(BaseWriterTest, ChangedConfigurableLevel)
- {
- MockBaseWriter writer("mytestname");
-
- writer.configurableMaxLevel_ = level::user_warning;
- writer.changedConfigurableLevel();
-
- testLevelMaxUserWarning(writer.getLevelMask());
- }
-
- // changedConfigurableAdditionalContextsLevel sets additional contexts level max to configurableAdditionalContextsMaxLevel_
- TEST(BaseWriterTest, ChangedConfigurableAdditionalContextsLevel)
- {
- MockBaseWriter writer("mytestname");
-
- writer.configurableAdditionalContextsMaxLevel_ = level::user_warning;
- writer.changedConfigurableAdditionalContextsLevel();
-
- testLevelMaxUserWarning(writer.getAdditionalContextsLevelMask());
- }
-
- // changedConfigurableAdditionalContexts sets additional contexts to configurableAdditionalContexts_
- TEST(BaseWriterTest, ChangedConfigurableAdditionalContexts)
- {
- MockBaseWriter writer("mytestname");
-
- writer.configurableAdditionalContexts_.push_back("unittest1");
- writer.changedConfigurableAdditionalContexts();
-
- EXPECT_TRUE(writer.getAdditionalContextsMask() & context::unittest1().mask);
- }
-
- // contexts added by name
- TEST(BaseWriterTest, DefineContextsByName)
- {
- MockBaseWriter writer("mytestname");
-
- writer.configurableAdditionalContexts_.push_back("unittest1");
- writer.configurableAdditionalContexts_.push_back("unittest2");
- writer.changedConfigurableAdditionalContexts();
-
- EXPECT_TRUE(writer.acceptsOutput(level::message, context::unittest1()));
- EXPECT_TRUE(writer.acceptsOutput(level::message, context::unittest2()));
- EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
- }
-
- // subcontexts added by name, separated from base context with "::"
- TEST(BaseWriterTest, DefineSubcontextsByName)
- {
- MockBaseWriter writer("mytestname");
-
- writer.configurableAdditionalContexts_.push_back("unittest3::sub1");
- writer.configurableAdditionalContexts_.push_back("unittest3::sub3");
- writer.changedConfigurableAdditionalContexts();
-
- EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
- EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
- EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
- EXPECT_TRUE(writer.acceptsOutput(level::message, context::sub1()));
- EXPECT_FALSE(writer.acceptsOutput(level::message, context::sub2()));
- EXPECT_TRUE(writer.acceptsOutput(level::message, context::sub3()));
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "util/Output.h"
+#include "util/output/BaseWriter.h"
+#include "util/output/OutputManager.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest1);
+ REGISTER_OUTPUT_CONTEXT(unittest2);
+ REGISTER_OUTPUT_CONTEXT(unittest3);
+
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
+ }
+ }
+
+ namespace
+ {
+ class MockBaseWriter : public BaseWriter
+ {
+ public:
+ MockBaseWriter(const std::string& name, bool bRegister = true) : BaseWriter(name, bRegister) {}
+
+ MOCK_METHOD2(printLine, void(const std::string&, OutputLevel));
+
+ virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
+ { this->BaseWriter::output(level, context, lines); }
+ };
+ }
+
+ // test getName
+ TEST(BaseWriterTest, GetName)
+ {
+ MockBaseWriter writer("mytestname");
+ EXPECT_EQ("mytestname", writer.getName());
+ }
+
+ // test configurable names contain name
+ TEST(BaseWriterTest, ConfigurableNamesContainName)
+ {
+ MockBaseWriter writer("mytestname");
+ EXPECT_NE(writer.getConfigurableMaxLevelName().find(writer.getName()), std::string::npos);
+ EXPECT_NE(writer.getConfigurableAdditionalContextsMaxLevelName().find(writer.getName()), std::string::npos);
+ EXPECT_NE(writer.getConfigurableAdditionalContextsName().find(writer.getName()), std::string::npos);
+
+ // but the section name is 'static' (does not contain the name)
+ EXPECT_EQ(writer.getConfigurableSectionName().find(writer.getName()), std::string::npos);
+ }
+
+ // output calls printLine for each line
+ TEST(BaseWriterTest, OutputCallsPrintLine)
+ {
+ MockBaseWriter writer("mytestname");
+
+ std::vector<std::string> lines;
+ lines.push_back("line1");
+ lines.push_back("line2");
+
+ EXPECT_CALL(writer, printLine(::testing::_, level::debug_output)).Times(2);
+
+ writer.output(level::debug_output, context::undefined(), lines);
+ }
+
+ // output adds prefix to first line
+ TEST(BaseWriterTest, OutputAddsPrefixToFirstLine)
+ {
+ MockBaseWriter writer("mytestname");
+
+ std::vector<std::string> lines;
+ lines.push_back("line1");
+
+ std::string prefix = OutputManager::getInstance().getDefaultPrefix(level::debug_output, context::undefined());
+ EXPECT_CALL(writer, printLine(prefix + "line1", level::debug_output));
+
+ writer.output(level::debug_output, context::undefined(), lines);
+ }
+
+ // setLevelMax sets level max
+ void testLevelMaxUserWarning(OutputLevel mask)
+ {
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_TRUE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_TRUE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ EXPECT_FALSE(mask & level::verbose);
+ }
+
+ TEST(BaseWriterTest, SetLevelMax)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.setLevelMax(level::user_warning);
+ testLevelMaxUserWarning(writer.getLevelMask());
+ }
+
+ // setAdditionalContextsLevelMax sets additional contexts level max
+ TEST(BaseWriterTest, SetAdditionalContextsLevelMax)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.setAdditionalContextsLevelMax(level::user_warning);
+ testLevelMaxUserWarning(writer.getAdditionalContextsLevelMask());
+ }
+
+ // changedConfigurableLevel sets max level to configurableMaxLevel_
+ TEST(BaseWriterTest, ChangedConfigurableLevel)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.configurableMaxLevel_ = level::user_warning;
+ writer.changedConfigurableLevel();
+
+ testLevelMaxUserWarning(writer.getLevelMask());
+ }
+
+ // changedConfigurableAdditionalContextsLevel sets additional contexts level max to configurableAdditionalContextsMaxLevel_
+ TEST(BaseWriterTest, ChangedConfigurableAdditionalContextsLevel)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.configurableAdditionalContextsMaxLevel_ = level::user_warning;
+ writer.changedConfigurableAdditionalContextsLevel();
+
+ testLevelMaxUserWarning(writer.getAdditionalContextsLevelMask());
+ }
+
+ // changedConfigurableAdditionalContexts sets additional contexts to configurableAdditionalContexts_
+ TEST(BaseWriterTest, ChangedConfigurableAdditionalContexts)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.configurableAdditionalContexts_.push_back("unittest1");
+ writer.changedConfigurableAdditionalContexts();
+
+ EXPECT_TRUE(writer.getAdditionalContextsMask() & context::unittest1().mask);
+ }
+
+ // contexts added by name
+ TEST(BaseWriterTest, DefineContextsByName)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.configurableAdditionalContexts_.push_back("unittest1");
+ writer.configurableAdditionalContexts_.push_back("unittest2");
+ writer.changedConfigurableAdditionalContexts();
+
+ EXPECT_TRUE(writer.acceptsOutput(level::message, context::unittest1()));
+ EXPECT_TRUE(writer.acceptsOutput(level::message, context::unittest2()));
+ EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
+ }
+
+ // subcontexts added by name, separated from base context with "::"
+ TEST(BaseWriterTest, DefineSubcontextsByName)
+ {
+ MockBaseWriter writer("mytestname");
+
+ writer.configurableAdditionalContexts_.push_back("unittest3::sub1");
+ writer.configurableAdditionalContexts_.push_back("unittest3::sub3");
+ writer.changedConfigurableAdditionalContexts();
+
+ EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
+ EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
+ EXPECT_FALSE(writer.acceptsOutput(level::message, context::unittest3()));
+ EXPECT_TRUE(writer.acceptsOutput(level::message, context::sub1()));
+ EXPECT_FALSE(writer.acceptsOutput(level::message, context::sub2()));
+ EXPECT_TRUE(writer.acceptsOutput(level::message, context::sub3()));
+ }
+}
Property changes on: code/branches/testing/test/util/output/BaseWriterTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/ConsoleWriterTest.cc
===================================================================
--- code/branches/testing/test/util/output/ConsoleWriterTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/ConsoleWriterTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,70 +1,70 @@
-#include <gtest/gtest.h>
-#include "util/Output.h"
-#include "util/output/ConsoleWriter.h"
-#include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
-
-namespace orxonox
-{
- TEST(ConsoleWriterTest, Disable)
- {
- // reset output manager
- OutputManager::Testing::getInstancePointer() = new OutputManager();
-
- std::ostream stream(NULL);
- EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
- ConsoleWriter writer(stream);
- EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
- writer.disable();
- EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
- }
-
- TEST(ConsoleWriterTest, Enable)
- {
- // reset output manager
- OutputManager::Testing::getInstancePointer() = new OutputManager();
-
- std::ostream stream(NULL);
- ConsoleWriter writer(stream);
- writer.disable();
- EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
- writer.enable();
- EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
- }
-
- TEST(ConsoleWriterTest, WritesNoOutputToOutputStream)
- {
- std::stringbuf buffer;
- std::ostream stream(&buffer);
- ConsoleWriter writer(stream);
- writer.setLevelMax(level::verbose);
-
- EXPECT_EQ(0, buffer.in_avail());
- EXPECT_EQ("", buffer.str());
- }
-
- TEST(ConsoleWriterTest, WritesOutputToOutputStream)
- {
- std::stringbuf buffer;
- std::ostream stream(&buffer);
- ConsoleWriter writer(stream);
- writer.setLevelMax(level::verbose);
-
- std::vector<std::string> lines;
- lines.push_back("test");
-
- EXPECT_TRUE(writer.acceptsOutput(level::debug_output, context::undefined()));
-
- writer.unfilteredOutput(level::debug_output, context::undefined(), lines);
-
- EXPECT_LT(0, buffer.in_avail());
- EXPECT_NE("", buffer.str());
- EXPECT_NE(std::string::npos, buffer.str().find("test"));
- }
-
- TEST(ConsoleWriterTest, DefaultConsoleWriterUsesCout)
- {
- OutputManager::getInstanceAndCreateListeners();
- EXPECT_EQ(std::cout, OutputManager::getInstance().getConsoleWriter().getOutputStream());
- }
-}
+#include <gtest/gtest.h>
+#include "util/Output.h"
+#include "util/output/ConsoleWriter.h"
+#include "util/output/OutputManager.h"
+#include "util/SharedPtr.h"
+
+namespace orxonox
+{
+ TEST(ConsoleWriterTest, Disable)
+ {
+ // reset output manager
+ OutputManager::Testing::getInstancePointer() = new OutputManager();
+
+ std::ostream stream(NULL);
+ EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
+ ConsoleWriter writer(stream);
+ EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
+ writer.disable();
+ EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
+ }
+
+ TEST(ConsoleWriterTest, Enable)
+ {
+ // reset output manager
+ OutputManager::Testing::getInstancePointer() = new OutputManager();
+
+ std::ostream stream(NULL);
+ ConsoleWriter writer(stream);
+ writer.disable();
+ EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
+ writer.enable();
+ EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
+ }
+
+ TEST(ConsoleWriterTest, WritesNoOutputToOutputStream)
+ {
+ std::stringbuf buffer;
+ std::ostream stream(&buffer);
+ ConsoleWriter writer(stream);
+ writer.setLevelMax(level::verbose);
+
+ EXPECT_EQ(0, buffer.in_avail());
+ EXPECT_EQ("", buffer.str());
+ }
+
+ TEST(ConsoleWriterTest, WritesOutputToOutputStream)
+ {
+ std::stringbuf buffer;
+ std::ostream stream(&buffer);
+ ConsoleWriter writer(stream);
+ writer.setLevelMax(level::verbose);
+
+ std::vector<std::string> lines;
+ lines.push_back("test");
+
+ EXPECT_TRUE(writer.acceptsOutput(level::debug_output, context::undefined()));
+
+ writer.unfilteredOutput(level::debug_output, context::undefined(), lines);
+
+ EXPECT_LT(0, buffer.in_avail());
+ EXPECT_NE("", buffer.str());
+ EXPECT_NE(std::string::npos, buffer.str().find("test"));
+ }
+
+ TEST(ConsoleWriterTest, DefaultConsoleWriterUsesCout)
+ {
+ OutputManager::getInstanceAndCreateListeners();
+ EXPECT_EQ(std::cout, OutputManager::getInstance().getConsoleWriter().getOutputStream());
+ }
+}
Property changes on: code/branches/testing/test/util/output/ConsoleWriterTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/LogWriterTest.cc
===================================================================
--- code/branches/testing/test/util/output/LogWriterTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/LogWriterTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,223 +1,223 @@
-#include <gtest/gtest.h>
-#include "util/Output.h"
-#include "util/output/LogWriter.h"
-#include "util/Convert.h"
-
-namespace orxonox
-{
- namespace
- {
- class MockLogWriter : public LogWriter
- {
- public:
- virtual void printLine(const std::string& line, OutputLevel level)
- { this->LogWriter::printLine(line, level); }
- };
- }
-
- // test constructor opens file
- TEST(LogWriterTest, ConstructorOpensFile)
- {
- LogWriter logWriter;
- EXPECT_TRUE(logWriter.getFile().is_open());
- }
-
- // setLogDirectory changes file, opens correct file
- bool fileExists(const std::string& path)
- {
- std::ifstream stream(path.c_str());
- bool exists = stream.is_open() && stream.good();
- stream.close();
- return exists;
- }
-
- std::string getLineWhichContains(const std::string& path, const std::string& message)
- {
- std::ifstream file(path.c_str());
- EXPECT_TRUE(file.is_open());
- EXPECT_TRUE(file.good());
- EXPECT_FALSE(file.eof());
-
- while (file.is_open() && file.good() && !file.eof())
- {
- std::string line;
- std::getline(file, line);
-
- // see if we find the output and return
- if (line.find(message) == (line.size() - message.size()))
- return line;
- }
-
- return std::string();
- }
-
- bool fileContains(const std::string& path, const std::string& message)
- {
- return !getLineWhichContains(path, message).empty();
- }
-
- bool deleteFile(const std::string& path)
- {
- bool result = std::remove(path.c_str()) == 0;
- EXPECT_FALSE(fileExists(path));
- return result;
- }
-
- TEST(LogWriterTest, SetLogDirectoryOpensNewFile)
- {
- std::string path = "./orxonox.log";
-
- // cleanup before test
- deleteFile(path);
-
- {
- LogWriter logWriter;
- EXPECT_FALSE(fileExists(path));
- logWriter.setLogDirectory(".");
- EXPECT_TRUE(fileExists(path));
- }
-
- // cleanup after test
- EXPECT_TRUE(deleteFile(path));
- }
-
- // prints output to logfile
- TEST(LogWriterTest, PrintsOutputToLogfile)
- {
- std::string path;
-
- {
- // write lines to log file
- std::vector<std::string> lines;
- lines.push_back("mytestoutput");
-
- LogWriter logWriter;
- logWriter.setLogDirectory(".");
- logWriter.unfilteredOutput(level::debug_output, context::undefined(), lines);
-
- path = logWriter.getPath();
- }
-
- EXPECT_TRUE(fileContains(path, "mytestoutput"));
- }
-
- // prints time to logfile
- TEST(LogWriterTest, PrintsTimestampToLogfile)
- {
- std::string path;
-
- {
- // write lines to log file
- std::vector<std::string> lines;
- lines.push_back("myothertestoutput");
-
- LogWriter logWriter;
- logWriter.setLogDirectory(".");
- logWriter.unfilteredOutput(level::debug_output, context::undefined(), lines);
-
- path = logWriter.getPath();
- }
-
- std::string line = getLineWhichContains(path, "myothertestoutput");
- EXPECT_FALSE(line.empty());
- EXPECT_TRUE(std::isdigit(line[0]));
- EXPECT_TRUE(std::isdigit(line[1]));
- EXPECT_EQ(':', line[2]);
- EXPECT_TRUE(std::isdigit(line[3]));
- EXPECT_TRUE(std::isdigit(line[4]));
- EXPECT_EQ(':', line[5]);
- EXPECT_TRUE(std::isdigit(line[6]));
- EXPECT_TRUE(std::isdigit(line[7]));
- EXPECT_EQ(' ', line[8]);
- }
-
- void deleteAllLogFiles()
- {
- std::string path;
- {
- LogWriter writer;
- path = writer.getPath();
- }
-
- deleteFile(path);
- deleteFile(path + ".1");
- deleteFile(path + ".2");
- deleteFile(path + ".3");
- deleteFile(path + ".4");
- deleteFile(path + ".5");
- deleteFile(path + ".6");
- deleteFile(path + ".7");
- deleteFile(path + ".8");
- deleteFile(path + ".9");
- }
-
- TEST(LogWriterTest, ArchivesOldLogFile)
- {
- deleteAllLogFiles();
-
- std::string path;
-
- {
- MockLogWriter writer;
- path = writer.getPath();
- writer.printLine("test1", level::message);
- }
-
- EXPECT_TRUE(fileExists(path));
- EXPECT_TRUE(fileContains(path, "test1"));
- EXPECT_FALSE(fileExists(path + ".1"));
- EXPECT_FALSE(fileExists(path + ".2"));
- EXPECT_FALSE(fileExists(path + ".3"));
-
- {
- MockLogWriter writer;
- writer.printLine("test2", level::message);
- }
-
- EXPECT_TRUE(fileExists(path));
- EXPECT_TRUE(fileContains(path, "test2"));
- EXPECT_TRUE(fileExists(path + ".1"));
- EXPECT_TRUE(fileContains(path + ".1", "test1"));
- EXPECT_FALSE(fileExists(path + ".2"));
- EXPECT_FALSE(fileExists(path + ".3"));
-
- {
- MockLogWriter writer;
- writer.printLine("test3", level::message);
- }
-
- EXPECT_TRUE(fileExists(path));
- EXPECT_TRUE(fileContains(path, "test3"));
- EXPECT_TRUE(fileExists(path + ".1"));
- EXPECT_TRUE(fileContains(path + ".1", "test2"));
- EXPECT_TRUE(fileExists(path + ".2"));
- EXPECT_TRUE(fileContains(path + ".2", "test1"));
- EXPECT_FALSE(fileExists(path + ".3"));
- }
-
- TEST(LogWriterTest, ArchivesNineLogFiles)
- {
- deleteAllLogFiles();
-
- std::string path;
- for (int i = 0; i < 20; ++i)
- {
- MockLogWriter writer;
- path = writer.getPath();
- writer.printLine("test" + multi_cast<std::string>(i), level::message);
- }
-
- EXPECT_TRUE(fileContains(path, "test19"));
- EXPECT_TRUE(fileContains(path + ".1", "test18"));
- EXPECT_TRUE(fileContains(path + ".2", "test17"));
- EXPECT_TRUE(fileContains(path + ".3", "test16"));
- EXPECT_TRUE(fileContains(path + ".4", "test15"));
- EXPECT_TRUE(fileContains(path + ".5", "test14"));
- EXPECT_TRUE(fileContains(path + ".6", "test13"));
- EXPECT_TRUE(fileContains(path + ".7", "test12"));
- EXPECT_TRUE(fileContains(path + ".8", "test11"));
- EXPECT_TRUE(fileContains(path + ".9", "test10"));
- EXPECT_FALSE(fileExists(path + ".10"));
- EXPECT_FALSE(fileExists(path + ".11"));
- }
-}
+#include <gtest/gtest.h>
+#include "util/Output.h"
+#include "util/output/LogWriter.h"
+#include "util/Convert.h"
+
+namespace orxonox
+{
+ namespace
+ {
+ class MockLogWriter : public LogWriter
+ {
+ public:
+ virtual void printLine(const std::string& line, OutputLevel level)
+ { this->LogWriter::printLine(line, level); }
+ };
+ }
+
+ // test constructor opens file
+ TEST(LogWriterTest, ConstructorOpensFile)
+ {
+ LogWriter logWriter;
+ EXPECT_TRUE(logWriter.getFile().is_open());
+ }
+
+ // setLogDirectory changes file, opens correct file
+ bool fileExists(const std::string& path)
+ {
+ std::ifstream stream(path.c_str());
+ bool exists = stream.is_open() && stream.good();
+ stream.close();
+ return exists;
+ }
+
+ std::string getLineWhichContains(const std::string& path, const std::string& message)
+ {
+ std::ifstream file(path.c_str());
+ EXPECT_TRUE(file.is_open());
+ EXPECT_TRUE(file.good());
+ EXPECT_FALSE(file.eof());
+
+ while (file.is_open() && file.good() && !file.eof())
+ {
+ std::string line;
+ std::getline(file, line);
+
+ // see if we find the output and return
+ if (line.find(message) == (line.size() - message.size()))
+ return line;
+ }
+
+ return std::string();
+ }
+
+ bool fileContains(const std::string& path, const std::string& message)
+ {
+ return !getLineWhichContains(path, message).empty();
+ }
+
+ bool deleteFile(const std::string& path)
+ {
+ bool result = std::remove(path.c_str()) == 0;
+ EXPECT_FALSE(fileExists(path));
+ return result;
+ }
+
+ TEST(LogWriterTest, SetLogDirectoryOpensNewFile)
+ {
+ std::string path = "./orxonox.log";
+
+ // cleanup before test
+ deleteFile(path);
+
+ {
+ LogWriter logWriter;
+ EXPECT_FALSE(fileExists(path));
+ logWriter.setLogDirectory(".");
+ EXPECT_TRUE(fileExists(path));
+ }
+
+ // cleanup after test
+ EXPECT_TRUE(deleteFile(path));
+ }
+
+ // prints output to logfile
+ TEST(LogWriterTest, PrintsOutputToLogfile)
+ {
+ std::string path;
+
+ {
+ // write lines to log file
+ std::vector<std::string> lines;
+ lines.push_back("mytestoutput");
+
+ LogWriter logWriter;
+ logWriter.setLogDirectory(".");
+ logWriter.unfilteredOutput(level::debug_output, context::undefined(), lines);
+
+ path = logWriter.getPath();
+ }
+
+ EXPECT_TRUE(fileContains(path, "mytestoutput"));
+ }
+
+ // prints time to logfile
+ TEST(LogWriterTest, PrintsTimestampToLogfile)
+ {
+ std::string path;
+
+ {
+ // write lines to log file
+ std::vector<std::string> lines;
+ lines.push_back("myothertestoutput");
+
+ LogWriter logWriter;
+ logWriter.setLogDirectory(".");
+ logWriter.unfilteredOutput(level::debug_output, context::undefined(), lines);
+
+ path = logWriter.getPath();
+ }
+
+ std::string line = getLineWhichContains(path, "myothertestoutput");
+ EXPECT_FALSE(line.empty());
+ EXPECT_TRUE(std::isdigit(line[0]));
+ EXPECT_TRUE(std::isdigit(line[1]));
+ EXPECT_EQ(':', line[2]);
+ EXPECT_TRUE(std::isdigit(line[3]));
+ EXPECT_TRUE(std::isdigit(line[4]));
+ EXPECT_EQ(':', line[5]);
+ EXPECT_TRUE(std::isdigit(line[6]));
+ EXPECT_TRUE(std::isdigit(line[7]));
+ EXPECT_EQ(' ', line[8]);
+ }
+
+ void deleteAllLogFiles()
+ {
+ std::string path;
+ {
+ LogWriter writer;
+ path = writer.getPath();
+ }
+
+ deleteFile(path);
+ deleteFile(path + ".1");
+ deleteFile(path + ".2");
+ deleteFile(path + ".3");
+ deleteFile(path + ".4");
+ deleteFile(path + ".5");
+ deleteFile(path + ".6");
+ deleteFile(path + ".7");
+ deleteFile(path + ".8");
+ deleteFile(path + ".9");
+ }
+
+ TEST(LogWriterTest, ArchivesOldLogFile)
+ {
+ deleteAllLogFiles();
+
+ std::string path;
+
+ {
+ MockLogWriter writer;
+ path = writer.getPath();
+ writer.printLine("test1", level::message);
+ }
+
+ EXPECT_TRUE(fileExists(path));
+ EXPECT_TRUE(fileContains(path, "test1"));
+ EXPECT_FALSE(fileExists(path + ".1"));
+ EXPECT_FALSE(fileExists(path + ".2"));
+ EXPECT_FALSE(fileExists(path + ".3"));
+
+ {
+ MockLogWriter writer;
+ writer.printLine("test2", level::message);
+ }
+
+ EXPECT_TRUE(fileExists(path));
+ EXPECT_TRUE(fileContains(path, "test2"));
+ EXPECT_TRUE(fileExists(path + ".1"));
+ EXPECT_TRUE(fileContains(path + ".1", "test1"));
+ EXPECT_FALSE(fileExists(path + ".2"));
+ EXPECT_FALSE(fileExists(path + ".3"));
+
+ {
+ MockLogWriter writer;
+ writer.printLine("test3", level::message);
+ }
+
+ EXPECT_TRUE(fileExists(path));
+ EXPECT_TRUE(fileContains(path, "test3"));
+ EXPECT_TRUE(fileExists(path + ".1"));
+ EXPECT_TRUE(fileContains(path + ".1", "test2"));
+ EXPECT_TRUE(fileExists(path + ".2"));
+ EXPECT_TRUE(fileContains(path + ".2", "test1"));
+ EXPECT_FALSE(fileExists(path + ".3"));
+ }
+
+ TEST(LogWriterTest, ArchivesNineLogFiles)
+ {
+ deleteAllLogFiles();
+
+ std::string path;
+ for (int i = 0; i < 20; ++i)
+ {
+ MockLogWriter writer;
+ path = writer.getPath();
+ writer.printLine("test" + multi_cast<std::string>(i), level::message);
+ }
+
+ EXPECT_TRUE(fileContains(path, "test19"));
+ EXPECT_TRUE(fileContains(path + ".1", "test18"));
+ EXPECT_TRUE(fileContains(path + ".2", "test17"));
+ EXPECT_TRUE(fileContains(path + ".3", "test16"));
+ EXPECT_TRUE(fileContains(path + ".4", "test15"));
+ EXPECT_TRUE(fileContains(path + ".5", "test14"));
+ EXPECT_TRUE(fileContains(path + ".6", "test13"));
+ EXPECT_TRUE(fileContains(path + ".7", "test12"));
+ EXPECT_TRUE(fileContains(path + ".8", "test11"));
+ EXPECT_TRUE(fileContains(path + ".9", "test10"));
+ EXPECT_FALSE(fileExists(path + ".10"));
+ EXPECT_FALSE(fileExists(path + ".11"));
+ }
+}
Property changes on: code/branches/testing/test/util/output/LogWriterTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/MemoryWriterTest.cc
===================================================================
--- code/branches/testing/test/util/output/MemoryWriterTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/MemoryWriterTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,46 +1,46 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-#include "util/Output.h"
-#include "util/output/MemoryWriter.h"
-#include "util/output/OutputManager.h"
-
-namespace orxonox
-{
- namespace
- {
- class MockOutputListener : public OutputListener
- {
- public:
- MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
- };
- }
-
- TEST(MemoryWriterTest, Disable)
- {
- EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
- MemoryWriter writer;
- EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
- writer.disable();
- EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
- }
-
- TEST(MemoryWriterTest, ResendOutput)
- {
- MemoryWriter writer;
-
- std::vector<std::string> lines;
- lines.push_back("random line of output");
- lines.push_back("another line of output");
-
- writer.unfilteredOutput(level::user_info, context::undefined(), lines);
- writer.unfilteredOutput(level::verbose, context::xml(), lines);
-
- MockOutputListener other;
- other.setLevelMask(level::all);
-
- EXPECT_CALL(other, output(level::user_info, context::undefined(), lines));
- EXPECT_CALL(other, output(level::verbose, context::xml(), lines));
-
- writer.resendOutput(&other);
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "util/Output.h"
+#include "util/output/MemoryWriter.h"
+#include "util/output/OutputManager.h"
+
+namespace orxonox
+{
+ namespace
+ {
+ class MockOutputListener : public OutputListener
+ {
+ public:
+ MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
+ };
+ }
+
+ TEST(MemoryWriterTest, Disable)
+ {
+ EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
+ MemoryWriter writer;
+ EXPECT_EQ(1U, OutputManager::getInstance().getListeners().size());
+ writer.disable();
+ EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
+ }
+
+ TEST(MemoryWriterTest, ResendOutput)
+ {
+ MemoryWriter writer;
+
+ std::vector<std::string> lines;
+ lines.push_back("random line of output");
+ lines.push_back("another line of output");
+
+ writer.unfilteredOutput(level::user_info, context::undefined(), lines);
+ writer.unfilteredOutput(level::verbose, context::xml(), lines);
+
+ MockOutputListener other;
+ other.setLevelMask(level::all);
+
+ EXPECT_CALL(other, output(level::user_info, context::undefined(), lines));
+ EXPECT_CALL(other, output(level::verbose, context::xml(), lines));
+
+ writer.resendOutput(&other);
+ }
+}
Property changes on: code/branches/testing/test/util/output/MemoryWriterTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/OutputDefinitionsTest.cc
===================================================================
--- code/branches/testing/test/util/output/OutputDefinitionsTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/OutputDefinitionsTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,46 +1,46 @@
-#include <gtest/gtest.h>
-#include "util/Output.h"
-
-namespace orxonox
-{
- TEST(OutputDefinitionsTest, Levels)
- {
- EXPECT_EQ(0x0000, level::none);
- }
-
- TEST(OutputDefinitionsTest, OutputContextContainer)
- {
- OutputContextContainer container1;
- container1.mask = 1;
- container1.sub_id = 1;
- container1.name = "1";
-
- OutputContextContainer container2;
- container2.mask = 1;
- container2.sub_id = 1;
- container2.name = "1";
-
- EXPECT_TRUE(container1 == container2);
-
- {
- OutputContextContainer container3(container2);
- EXPECT_TRUE(container1 == container3);
- container3.mask = 2;
- EXPECT_FALSE(container1 == container3);
- }
-
- {
- OutputContextContainer container3(container2);
- EXPECT_TRUE(container1 == container3);
- container3.sub_id = 2;
- EXPECT_FALSE(container1 == container3);
- }
-
- {
- OutputContextContainer container3(container2);
- EXPECT_TRUE(container1 == container3);
- container3.name = "2";
- EXPECT_FALSE(container1 == container3);
- }
- }
-}
+#include <gtest/gtest.h>
+#include "util/Output.h"
+
+namespace orxonox
+{
+ TEST(OutputDefinitionsTest, Levels)
+ {
+ EXPECT_EQ(0x0000, level::none);
+ }
+
+ TEST(OutputDefinitionsTest, OutputContextContainer)
+ {
+ OutputContextContainer container1;
+ container1.mask = 1;
+ container1.sub_id = 1;
+ container1.name = "1";
+
+ OutputContextContainer container2;
+ container2.mask = 1;
+ container2.sub_id = 1;
+ container2.name = "1";
+
+ EXPECT_TRUE(container1 == container2);
+
+ {
+ OutputContextContainer container3(container2);
+ EXPECT_TRUE(container1 == container3);
+ container3.mask = 2;
+ EXPECT_FALSE(container1 == container3);
+ }
+
+ {
+ OutputContextContainer container3(container2);
+ EXPECT_TRUE(container1 == container3);
+ container3.sub_id = 2;
+ EXPECT_FALSE(container1 == container3);
+ }
+
+ {
+ OutputContextContainer container3(container2);
+ EXPECT_TRUE(container1 == container3);
+ container3.name = "2";
+ EXPECT_FALSE(container1 == container3);
+ }
+ }
+}
Property changes on: code/branches/testing/test/util/output/OutputDefinitionsTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/OutputListenerTest.cc
===================================================================
--- code/branches/testing/test/util/output/OutputListenerTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/OutputListenerTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,376 +1,376 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-#include "util/output/OutputListener.h"
-#include "util/output/OutputManager.h"
-#include "util/SharedPtr.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest1);
- REGISTER_OUTPUT_CONTEXT(unittest2);
- REGISTER_OUTPUT_CONTEXT(unittest3);
- }
- }
-
- namespace
- {
- class MockOutputListener : public OutputListener
- {
- 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(OutputListenerTest, DefaultConstructorAcceptsNothing)
- {
- MockOutputListener listener;
-
- EXPECT_EQ(level::none, listener.getLevelMask());
- EXPECT_EQ(level::none, listener.getAdditionalContextsLevelMask());
- EXPECT_EQ(context::none, listener.getAdditionalContextsMask());
- }
-
- // test setLevelMax
- TEST(OutputListenerTest, SetLevelMax)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
-
- OutputLevel mask = listener.getLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_TRUE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_TRUE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setLevelRange
- TEST(OutputListenerTest, SetLevelRange)
- {
- MockOutputListener listener;
-
- listener.setLevelRange(level::debug_output, level::user_warning);
-
- OutputLevel mask = listener.getLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_FALSE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_TRUE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setLevelMask
- TEST(OutputListenerTest, SetLevelMask)
- {
- MockOutputListener listener;
-
- listener.setLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
-
- OutputLevel mask = listener.getLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_FALSE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_FALSE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setAdditionalContextsLevelMax
- TEST(OutputListenerTest, SetAdditionalContextsLevelMax)
- {
- MockOutputListener listener;
-
- listener.setAdditionalContextsLevelMax(level::user_warning);
-
- OutputLevel mask = listener.getAdditionalContextsLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_TRUE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_TRUE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setAdditionalContextsLevelRange
- TEST(OutputListenerTest, SetAdditionalContextsLevelRange)
- {
- MockOutputListener listener;
-
- listener.setAdditionalContextsLevelRange(level::debug_output, level::user_warning);
-
- OutputLevel mask = listener.getAdditionalContextsLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_FALSE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_TRUE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setAdditionalContextsLevelMask
- TEST(OutputListenerTest, SetAdditionalContextsLevelMask)
- {
- MockOutputListener listener;
-
- listener.setAdditionalContextsLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
-
- OutputLevel mask = listener.getAdditionalContextsLevelMask();
-
- EXPECT_FALSE(mask & level::none);
- EXPECT_FALSE(mask & level::message);
- EXPECT_TRUE(mask & level::debug_output);
- EXPECT_FALSE(mask & level::user_error);
- EXPECT_TRUE(mask & level::user_warning);
- EXPECT_FALSE(mask & level::user_status);
- }
-
- // test setAdditionalContextsMask
- TEST(OutputListenerTest, SetAdditionalContextsMask)
- {
- MockOutputListener listener;
-
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest3().mask);
-
- OutputContextMask mask = listener.getAdditionalContextsMask();
-
- EXPECT_TRUE(mask & context::unittest1().mask);
- EXPECT_FALSE(mask & context::unittest2().mask);
- EXPECT_TRUE(mask & context::unittest3().mask);
- }
-
- // 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
- namespace
- {
- void testContext(const OutputListener& listener, const OutputContextContainer& context, bool accepted)
- {
- EXPECT_TRUE(listener.acceptsOutput(level::message, context));
- EXPECT_TRUE(listener.acceptsOutput(level::user_error, context));
- EXPECT_TRUE(listener.acceptsOutput(level::user_warning, context));
-
- if (accepted)
- {
- EXPECT_TRUE(listener.acceptsOutput(level::user_status, context));
- EXPECT_TRUE(listener.acceptsOutput(level::internal_error, context));
- EXPECT_TRUE(listener.acceptsOutput(level::internal_info, context));
- }
- else
- {
- EXPECT_FALSE(listener.acceptsOutput(level::user_status, context));
- EXPECT_FALSE(listener.acceptsOutput(level::internal_error, context));
- EXPECT_FALSE(listener.acceptsOutput(level::internal_info, context));
- }
-
- EXPECT_FALSE(listener.acceptsOutput(level::verbose, context));
- EXPECT_FALSE(listener.acceptsOutput(level::verbose_ultra, context));
- }
- }
-
- TEST(OutputListenerTest, AcceptsOutputNoAdditionalContext)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
-
- testContext(listener, context::undefined(), false);
- testContext(listener, context::unittest1(), false);
- testContext(listener, context::unittest2(), false);
- }
-
- TEST(OutputListenerTest, AcceptsOutputWithAdditionalContext)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
- listener.setAdditionalContextsMask(context::unittest1().mask);
- listener.setAdditionalContextsLevelMax(level::internal_info);
-
- testContext(listener, context::undefined(), false);
- testContext(listener, context::unittest1(), true);
- testContext(listener, context::unittest2(), false);
- }
-
- TEST(OutputListenerTest, AcceptsOutputWithTwoAdditionalContexts)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
-
- listener.setLevelMax(level::user_warning);
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
- listener.setAdditionalContextsLevelMax(level::internal_info);
-
- testContext(listener, context::undefined(), false);
- testContext(listener, context::unittest1(), true);
- testContext(listener, context::unittest2(), true);
- }
-
- // test unfilteredOutput
- TEST(OutputListenerTest, UnfilteredOutputCallsOutputIfOutputAccepted)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
-
- const OutputLevel& level = level::message;
- const OutputContextContainer& context = context::undefined();
-
- EXPECT_TRUE(listener.acceptsOutput(level, context));
-
- std::vector<std::string> lines;
- EXPECT_CALL(listener, output(level, context, lines)).Times(1);
-
- listener.unfilteredOutput(level, context, lines);
- }
-
- TEST(OutputListenerTest, UnfilteredOutputDoesNotCallOutputIfOutputNotAccepted)
- {
- MockOutputListener listener;
-
- listener.setLevelMax(level::user_warning);
-
- const OutputLevel& level = level::verbose;
- const OutputContextContainer& context = context::undefined();
-
- EXPECT_FALSE(listener.acceptsOutput(level, context));
-
- std::vector<std::string> lines;
- EXPECT_CALL(listener, output(level, context, lines)).Times(0);
-
- listener.unfilteredOutput(level, context, lines);
- }
-
- // 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);
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "util/output/OutputListener.h"
+#include "util/output/OutputManager.h"
+#include "util/SharedPtr.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest1);
+ REGISTER_OUTPUT_CONTEXT(unittest2);
+ REGISTER_OUTPUT_CONTEXT(unittest3);
+ }
+ }
+
+ namespace
+ {
+ class MockOutputListener : public OutputListener
+ {
+ 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(OutputListenerTest, DefaultConstructorAcceptsNothing)
+ {
+ MockOutputListener listener;
+
+ EXPECT_EQ(level::none, listener.getLevelMask());
+ EXPECT_EQ(level::none, listener.getAdditionalContextsLevelMask());
+ EXPECT_EQ(context::none, listener.getAdditionalContextsMask());
+ }
+
+ // test setLevelMax
+ TEST(OutputListenerTest, SetLevelMax)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+
+ OutputLevel mask = listener.getLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_TRUE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_TRUE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setLevelRange
+ TEST(OutputListenerTest, SetLevelRange)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelRange(level::debug_output, level::user_warning);
+
+ OutputLevel mask = listener.getLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_FALSE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_TRUE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setLevelMask
+ TEST(OutputListenerTest, SetLevelMask)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
+
+ OutputLevel mask = listener.getLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_FALSE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_FALSE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setAdditionalContextsLevelMax
+ TEST(OutputListenerTest, SetAdditionalContextsLevelMax)
+ {
+ MockOutputListener listener;
+
+ listener.setAdditionalContextsLevelMax(level::user_warning);
+
+ OutputLevel mask = listener.getAdditionalContextsLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_TRUE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_TRUE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setAdditionalContextsLevelRange
+ TEST(OutputListenerTest, SetAdditionalContextsLevelRange)
+ {
+ MockOutputListener listener;
+
+ listener.setAdditionalContextsLevelRange(level::debug_output, level::user_warning);
+
+ OutputLevel mask = listener.getAdditionalContextsLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_FALSE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_TRUE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setAdditionalContextsLevelMask
+ TEST(OutputListenerTest, SetAdditionalContextsLevelMask)
+ {
+ MockOutputListener listener;
+
+ listener.setAdditionalContextsLevelMask(static_cast<OutputLevel>(level::debug_output | level::user_warning));
+
+ OutputLevel mask = listener.getAdditionalContextsLevelMask();
+
+ EXPECT_FALSE(mask & level::none);
+ EXPECT_FALSE(mask & level::message);
+ EXPECT_TRUE(mask & level::debug_output);
+ EXPECT_FALSE(mask & level::user_error);
+ EXPECT_TRUE(mask & level::user_warning);
+ EXPECT_FALSE(mask & level::user_status);
+ }
+
+ // test setAdditionalContextsMask
+ TEST(OutputListenerTest, SetAdditionalContextsMask)
+ {
+ MockOutputListener listener;
+
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest3().mask);
+
+ OutputContextMask mask = listener.getAdditionalContextsMask();
+
+ EXPECT_TRUE(mask & context::unittest1().mask);
+ EXPECT_FALSE(mask & context::unittest2().mask);
+ EXPECT_TRUE(mask & context::unittest3().mask);
+ }
+
+ // 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
+ namespace
+ {
+ void testContext(const OutputListener& listener, const OutputContextContainer& context, bool accepted)
+ {
+ EXPECT_TRUE(listener.acceptsOutput(level::message, context));
+ EXPECT_TRUE(listener.acceptsOutput(level::user_error, context));
+ EXPECT_TRUE(listener.acceptsOutput(level::user_warning, context));
+
+ if (accepted)
+ {
+ EXPECT_TRUE(listener.acceptsOutput(level::user_status, context));
+ EXPECT_TRUE(listener.acceptsOutput(level::internal_error, context));
+ EXPECT_TRUE(listener.acceptsOutput(level::internal_info, context));
+ }
+ else
+ {
+ EXPECT_FALSE(listener.acceptsOutput(level::user_status, context));
+ EXPECT_FALSE(listener.acceptsOutput(level::internal_error, context));
+ EXPECT_FALSE(listener.acceptsOutput(level::internal_info, context));
+ }
+
+ EXPECT_FALSE(listener.acceptsOutput(level::verbose, context));
+ EXPECT_FALSE(listener.acceptsOutput(level::verbose_ultra, context));
+ }
+ }
+
+ TEST(OutputListenerTest, AcceptsOutputNoAdditionalContext)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+
+ testContext(listener, context::undefined(), false);
+ testContext(listener, context::unittest1(), false);
+ testContext(listener, context::unittest2(), false);
+ }
+
+ TEST(OutputListenerTest, AcceptsOutputWithAdditionalContext)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+ listener.setAdditionalContextsMask(context::unittest1().mask);
+ listener.setAdditionalContextsLevelMax(level::internal_info);
+
+ testContext(listener, context::undefined(), false);
+ testContext(listener, context::unittest1(), true);
+ testContext(listener, context::unittest2(), false);
+ }
+
+ TEST(OutputListenerTest, AcceptsOutputWithTwoAdditionalContexts)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+
+ listener.setLevelMax(level::user_warning);
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
+ listener.setAdditionalContextsLevelMax(level::internal_info);
+
+ testContext(listener, context::undefined(), false);
+ testContext(listener, context::unittest1(), true);
+ testContext(listener, context::unittest2(), true);
+ }
+
+ // test unfilteredOutput
+ TEST(OutputListenerTest, UnfilteredOutputCallsOutputIfOutputAccepted)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+
+ const OutputLevel& level = level::message;
+ const OutputContextContainer& context = context::undefined();
+
+ EXPECT_TRUE(listener.acceptsOutput(level, context));
+
+ std::vector<std::string> lines;
+ EXPECT_CALL(listener, output(level, context, lines)).Times(1);
+
+ listener.unfilteredOutput(level, context, lines);
+ }
+
+ TEST(OutputListenerTest, UnfilteredOutputDoesNotCallOutputIfOutputNotAccepted)
+ {
+ MockOutputListener listener;
+
+ listener.setLevelMax(level::user_warning);
+
+ const OutputLevel& level = level::verbose;
+ const OutputContextContainer& context = context::undefined();
+
+ EXPECT_FALSE(listener.acceptsOutput(level, context));
+
+ std::vector<std::string> lines;
+ EXPECT_CALL(listener, output(level, context, lines)).Times(0);
+
+ listener.unfilteredOutput(level, context, lines);
+ }
+
+ // 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);
+ }
+}
Property changes on: code/branches/testing/test/util/output/OutputListenerTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/OutputManagerTest.cc
===================================================================
--- code/branches/testing/test/util/output/OutputManagerTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/OutputManagerTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,432 +1,432 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#define DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
-
-#include "util/Output.h"
-#include "util/output/OutputManager.h"
-#include "util/output/OutputListener.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest1);
- REGISTER_OUTPUT_CONTEXT(unittest2);
- REGISTER_OUTPUT_CONTEXT(unittest3);
-
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
- }
- }
-
- namespace
- {
- class MockOutputManager : public OutputManager
- {
- public:
- MOCK_METHOD1(updatedLevelMask, void(const OutputListener*));
- MOCK_METHOD1(updatedAdditionalContextsLevelMask, void(const OutputListener*));
- MOCK_METHOD1(updatedAdditionalContextsMask, void(const OutputListener*));
-
- void originalUpdatedLevelMask(const OutputListener* listener) { this->OutputManager::updatedLevelMask(listener); }
- void originalUpdatedAdditionalContextsLevelMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsLevelMask(listener); }
- void originalUpdatedAdditionalContextsMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsMask(listener); }
- };
-
- class MockOutputListener : public OutputListener
- {
- public:
- MockOutputListener(bool bRegister = true) : OutputListener(bRegister) {}
-
- MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
- MOCK_METHOD3(unfilteredOutput, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
-
- inline const std::vector<AdditionalContextListener*>& getListeners() const
- { return OutputListener::getListeners(); }
- };
- }
-
- // test getInstance does not create listeners
- TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
- {
- EXPECT_TRUE(NULL == &OutputManager::getInstance().getMemoryWriter());
- EXPECT_TRUE(NULL == &OutputManager::getInstance().getConsoleWriter());
- EXPECT_TRUE(NULL == &OutputManager::getInstance().getLogWriter());
- }
-
- // test getInstanceAndCreateListeners creates listeners
- TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
- {
- EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
- EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
- EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getLogWriter());
- }
-
- // test getInstanceAndCreateListeners called again does not re-create listeners
- TEST(OutputManagerTest, GetInstanceAndCreateListenersDoesNotCreateDefaultListenersTwice)
- {
- MemoryWriter* memoryWriter = &OutputManager::getInstanceAndCreateListeners().getMemoryWriter();
- ConsoleWriter* consoleWriter = &OutputManager::getInstanceAndCreateListeners().getConsoleWriter();
- LogWriter* logWriter = &OutputManager::getInstanceAndCreateListeners().getLogWriter();
-
- EXPECT_TRUE(memoryWriter == &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
- EXPECT_TRUE(consoleWriter == &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
- EXPECT_TRUE(logWriter == &OutputManager::getInstanceAndCreateListeners().getLogWriter());
- }
-
- // test constructor
- TEST(OutputManagerTest, MasksAreZeroAfterConstruction)
- {
- OutputManager manager;
- EXPECT_EQ(0u, manager.getCombinedLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
- }
-
- // test registerListener adds listener to list
- TEST(OutputManagerTest, RegisterListenerAddsListenerToList)
- {
- OutputManager manager;
- MockOutputListener listener;
- EXPECT_TRUE(manager.getListeners().empty());
-
- manager.registerListener(&listener);
-
- EXPECT_FALSE(manager.getListeners().empty());
- }
-
- // test unregisterListener removes listener from list
- TEST(OutputManagerTest, UnregisterListenerRemovesListenerFromList)
- {
- OutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
- EXPECT_FALSE(manager.getListeners().empty());
-
- manager.unregisterListener(&listener);
-
- EXPECT_TRUE(manager.getListeners().empty());
- }
-
- // test registerListener registers manager at listener
- TEST(OutputManagerTest, RegisterListenerRegistersManagerAtListener)
- {
- OutputManager manager;
- MockOutputListener listener(false);
- EXPECT_TRUE(listener.getListeners().empty());
-
- manager.registerListener(&listener);
-
- EXPECT_FALSE(listener.getListeners().empty());
- }
-
- // test unregisterListener unregisters manager from listener
- TEST(OutputManagerTest, UnregisterListenerRemovesManagerFromListener)
- {
- OutputManager manager;
- MockOutputListener listener(false);
- manager.registerListener(&listener);
- EXPECT_FALSE(listener.getListeners().empty());
-
- manager.unregisterListener(&listener);
-
- EXPECT_TRUE(listener.getListeners().empty());
- }
-
- // test registerListener adjusts masks
- TEST(OutputManagerTest, RegisterListenerAdjustsMasks)
- {
- OutputManager manager;
- EXPECT_EQ(0u, manager.getCombinedLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
-
- MockOutputListener listener;
- listener.setLevelMask(level::internal_warning);
- listener.setAdditionalContextsLevelMask(level::verbose_more);
- listener.setAdditionalContextsMask(context::unittest2().mask);
-
- manager.registerListener(&listener);
-
- EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
- EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
- }
-
- // test unregisterListener adjusts masks
- TEST(OutputManagerTest, UnregisterListenerAdjustsMasks)
- {
- OutputManager manager;
- MockOutputListener listener;
- listener.setLevelMask(level::internal_warning);
- listener.setAdditionalContextsLevelMask(level::verbose_more);
- listener.setAdditionalContextsMask(context::unittest2().mask);
-
- manager.registerListener(&listener);
-
- EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
- EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
-
- manager.unregisterListener(&listener);
-
- EXPECT_EQ(0u, manager.getCombinedLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
- }
-
- // test updatedLevelMask updates mask
- TEST(OutputManagerTest, UpdatedLevelMask)
- {
- MockOutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
-
- EXPECT_EQ(0u, manager.getCombinedLevelMask());
- EXPECT_CALL(manager, updatedLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedLevelMask));
-
- listener.setLevelMask(level::internal_warning);
-
- EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
- }
-
- // test updatedAdditionalContextsLevelMask updates mask
- TEST(OutputManagerTest, UpdatedAdditionalContextsLevelMask)
- {
- MockOutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
-
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_CALL(manager, updatedAdditionalContextsLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsLevelMask));
-
- listener.setAdditionalContextsLevelMask(level::internal_warning);
-
- EXPECT_EQ(level::internal_warning, manager.getCombinedAdditionalContextsLevelMask());
- }
-
- // test updatedAdditionalContextsMask updates mask
- TEST(OutputManagerTest, UpdatedAdditionalContextsMask)
- {
- MockOutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
-
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
- EXPECT_CALL(manager, updatedAdditionalContextsMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsMask));
-
- listener.setAdditionalContextsMask(context::unittest2().mask);
-
- EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
- }
-
- // test combines masks of all listeners
- TEST(OutputManagerTest, CombinesMasksOfAllListeners)
- {
- OutputManager manager;
- EXPECT_EQ(0u, manager.getCombinedLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
-
- MockOutputListener listener1;
- listener1.setLevelMask(level::user_error);
- listener1.setAdditionalContextsLevelMask(level::verbose);
- listener1.setAdditionalContextsMask(context::unittest1().mask);
- manager.registerListener(&listener1);
-
- MockOutputListener listener2;
- listener2.setLevelMask(level::user_warning);
- listener2.setAdditionalContextsLevelMask(level::verbose_more);
- listener2.setAdditionalContextsMask(context::unittest2().mask);
- manager.registerListener(&listener2);
-
- MockOutputListener listener3;
- listener3.setLevelMask(level::internal_warning);
- listener3.setAdditionalContextsLevelMask(level::verbose_ultra);
- listener3.setAdditionalContextsMask(context::unittest3().mask);
- manager.registerListener(&listener3);
-
- EXPECT_EQ(level::user_error | level::user_warning | level::internal_warning, manager.getCombinedLevelMask());
- EXPECT_EQ(level::verbose | level::verbose_more | level::verbose_ultra, manager.getCombinedAdditionalContextsLevelMask());
- EXPECT_EQ(context::unittest1().mask | context::unittest2().mask | context::unittest3().mask, manager.getCombinedAdditionalContextsMask());
- }
-
- // test acceptsOutput
- TEST(OutputManagerTest, AcceptsOutput)
- {
- OutputManager manager;
- MockOutputListener listener;
- listener.setLevelMask(level::internal_warning);
- listener.setAdditionalContextsLevelMask(level::verbose_more);
- listener.setAdditionalContextsMask(context::unittest2().mask);
-
- manager.registerListener(&listener);
-
- EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::undefined()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::undefined()));
- EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::undefined()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::undefined()));
- EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::undefined()));
- EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::undefined()));
-
- EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest1()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest1()));
- EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest1()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest1()));
- EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::unittest1()));
- EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest1()));
-
- EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest2()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest2()));
- EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest2()));
- EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest2()));
- EXPECT_TRUE(manager.acceptsOutput(level::verbose_more, context::unittest2()));
- EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest2()));
- }
-
- // test pushMessage sends lines to listeners
- TEST(OutputManagerTest, PushMessageSendsLinesToListeners)
- {
- OutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
-
- std::vector<std::string> lines;
- lines.push_back("some output");
-
- EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
-
- manager.pushMessage(level::user_status, context::unittest1(), "some output");
- }
-
- // test pushMessage splits lines by \n
- TEST(OutputManagerTest, PushMessageSplitsTextAtNewlineChar)
- {
- OutputManager manager;
- MockOutputListener listener;
- manager.registerListener(&listener);
-
- std::vector<std::string> lines;
- lines.push_back("some output");
- lines.push_back("and some more output");
- lines.push_back("!!!");
-
- EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
-
- manager.pushMessage(level::user_status, context::unittest1(), "some output\nand some more output\n!!!");
- }
-
- // test registerContext for new context
- TEST(OutputManagerTest, RegisterNewContext)
- {
- OutputManager manager;
- OutputContextContainer container = manager.registerContext("whatever");
- EXPECT_EQ("whatever", container.name);
- EXPECT_EQ(0, container.sub_id);
- }
-
- // test registerContext for existing context
- TEST(OutputManagerTest, RegisterContextTwice)
- {
- OutputManager manager;
- OutputContextContainer container1 = manager.registerContext("whatever");
- OutputContextContainer container2 = manager.registerContext("whatever");
- EXPECT_EQ("whatever", container1.name);
- EXPECT_EQ(0, container1.sub_id);
- EXPECT_EQ(container1, container2);
- }
-
- // test registerContext for multiple contexts
- TEST(OutputManagerTest, RegisterMultipleContexts)
- {
- OutputManager manager;
- OutputContextContainer container1 = manager.registerContext("whatever");
- OutputContextContainer container2 = manager.registerContext("asdf");
- EXPECT_EQ("whatever", container1.name);
- EXPECT_EQ(0, container1.sub_id);
- EXPECT_EQ("asdf", container2.name);
- EXPECT_EQ(0, container2.sub_id);
- EXPECT_NE(container1.mask, container2.mask);
- }
-
- // test registerContext for new subcontext
- TEST(OutputManagerTest, RegisterNewSubcontext)
- {
- OutputManager manager;
- OutputContextContainer container = manager.registerContext("base", "subcontext");
- EXPECT_EQ("base::subcontext", container.name);
- EXPECT_NE(0, container.sub_id);
- }
-
- // test registerContext for existing subcontext
- TEST(OutputManagerTest, RegisterSubcontextTwice)
- {
- OutputManager manager;
- OutputContextContainer container1 = manager.registerContext("base", "subcontext");
- OutputContextContainer container2 = manager.registerContext("base", "subcontext");
- EXPECT_EQ("base::subcontext", container1.name);
- EXPECT_NE(0, container1.sub_id);
- EXPECT_EQ(container1, container2);
- }
-
- // test registerContext for multiple subcontexts
- TEST(OutputManagerTest, RegisterMultipleSubcontexts)
- {
- OutputManager manager;
- OutputContextContainer container1 = manager.registerContext("base", "subcontext");
- OutputContextContainer container2 = manager.registerContext("base", "meh");
- EXPECT_EQ("base::subcontext", container1.name);
- EXPECT_NE(0, container1.sub_id);
- EXPECT_EQ("base::meh", container2.name);
- EXPECT_NE(0, container2.sub_id);
- EXPECT_EQ(container1.mask, container2.mask);
- EXPECT_NE(container1.sub_id, container2.sub_id);
- }
-
- // test subcontext has mask of base context
- TEST(OutputManagerTest, SubcontextHasMaskOfBaseContext)
- {
- OutputManager manager;
- OutputContextContainer container1 = manager.registerContext("base", "subcontext");
- EXPECT_EQ("base::subcontext", container1.name);
- EXPECT_NE(0, container1.sub_id);
-
- OutputContextContainer container2 = manager.registerContext("base");
- EXPECT_EQ("base", container2.name);
- EXPECT_EQ(0, container2.sub_id);
-
- EXPECT_EQ(container1.mask, container2.mask);
- }
-
- // test getLevelName
- TEST(OutputManagerTest, GetLevelName)
- {
- OutputManager manager;
- EXPECT_EQ("Debug", manager.getLevelName(level::debug_output));
- EXPECT_EQ("Error", manager.getLevelName(level::user_error));
- EXPECT_EQ("Status", manager.getLevelName(level::user_status));
- EXPECT_EQ("Warning (internal)", manager.getLevelName(level::internal_warning));
- EXPECT_EQ("Info (internal)", manager.getLevelName(level::internal_info));
- EXPECT_EQ("Verbose", manager.getLevelName(level::verbose));
- }
-
- // test getDefaultPrefix for undefined context
- TEST(OutputManagerTest, GetDefaultPrefixWithoutContext)
- {
- OutputManager manager;
- std::string prefix = manager.getDefaultPrefix(level::debug_output, context::undefined());
- EXPECT_EQ(manager.getLevelName(level::debug_output) + ": ", prefix);
- }
-
- // test getDefaultPrefix for regular context
- TEST(OutputManagerTest, GetDefaultPrefixWithContext)
- {
- OutputManager manager;
- std::string prefix = manager.getDefaultPrefix(level::debug_output, context::unittest1());
- EXPECT_EQ(manager.getLevelName(level::debug_output) + ": [unittest1] ", prefix);
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#define DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
+
+#include "util/Output.h"
+#include "util/output/OutputManager.h"
+#include "util/output/OutputListener.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest1);
+ REGISTER_OUTPUT_CONTEXT(unittest2);
+ REGISTER_OUTPUT_CONTEXT(unittest3);
+
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
+ }
+ }
+
+ namespace
+ {
+ class MockOutputManager : public OutputManager
+ {
+ public:
+ MOCK_METHOD1(updatedLevelMask, void(const OutputListener*));
+ MOCK_METHOD1(updatedAdditionalContextsLevelMask, void(const OutputListener*));
+ MOCK_METHOD1(updatedAdditionalContextsMask, void(const OutputListener*));
+
+ void originalUpdatedLevelMask(const OutputListener* listener) { this->OutputManager::updatedLevelMask(listener); }
+ void originalUpdatedAdditionalContextsLevelMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsLevelMask(listener); }
+ void originalUpdatedAdditionalContextsMask(const OutputListener* listener) { this->OutputManager::updatedAdditionalContextsMask(listener); }
+ };
+
+ class MockOutputListener : public OutputListener
+ {
+ public:
+ MockOutputListener(bool bRegister = true) : OutputListener(bRegister) {}
+
+ MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
+ MOCK_METHOD3(unfilteredOutput, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
+
+ inline const std::vector<AdditionalContextListener*>& getListeners() const
+ { return OutputListener::getListeners(); }
+ };
+ }
+
+ // test getInstance does not create listeners
+ TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
+ {
+ EXPECT_TRUE(NULL == &OutputManager::getInstance().getMemoryWriter());
+ EXPECT_TRUE(NULL == &OutputManager::getInstance().getConsoleWriter());
+ EXPECT_TRUE(NULL == &OutputManager::getInstance().getLogWriter());
+ }
+
+ // test getInstanceAndCreateListeners creates listeners
+ TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
+ {
+ EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
+ EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
+ EXPECT_TRUE(NULL != &OutputManager::getInstanceAndCreateListeners().getLogWriter());
+ }
+
+ // test getInstanceAndCreateListeners called again does not re-create listeners
+ TEST(OutputManagerTest, GetInstanceAndCreateListenersDoesNotCreateDefaultListenersTwice)
+ {
+ MemoryWriter* memoryWriter = &OutputManager::getInstanceAndCreateListeners().getMemoryWriter();
+ ConsoleWriter* consoleWriter = &OutputManager::getInstanceAndCreateListeners().getConsoleWriter();
+ LogWriter* logWriter = &OutputManager::getInstanceAndCreateListeners().getLogWriter();
+
+ EXPECT_TRUE(memoryWriter == &OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
+ EXPECT_TRUE(consoleWriter == &OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
+ EXPECT_TRUE(logWriter == &OutputManager::getInstanceAndCreateListeners().getLogWriter());
+ }
+
+ // test constructor
+ TEST(OutputManagerTest, MasksAreZeroAfterConstruction)
+ {
+ OutputManager manager;
+ EXPECT_EQ(0u, manager.getCombinedLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
+ }
+
+ // test registerListener adds listener to list
+ TEST(OutputManagerTest, RegisterListenerAddsListenerToList)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ EXPECT_TRUE(manager.getListeners().empty());
+
+ manager.registerListener(&listener);
+
+ EXPECT_FALSE(manager.getListeners().empty());
+ }
+
+ // test unregisterListener removes listener from list
+ TEST(OutputManagerTest, UnregisterListenerRemovesListenerFromList)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+ EXPECT_FALSE(manager.getListeners().empty());
+
+ manager.unregisterListener(&listener);
+
+ EXPECT_TRUE(manager.getListeners().empty());
+ }
+
+ // test registerListener registers manager at listener
+ TEST(OutputManagerTest, RegisterListenerRegistersManagerAtListener)
+ {
+ OutputManager manager;
+ MockOutputListener listener(false);
+ EXPECT_TRUE(listener.getListeners().empty());
+
+ manager.registerListener(&listener);
+
+ EXPECT_FALSE(listener.getListeners().empty());
+ }
+
+ // test unregisterListener unregisters manager from listener
+ TEST(OutputManagerTest, UnregisterListenerRemovesManagerFromListener)
+ {
+ OutputManager manager;
+ MockOutputListener listener(false);
+ manager.registerListener(&listener);
+ EXPECT_FALSE(listener.getListeners().empty());
+
+ manager.unregisterListener(&listener);
+
+ EXPECT_TRUE(listener.getListeners().empty());
+ }
+
+ // test registerListener adjusts masks
+ TEST(OutputManagerTest, RegisterListenerAdjustsMasks)
+ {
+ OutputManager manager;
+ EXPECT_EQ(0u, manager.getCombinedLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
+
+ MockOutputListener listener;
+ listener.setLevelMask(level::internal_warning);
+ listener.setAdditionalContextsLevelMask(level::verbose_more);
+ listener.setAdditionalContextsMask(context::unittest2().mask);
+
+ manager.registerListener(&listener);
+
+ EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
+ EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
+ }
+
+ // test unregisterListener adjusts masks
+ TEST(OutputManagerTest, UnregisterListenerAdjustsMasks)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ listener.setLevelMask(level::internal_warning);
+ listener.setAdditionalContextsLevelMask(level::verbose_more);
+ listener.setAdditionalContextsMask(context::unittest2().mask);
+
+ manager.registerListener(&listener);
+
+ EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
+ EXPECT_EQ(level::verbose_more, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
+
+ manager.unregisterListener(&listener);
+
+ EXPECT_EQ(0u, manager.getCombinedLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
+ }
+
+ // test updatedLevelMask updates mask
+ TEST(OutputManagerTest, UpdatedLevelMask)
+ {
+ MockOutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+
+ EXPECT_EQ(0u, manager.getCombinedLevelMask());
+ EXPECT_CALL(manager, updatedLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedLevelMask));
+
+ listener.setLevelMask(level::internal_warning);
+
+ EXPECT_EQ(level::internal_warning, manager.getCombinedLevelMask());
+ }
+
+ // test updatedAdditionalContextsLevelMask updates mask
+ TEST(OutputManagerTest, UpdatedAdditionalContextsLevelMask)
+ {
+ MockOutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_CALL(manager, updatedAdditionalContextsLevelMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsLevelMask));
+
+ listener.setAdditionalContextsLevelMask(level::internal_warning);
+
+ EXPECT_EQ(level::internal_warning, manager.getCombinedAdditionalContextsLevelMask());
+ }
+
+ // test updatedAdditionalContextsMask updates mask
+ TEST(OutputManagerTest, UpdatedAdditionalContextsMask)
+ {
+ MockOutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
+ EXPECT_CALL(manager, updatedAdditionalContextsMask(&listener)).WillRepeatedly(::testing::Invoke(&manager, &MockOutputManager::originalUpdatedAdditionalContextsMask));
+
+ listener.setAdditionalContextsMask(context::unittest2().mask);
+
+ EXPECT_EQ(context::unittest2().mask, manager.getCombinedAdditionalContextsMask());
+ }
+
+ // test combines masks of all listeners
+ TEST(OutputManagerTest, CombinesMasksOfAllListeners)
+ {
+ OutputManager manager;
+ EXPECT_EQ(0u, manager.getCombinedLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(0u, manager.getCombinedAdditionalContextsMask());
+
+ MockOutputListener listener1;
+ listener1.setLevelMask(level::user_error);
+ listener1.setAdditionalContextsLevelMask(level::verbose);
+ listener1.setAdditionalContextsMask(context::unittest1().mask);
+ manager.registerListener(&listener1);
+
+ MockOutputListener listener2;
+ listener2.setLevelMask(level::user_warning);
+ listener2.setAdditionalContextsLevelMask(level::verbose_more);
+ listener2.setAdditionalContextsMask(context::unittest2().mask);
+ manager.registerListener(&listener2);
+
+ MockOutputListener listener3;
+ listener3.setLevelMask(level::internal_warning);
+ listener3.setAdditionalContextsLevelMask(level::verbose_ultra);
+ listener3.setAdditionalContextsMask(context::unittest3().mask);
+ manager.registerListener(&listener3);
+
+ EXPECT_EQ(level::user_error | level::user_warning | level::internal_warning, manager.getCombinedLevelMask());
+ EXPECT_EQ(level::verbose | level::verbose_more | level::verbose_ultra, manager.getCombinedAdditionalContextsLevelMask());
+ EXPECT_EQ(context::unittest1().mask | context::unittest2().mask | context::unittest3().mask, manager.getCombinedAdditionalContextsMask());
+ }
+
+ // test acceptsOutput
+ TEST(OutputManagerTest, AcceptsOutput)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ listener.setLevelMask(level::internal_warning);
+ listener.setAdditionalContextsLevelMask(level::verbose_more);
+ listener.setAdditionalContextsMask(context::unittest2().mask);
+
+ manager.registerListener(&listener);
+
+ EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::undefined()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::undefined()));
+ EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::undefined()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::undefined()));
+ EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::undefined()));
+ EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::undefined()));
+
+ EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest1()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest1()));
+ EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest1()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest1()));
+ EXPECT_FALSE(manager.acceptsOutput(level::verbose_more, context::unittest1()));
+ EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest1()));
+
+ EXPECT_FALSE(manager.acceptsOutput(level::user_error, context::unittest2()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_error, context::unittest2()));
+ EXPECT_TRUE(manager.acceptsOutput(level::internal_warning, context::unittest2()));
+ EXPECT_FALSE(manager.acceptsOutput(level::internal_status, context::unittest2()));
+ EXPECT_TRUE(manager.acceptsOutput(level::verbose_more, context::unittest2()));
+ EXPECT_FALSE(manager.acceptsOutput(level::verbose_ultra, context::unittest2()));
+ }
+
+ // test pushMessage sends lines to listeners
+ TEST(OutputManagerTest, PushMessageSendsLinesToListeners)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+
+ std::vector<std::string> lines;
+ lines.push_back("some output");
+
+ EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
+
+ manager.pushMessage(level::user_status, context::unittest1(), "some output");
+ }
+
+ // test pushMessage splits lines by \n
+ TEST(OutputManagerTest, PushMessageSplitsTextAtNewlineChar)
+ {
+ OutputManager manager;
+ MockOutputListener listener;
+ manager.registerListener(&listener);
+
+ std::vector<std::string> lines;
+ lines.push_back("some output");
+ lines.push_back("and some more output");
+ lines.push_back("!!!");
+
+ EXPECT_CALL(listener, unfilteredOutput(level::user_status, context::unittest1(), lines));
+
+ manager.pushMessage(level::user_status, context::unittest1(), "some output\nand some more output\n!!!");
+ }
+
+ // test registerContext for new context
+ TEST(OutputManagerTest, RegisterNewContext)
+ {
+ OutputManager manager;
+ OutputContextContainer container = manager.registerContext("whatever");
+ EXPECT_EQ("whatever", container.name);
+ EXPECT_EQ(0, container.sub_id);
+ }
+
+ // test registerContext for existing context
+ TEST(OutputManagerTest, RegisterContextTwice)
+ {
+ OutputManager manager;
+ OutputContextContainer container1 = manager.registerContext("whatever");
+ OutputContextContainer container2 = manager.registerContext("whatever");
+ EXPECT_EQ("whatever", container1.name);
+ EXPECT_EQ(0, container1.sub_id);
+ EXPECT_EQ(container1, container2);
+ }
+
+ // test registerContext for multiple contexts
+ TEST(OutputManagerTest, RegisterMultipleContexts)
+ {
+ OutputManager manager;
+ OutputContextContainer container1 = manager.registerContext("whatever");
+ OutputContextContainer container2 = manager.registerContext("asdf");
+ EXPECT_EQ("whatever", container1.name);
+ EXPECT_EQ(0, container1.sub_id);
+ EXPECT_EQ("asdf", container2.name);
+ EXPECT_EQ(0, container2.sub_id);
+ EXPECT_NE(container1.mask, container2.mask);
+ }
+
+ // test registerContext for new subcontext
+ TEST(OutputManagerTest, RegisterNewSubcontext)
+ {
+ OutputManager manager;
+ OutputContextContainer container = manager.registerContext("base", "subcontext");
+ EXPECT_EQ("base::subcontext", container.name);
+ EXPECT_NE(0, container.sub_id);
+ }
+
+ // test registerContext for existing subcontext
+ TEST(OutputManagerTest, RegisterSubcontextTwice)
+ {
+ OutputManager manager;
+ OutputContextContainer container1 = manager.registerContext("base", "subcontext");
+ OutputContextContainer container2 = manager.registerContext("base", "subcontext");
+ EXPECT_EQ("base::subcontext", container1.name);
+ EXPECT_NE(0, container1.sub_id);
+ EXPECT_EQ(container1, container2);
+ }
+
+ // test registerContext for multiple subcontexts
+ TEST(OutputManagerTest, RegisterMultipleSubcontexts)
+ {
+ OutputManager manager;
+ OutputContextContainer container1 = manager.registerContext("base", "subcontext");
+ OutputContextContainer container2 = manager.registerContext("base", "meh");
+ EXPECT_EQ("base::subcontext", container1.name);
+ EXPECT_NE(0, container1.sub_id);
+ EXPECT_EQ("base::meh", container2.name);
+ EXPECT_NE(0, container2.sub_id);
+ EXPECT_EQ(container1.mask, container2.mask);
+ EXPECT_NE(container1.sub_id, container2.sub_id);
+ }
+
+ // test subcontext has mask of base context
+ TEST(OutputManagerTest, SubcontextHasMaskOfBaseContext)
+ {
+ OutputManager manager;
+ OutputContextContainer container1 = manager.registerContext("base", "subcontext");
+ EXPECT_EQ("base::subcontext", container1.name);
+ EXPECT_NE(0, container1.sub_id);
+
+ OutputContextContainer container2 = manager.registerContext("base");
+ EXPECT_EQ("base", container2.name);
+ EXPECT_EQ(0, container2.sub_id);
+
+ EXPECT_EQ(container1.mask, container2.mask);
+ }
+
+ // test getLevelName
+ TEST(OutputManagerTest, GetLevelName)
+ {
+ OutputManager manager;
+ EXPECT_EQ("Debug", manager.getLevelName(level::debug_output));
+ EXPECT_EQ("Error", manager.getLevelName(level::user_error));
+ EXPECT_EQ("Status", manager.getLevelName(level::user_status));
+ EXPECT_EQ("Warning (internal)", manager.getLevelName(level::internal_warning));
+ EXPECT_EQ("Info (internal)", manager.getLevelName(level::internal_info));
+ EXPECT_EQ("Verbose", manager.getLevelName(level::verbose));
+ }
+
+ // test getDefaultPrefix for undefined context
+ TEST(OutputManagerTest, GetDefaultPrefixWithoutContext)
+ {
+ OutputManager manager;
+ std::string prefix = manager.getDefaultPrefix(level::debug_output, context::undefined());
+ EXPECT_EQ(manager.getLevelName(level::debug_output) + ": ", prefix);
+ }
+
+ // test getDefaultPrefix for regular context
+ TEST(OutputManagerTest, GetDefaultPrefixWithContext)
+ {
+ OutputManager manager;
+ std::string prefix = manager.getDefaultPrefix(level::debug_output, context::unittest1());
+ EXPECT_EQ(manager.getLevelName(level::debug_output) + ": [unittest1] ", prefix);
+ }
+}
Property changes on: code/branches/testing/test/util/output/OutputManagerTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/OutputStreamTest.cc
===================================================================
--- code/branches/testing/test/util/output/OutputStreamTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/OutputStreamTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,170 +1,170 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#define DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
-
-#include "util/Output.h"
-#include "util/output/OutputStream.h"
-#include "util/output/OutputManager.h"
-#include "util/output/MemoryWriter.h"
-#include "util/SharedPtr.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest1);
- }
- }
-
- namespace
- {
- class MockOutputManager : public OutputManager
- {
- public:
- MOCK_METHOD3(pushMessage, void(OutputLevel, const OutputContextContainer&, const std::string&));
- };
- }
-
- // test level and context in constructor
- TEST(OutputStreamTest, Constructor)
- {
- OutputStream stream(level::user_warning, context::unittest1());
-
- EXPECT_EQ(level::user_warning, stream.getOutputLevel());
- EXPECT_EQ(&context::unittest1(), stream.getOutputContext());
- }
-
- // test setOutputAttributes
- TEST(OutputStreamTest, SetOutputAttributes)
- {
- OutputStream stream;
- stream.setOutputAttributes(level::user_warning, context::unittest1());
-
- EXPECT_EQ(level::user_warning, stream.getOutputLevel());
- EXPECT_EQ(&context::unittest1(), stream.getOutputContext());
- }
-
- // test manipulator applied
- TEST(OutputStreamTest, ManipulatorApplied)
- {
- OutputStream stream;
- stream << "test";
- EXPECT_EQ(4u, stream.str().size());
-
- // apply manipulator
- stream << std::ends;
- EXPECT_EQ(5u, stream.str().size());
- }
-
- // test manipulator only applied if output accepted
- TEST(OutputStreamTest, ManipulatorOnlyAppliedIfOutputAccepted)
- {
- // disable MemoryWriter because otherwise we would always accept all output
- OutputManager::getInstance().getMemoryWriter().disable();
-
- {
- OutputStream stream;
- EXPECT_TRUE(stream.acceptsOutput());
- stream << std::ends;
- EXPECT_EQ(1u, stream.str().size());
- }
-
- {
- OutputStream stream(level::verbose, context::undefined());
- EXPECT_FALSE(stream.acceptsOutput());
- stream << std::ends;
- EXPECT_EQ(0u, stream.str().size());
- }
- }
-
- // Fixture
- class OutputStreamTestWithMockedOutputManager : 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 endl-manipulator sends output to OutputManager
- TEST_F(OutputStreamTestWithMockedOutputManager, EndlSendsToOutputManager)
- {
- OutputStream stream;
-
- const OutputContextContainer& context = context::unittest1();
-
- stream.setOutputAttributes(level::user_warning, context);
- EXPECT_TRUE(stream.acceptsOutput());
- EXPECT_EQ(context, *stream.getOutputContext());
-
- EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "some output"));
-
- stream << "some output" << std::endl;
- }
-
- // test multiple lines sent to OutputManager
- TEST_F(OutputStreamTestWithMockedOutputManager, MultipleLinesSentToOutputManager)
- {
- OutputStream stream;
-
- const OutputContextContainer& context = context::unittest1();
-
- stream.setOutputAttributes(level::user_warning, context);
- EXPECT_TRUE(stream.acceptsOutput());
- EXPECT_EQ(context, *stream.getOutputContext());
-
- EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "some output"));
- EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "more output"));
- EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "yet another line of output"));
-
- stream << "some output" << std::endl;
- stream << "more output" << std::endl;
- stream << "yet another line of output" << std::endl;
- }
-
- // test output only sent if accepted
- TEST_F(OutputStreamTestWithMockedOutputManager, OutputOnlySentToOutputManagerIfAccepted)
- {
- // disable MemoryWriter because otherwise we would always accept all output
- OutputManager::getInstanceAndCreateListeners().getMemoryWriter().disable();
-
- OutputStream stream;
-
- const OutputContextContainer& context = context::unittest1();
-
- stream.setOutputAttributes(level::verbose, context);
- EXPECT_FALSE(stream.acceptsOutput());
-
- EXPECT_CALL(*this->manager_, pushMessage(::testing::_, ::testing::_, ::testing::_)).Times(0);
-
- stream << "some output" << std::endl;
- }
-
- // test desctructor sends remaining output to OutputManager
- TEST_F(OutputStreamTestWithMockedOutputManager, DestructorSendsRemainingOutputToOutputManager)
- {
- OutputStream stream;
-
- const OutputContextContainer& context = context::undefined();
-
- stream.setOutputAttributes(level::verbose, context);
- EXPECT_TRUE(stream.acceptsOutput());
-
- EXPECT_CALL(*this->manager_, pushMessage(::testing::_, ::testing::_, "some output [missing endl]"));
-
- stream << "some output";
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#define DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
+
+#include "util/Output.h"
+#include "util/output/OutputStream.h"
+#include "util/output/OutputManager.h"
+#include "util/output/MemoryWriter.h"
+#include "util/SharedPtr.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest1);
+ }
+ }
+
+ namespace
+ {
+ class MockOutputManager : public OutputManager
+ {
+ public:
+ MOCK_METHOD3(pushMessage, void(OutputLevel, const OutputContextContainer&, const std::string&));
+ };
+ }
+
+ // test level and context in constructor
+ TEST(OutputStreamTest, Constructor)
+ {
+ OutputStream stream(level::user_warning, context::unittest1());
+
+ EXPECT_EQ(level::user_warning, stream.getOutputLevel());
+ EXPECT_EQ(&context::unittest1(), stream.getOutputContext());
+ }
+
+ // test setOutputAttributes
+ TEST(OutputStreamTest, SetOutputAttributes)
+ {
+ OutputStream stream;
+ stream.setOutputAttributes(level::user_warning, context::unittest1());
+
+ EXPECT_EQ(level::user_warning, stream.getOutputLevel());
+ EXPECT_EQ(&context::unittest1(), stream.getOutputContext());
+ }
+
+ // test manipulator applied
+ TEST(OutputStreamTest, ManipulatorApplied)
+ {
+ OutputStream stream;
+ stream << "test";
+ EXPECT_EQ(4u, stream.str().size());
+
+ // apply manipulator
+ stream << std::ends;
+ EXPECT_EQ(5u, stream.str().size());
+ }
+
+ // test manipulator only applied if output accepted
+ TEST(OutputStreamTest, ManipulatorOnlyAppliedIfOutputAccepted)
+ {
+ // disable MemoryWriter because otherwise we would always accept all output
+ OutputManager::getInstance().getMemoryWriter().disable();
+
+ {
+ OutputStream stream;
+ EXPECT_TRUE(stream.acceptsOutput());
+ stream << std::ends;
+ EXPECT_EQ(1u, stream.str().size());
+ }
+
+ {
+ OutputStream stream(level::verbose, context::undefined());
+ EXPECT_FALSE(stream.acceptsOutput());
+ stream << std::ends;
+ EXPECT_EQ(0u, stream.str().size());
+ }
+ }
+
+ // Fixture
+ class OutputStreamTestWithMockedOutputManager : 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 endl-manipulator sends output to OutputManager
+ TEST_F(OutputStreamTestWithMockedOutputManager, EndlSendsToOutputManager)
+ {
+ OutputStream stream;
+
+ const OutputContextContainer& context = context::unittest1();
+
+ stream.setOutputAttributes(level::user_warning, context);
+ EXPECT_TRUE(stream.acceptsOutput());
+ EXPECT_EQ(context, *stream.getOutputContext());
+
+ EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "some output"));
+
+ stream << "some output" << std::endl;
+ }
+
+ // test multiple lines sent to OutputManager
+ TEST_F(OutputStreamTestWithMockedOutputManager, MultipleLinesSentToOutputManager)
+ {
+ OutputStream stream;
+
+ const OutputContextContainer& context = context::unittest1();
+
+ stream.setOutputAttributes(level::user_warning, context);
+ EXPECT_TRUE(stream.acceptsOutput());
+ EXPECT_EQ(context, *stream.getOutputContext());
+
+ EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "some output"));
+ EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "more output"));
+ EXPECT_CALL(*this->manager_, pushMessage(level::user_warning, context, "yet another line of output"));
+
+ stream << "some output" << std::endl;
+ stream << "more output" << std::endl;
+ stream << "yet another line of output" << std::endl;
+ }
+
+ // test output only sent if accepted
+ TEST_F(OutputStreamTestWithMockedOutputManager, OutputOnlySentToOutputManagerIfAccepted)
+ {
+ // disable MemoryWriter because otherwise we would always accept all output
+ OutputManager::getInstanceAndCreateListeners().getMemoryWriter().disable();
+
+ OutputStream stream;
+
+ const OutputContextContainer& context = context::unittest1();
+
+ stream.setOutputAttributes(level::verbose, context);
+ EXPECT_FALSE(stream.acceptsOutput());
+
+ EXPECT_CALL(*this->manager_, pushMessage(::testing::_, ::testing::_, ::testing::_)).Times(0);
+
+ stream << "some output" << std::endl;
+ }
+
+ // test desctructor sends remaining output to OutputManager
+ TEST_F(OutputStreamTestWithMockedOutputManager, DestructorSendsRemainingOutputToOutputManager)
+ {
+ OutputStream stream;
+
+ const OutputContextContainer& context = context::undefined();
+
+ stream.setOutputAttributes(level::verbose, context);
+ EXPECT_TRUE(stream.acceptsOutput());
+
+ EXPECT_CALL(*this->manager_, pushMessage(::testing::_, ::testing::_, "some output [missing endl]"));
+
+ stream << "some output";
+ }
+}
Property changes on: code/branches/testing/test/util/output/OutputStreamTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
Modified: code/branches/testing/test/util/output/SubcontextOutputListenerTest.cc
===================================================================
--- code/branches/testing/test/util/output/SubcontextOutputListenerTest.cc 2013-03-11 22:13:21 UTC (rev 9544)
+++ code/branches/testing/test/util/output/SubcontextOutputListenerTest.cc 2013-03-11 22:17:42 UTC (rev 9545)
@@ -1,217 +1,217 @@
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-#include "util/Output.h"
-#include "util/output/SubcontextOutputListener.h"
-
-namespace orxonox
-{
- namespace context
- {
- namespace
- {
- REGISTER_OUTPUT_CONTEXT(unittest1);
- REGISTER_OUTPUT_CONTEXT(unittest2);
- REGISTER_OUTPUT_CONTEXT(unittest3);
-
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
- REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
- }
- }
-
- namespace
- {
- class MockSubcontextOutputListener : public SubcontextOutputListener
- {
- public:
- MockSubcontextOutputListener(bool bRegister = true) : SubcontextOutputListener(bRegister) {}
- MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
- };
- }
-
- TEST(SubcontextOutputListenerTest, ContextsDefinedCorrectly)
- {
- EXPECT_TRUE(context::unittest1().sub_id == context::no_subcontext);
- EXPECT_TRUE(context::unittest2().sub_id == context::no_subcontext);
- EXPECT_TRUE(context::unittest3().sub_id == context::no_subcontext);
- EXPECT_FALSE(context::sub1().sub_id == context::no_subcontext);
- EXPECT_FALSE(context::sub2().sub_id == context::no_subcontext);
- EXPECT_FALSE(context::sub3().sub_id == context::no_subcontext);
- }
-
- // test setAdditionalContextsMask
- TEST(SubcontextOutputListenerTest, SetAdditionalContextsMask)
- {
- MockSubcontextOutputListener listener;
-
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
-
- OutputContextMask mask = listener.getAdditionalContextsMask();
-
- EXPECT_TRUE(mask & context::unittest1().mask);
- EXPECT_TRUE(mask & context::unittest2().mask);
- EXPECT_FALSE(mask & context::unittest3().mask);
- }
-
- // test setAdditionalSubcontexts
- TEST(SubcontextOutputListenerTest, SetAdditionalSubcontexts)
- {
- MockSubcontextOutputListener listener;
-
- std::set<const OutputContextContainer*> subcontexts;
- subcontexts.insert(&context::sub1());
- subcontexts.insert(&context::sub3());
-
- listener.setAdditionalSubcontexts(subcontexts);
- OutputContextMask mask = listener.getAdditionalContextsMask();
-
- EXPECT_FALSE(mask & context::unittest1().mask);
- EXPECT_FALSE(mask & context::unittest2().mask);
- EXPECT_TRUE(mask & context::unittest3().mask);
- }
-
- // test setAdditionalContextsMask and setAdditionalSubcontexts
- TEST(SubcontextOutputListenerTest, SetAdditionalContextsAndSubcontexts)
- {
- MockSubcontextOutputListener listener;
-
- std::set<const OutputContextContainer*> subcontexts;
- subcontexts.insert(&context::sub1());
- subcontexts.insert(&context::sub3());
-
- listener.setAdditionalSubcontexts(subcontexts);
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
-
- OutputContextMask mask = listener.getAdditionalContextsMask();
-
- EXPECT_TRUE(mask & context::unittest1().mask);
- EXPECT_TRUE(mask & context::unittest2().mask);
- EXPECT_TRUE(mask & context::unittest3().mask);
- }
-
- // test acceptsOutput
- namespace
- {
- void testContext(const OutputListener& listener, const OutputContextContainer& context, bool accepted)
- {
- EXPECT_TRUE(accepted == listener.acceptsOutput(level::message, context));
- EXPECT_TRUE(accepted == listener.acceptsOutput(level::user_error, context));
- EXPECT_TRUE(accepted == listener.acceptsOutput(level::internal_info, context));
- }
- }
-
- TEST(SubcontextOutputListenerTest, NoContext)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- testContext(listener, context::unittest1(), false);
- testContext(listener, context::unittest2(), false);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), false);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), false);
- }
-
- TEST(SubcontextOutputListenerTest, OneContext)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- listener.setAdditionalContextsMask(context::unittest1().mask);
-
- testContext(listener, context::unittest1(), true);
- testContext(listener, context::unittest2(), false);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), false);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), false);
- }
-
- TEST(SubcontextOutputListenerTest, TwoContexts)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
-
- testContext(listener, context::unittest1(), true);
- testContext(listener, context::unittest2(), true);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), false);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), false);
- }
-
- TEST(SubcontextOutputListenerTest, OneSubcontext)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- std::set<const OutputContextContainer*> subcontexts;
- subcontexts.insert(&context::sub1());
-
- listener.setAdditionalSubcontexts(subcontexts);
-
- testContext(listener, context::unittest1(), false);
- testContext(listener, context::unittest2(), false);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), true);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), false);
- }
-
- TEST(SubcontextOutputListenerTest, TwoSubcontexts)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- std::set<const OutputContextContainer*> subcontexts;
- subcontexts.insert(&context::sub1());
- subcontexts.insert(&context::sub3());
-
- listener.setAdditionalSubcontexts(subcontexts);
-
- testContext(listener, context::unittest1(), false);
- testContext(listener, context::unittest2(), false);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), true);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), true);
- }
-
- TEST(SubcontextOutputListenerTest, ContextsAndSubcontexts)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- std::set<const OutputContextContainer*> subcontexts;
- subcontexts.insert(&context::sub1());
- subcontexts.insert(&context::sub3());
-
- listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
- listener.setAdditionalSubcontexts(subcontexts);
-
- testContext(listener, context::unittest1(), true);
- testContext(listener, context::unittest2(), true);
- testContext(listener, context::unittest3(), false);
- testContext(listener, context::sub1(), true);
- testContext(listener, context::sub2(), false);
- testContext(listener, context::sub3(), true);
- }
-
- TEST(SubcontextOutputListenerTest, BaseContextEnablesAllSubcontexts)
- {
- MockSubcontextOutputListener listener;
- listener.setAdditionalContextsLevelMax(level::verbose);
-
- listener.setAdditionalContextsMask(context::unittest3().mask);
-
- testContext(listener, context::unittest1(), false);
- testContext(listener, context::unittest2(), false);
- testContext(listener, context::unittest3(), true);
- testContext(listener, context::sub1(), true);
- testContext(listener, context::sub2(), true);
- testContext(listener, context::sub3(), true);
- }
-}
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "util/Output.h"
+#include "util/output/SubcontextOutputListener.h"
+
+namespace orxonox
+{
+ namespace context
+ {
+ namespace
+ {
+ REGISTER_OUTPUT_CONTEXT(unittest1);
+ REGISTER_OUTPUT_CONTEXT(unittest2);
+ REGISTER_OUTPUT_CONTEXT(unittest3);
+
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub1);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub2);
+ REGISTER_OUTPUT_SUBCONTEXT(unittest3, sub3);
+ }
+ }
+
+ namespace
+ {
+ class MockSubcontextOutputListener : public SubcontextOutputListener
+ {
+ public:
+ MockSubcontextOutputListener(bool bRegister = true) : SubcontextOutputListener(bRegister) {}
+ MOCK_METHOD3(output, void(OutputLevel, const OutputContextContainer&, const std::vector<std::string>&));
+ };
+ }
+
+ TEST(SubcontextOutputListenerTest, ContextsDefinedCorrectly)
+ {
+ EXPECT_TRUE(context::unittest1().sub_id == context::no_subcontext);
+ EXPECT_TRUE(context::unittest2().sub_id == context::no_subcontext);
+ EXPECT_TRUE(context::unittest3().sub_id == context::no_subcontext);
+ EXPECT_FALSE(context::sub1().sub_id == context::no_subcontext);
+ EXPECT_FALSE(context::sub2().sub_id == context::no_subcontext);
+ EXPECT_FALSE(context::sub3().sub_id == context::no_subcontext);
+ }
+
+ // test setAdditionalContextsMask
+ TEST(SubcontextOutputListenerTest, SetAdditionalContextsMask)
+ {
+ MockSubcontextOutputListener listener;
+
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
+
+ OutputContextMask mask = listener.getAdditionalContextsMask();
+
+ EXPECT_TRUE(mask & context::unittest1().mask);
+ EXPECT_TRUE(mask & context::unittest2().mask);
+ EXPECT_FALSE(mask & context::unittest3().mask);
+ }
+
+ // test setAdditionalSubcontexts
+ TEST(SubcontextOutputListenerTest, SetAdditionalSubcontexts)
+ {
+ MockSubcontextOutputListener listener;
+
+ std::set<const OutputContextContainer*> subcontexts;
+ subcontexts.insert(&context::sub1());
+ subcontexts.insert(&context::sub3());
+
+ listener.setAdditionalSubcontexts(subcontexts);
+ OutputContextMask mask = listener.getAdditionalContextsMask();
+
+ EXPECT_FALSE(mask & context::unittest1().mask);
+ EXPECT_FALSE(mask & context::unittest2().mask);
+ EXPECT_TRUE(mask & context::unittest3().mask);
+ }
+
+ // test setAdditionalContextsMask and setAdditionalSubcontexts
+ TEST(SubcontextOutputListenerTest, SetAdditionalContextsAndSubcontexts)
+ {
+ MockSubcontextOutputListener listener;
+
+ std::set<const OutputContextContainer*> subcontexts;
+ subcontexts.insert(&context::sub1());
+ subcontexts.insert(&context::sub3());
+
+ listener.setAdditionalSubcontexts(subcontexts);
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
+
+ OutputContextMask mask = listener.getAdditionalContextsMask();
+
+ EXPECT_TRUE(mask & context::unittest1().mask);
+ EXPECT_TRUE(mask & context::unittest2().mask);
+ EXPECT_TRUE(mask & context::unittest3().mask);
+ }
+
+ // test acceptsOutput
+ namespace
+ {
+ void testContext(const OutputListener& listener, const OutputContextContainer& context, bool accepted)
+ {
+ EXPECT_TRUE(accepted == listener.acceptsOutput(level::message, context));
+ EXPECT_TRUE(accepted == listener.acceptsOutput(level::user_error, context));
+ EXPECT_TRUE(accepted == listener.acceptsOutput(level::internal_info, context));
+ }
+ }
+
+ TEST(SubcontextOutputListenerTest, NoContext)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ testContext(listener, context::unittest1(), false);
+ testContext(listener, context::unittest2(), false);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), false);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), false);
+ }
+
+ TEST(SubcontextOutputListenerTest, OneContext)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ listener.setAdditionalContextsMask(context::unittest1().mask);
+
+ testContext(listener, context::unittest1(), true);
+ testContext(listener, context::unittest2(), false);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), false);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), false);
+ }
+
+ TEST(SubcontextOutputListenerTest, TwoContexts)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
+
+ testContext(listener, context::unittest1(), true);
+ testContext(listener, context::unittest2(), true);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), false);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), false);
+ }
+
+ TEST(SubcontextOutputListenerTest, OneSubcontext)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ std::set<const OutputContextContainer*> subcontexts;
+ subcontexts.insert(&context::sub1());
+
+ listener.setAdditionalSubcontexts(subcontexts);
+
+ testContext(listener, context::unittest1(), false);
+ testContext(listener, context::unittest2(), false);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), true);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), false);
+ }
+
+ TEST(SubcontextOutputListenerTest, TwoSubcontexts)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ std::set<const OutputContextContainer*> subcontexts;
+ subcontexts.insert(&context::sub1());
+ subcontexts.insert(&context::sub3());
+
+ listener.setAdditionalSubcontexts(subcontexts);
+
+ testContext(listener, context::unittest1(), false);
+ testContext(listener, context::unittest2(), false);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), true);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), true);
+ }
+
+ TEST(SubcontextOutputListenerTest, ContextsAndSubcontexts)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ std::set<const OutputContextContainer*> subcontexts;
+ subcontexts.insert(&context::sub1());
+ subcontexts.insert(&context::sub3());
+
+ listener.setAdditionalContextsMask(context::unittest1().mask | context::unittest2().mask);
+ listener.setAdditionalSubcontexts(subcontexts);
+
+ testContext(listener, context::unittest1(), true);
+ testContext(listener, context::unittest2(), true);
+ testContext(listener, context::unittest3(), false);
+ testContext(listener, context::sub1(), true);
+ testContext(listener, context::sub2(), false);
+ testContext(listener, context::sub3(), true);
+ }
+
+ TEST(SubcontextOutputListenerTest, BaseContextEnablesAllSubcontexts)
+ {
+ MockSubcontextOutputListener listener;
+ listener.setAdditionalContextsLevelMax(level::verbose);
+
+ listener.setAdditionalContextsMask(context::unittest3().mask);
+
+ testContext(listener, context::unittest1(), false);
+ testContext(listener, context::unittest2(), false);
+ testContext(listener, context::unittest3(), true);
+ testContext(listener, context::sub1(), true);
+ testContext(listener, context::sub2(), true);
+ testContext(listener, context::sub3(), true);
+ }
+}
Property changes on: code/branches/testing/test/util/output/SubcontextOutputListenerTest.cc
___________________________________________________________________
Added: svn:eol-style
+ native
More information about the Orxonox-commit
mailing list