add append method to Text class that returns a ostream that can be used with << operator to append something to the text

Framework Tests/Array.cpp

@@ -1,255 +1,336 @@
 #include "pch.h"
-#include "CppUnitTest.h"
 
+#define NO_MAIN
 #include <Array.h>
 
+#include "CppUnitTest.h"
+
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace FrameworkTests
 {
-    TEST_CLASS( ArrayTests )
+    TEST_CLASS (ArrayTests)
     {
     public:
-
-        TEST_METHOD( EmtptyTest )
+        TEST_METHOD (EmtptyTest)
         {
             Framework::Array<int> array;
-            Assert::IsTrue( array.getEintragAnzahl() == 0, L"getEintragAnzahl() on empty array should be 0" );
+            Assert::IsTrue(array.getEintragAnzahl() == 0,
+                L"getEintragAnzahl() on empty array should be 0");
             int count = 0;
-            for( auto i : array ) count++;
-            Assert::IsTrue( count == 0, L"Iteration with : over an empty array should not do anything" );
+            for (auto i : array)
+                count++;
+            Assert::IsTrue(count == 0,
+                L"Iteration with : over an empty array should not do anything");
             auto end = array.end();
-            Assert::IsFalse( array.begin() != end, L"Iterator of an empty array should not have an element" );
-            Assert::IsFalse( array.hat( 0 ), L"Empty Array should not have an element" );
+            Assert::IsFalse(array.begin() != end,
+                L"Iterator of an empty array should not have an element");
+            Assert::IsFalse(
+                array.hat(0), L"Empty Array should not have an element");
         }
 
-        TEST_METHOD( AddTest )
+        TEST_METHOD (AddTest)
         {
             Framework::Array<int> array;
-            array.add( 100 );
-            array.add( 20, 1 );
-            array.add( 10, 0 );
-            array.add( 0 );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( array.get( 0 ) == 10, L"invalid value at index 0 of array after adding elements" );
-            Assert::IsTrue( array.get( 1 ) == 100, L"invalid value at index 1 of array after adding elements" );
-            Assert::IsTrue( array.get( 2 ) == 20, L"invalid value at index 1 of array after adding elements" );
-            Assert::IsTrue( array.get( 3 ) == 0, L"invalid value at index 1 of array after adding elements" );
+            array.add(100);
+            array.add(20, 1);
+            array.add(10, 0);
+            array.add(0);
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements getEintragAnzahl() should be 4");
+            Assert::IsTrue(array.get(0) == 10,
+                L"invalid value at index 0 of array after adding elements");
+            Assert::IsTrue(array.get(1) == 100,
+                L"invalid value at index 1 of array after adding elements");
+            Assert::IsTrue(array.get(2) == 20,
+                L"invalid value at index 1 of array after adding elements");
+            Assert::IsTrue(array.get(3) == 0,
+                L"invalid value at index 1 of array after adding elements");
             auto i = array.begin();
-            Assert::IsTrue( i.val() == 10, L"invalid value at index 0 of array after adding elements" );
+            Assert::IsTrue(i.val() == 10,
+                L"invalid value at index 0 of array after adding elements");
             i++;
-            Assert::IsTrue( i.val() == 100, L"invalid value at index 1 of array after adding elements" );
+            Assert::IsTrue(i.val() == 100,
+                L"invalid value at index 1 of array after adding elements");
             ++i;
-            Assert::IsTrue( i.val() == 20, L"invalid value at index 2 of array after adding elements" );
+            Assert::IsTrue(i.val() == 20,
+                L"invalid value at index 2 of array after adding elements");
             i = i.next();
-            Assert::IsTrue( i.val() == 0, L"invalid value at index 3 of array after adding elements" );
-            Assert::IsFalse( i.hasNext(), L"Iterator has to much elements after adding elements to array" );
+            Assert::IsTrue(i.val() == 0,
+                L"invalid value at index 3 of array after adding elements");
+            Assert::IsFalse(i.hasNext(),
+                L"Iterator has to much elements after adding elements to "
+                L"array");
             auto end = array.end();
-            Assert::IsFalse( ++i != end, L"iterator should match end() after iterating throu the array" );
+            Assert::IsFalse(++i != end,
+                L"iterator should match end() after iterating throu the array");
         }
 
-        TEST_METHOD( RemoveTest )
+        TEST_METHOD (RemoveTest)
         {
             Framework::Array<int> array;
-            array.add( 100 );
-            array.add( 20, 1 );
-            array.add( 10, 0 );
-            array.add( 0 );
-            array.remove( 3 );
-            array.remove( 1 );
-            array.remove( 0 );
-            Assert::IsTrue( array.getEintragAnzahl() == 1, L"after adding 4 elements and removing 3 elements getEintragAnzahl() should be 1" );
-            Assert::IsTrue( array.get( 0 ) == 20, L"invalid value at index 0 of array after removing elements" );
-            Assert::IsTrue( array.begin().val() == 20, L"invalid value at index 0 of array after removing elements" );
-            Assert::IsFalse( array.begin().hasNext(), L"Iterator has to many elements after removing elements" );
+            array.add(100);
+            array.add(20, 1);
+            array.add(10, 0);
+            array.add(0);
+            array.remove(3);
+            array.remove(1);
+            array.remove(0);
+            Assert::IsTrue(array.getEintragAnzahl() == 1,
+                L"after adding 4 elements and removing 3 elements "
+                L"getEintragAnzahl() should be 1");
+            Assert::IsTrue(array.get(0) == 20,
+                L"invalid value at index 0 of array after removing elements");
+            Assert::IsTrue(array.begin().val() == 20,
+                L"invalid value at index 0 of array after removing elements");
+            Assert::IsFalse(array.begin().hasNext(),
+                L"Iterator has to many elements after removing elements");
             auto end = array.end();
-            Assert::IsFalse( array.begin().next() != end, L"Iterator has to many elements after removing elements" );
+            Assert::IsFalse(array.begin().next() != end,
+                L"Iterator has to many elements after removing elements");
         }
 
-        TEST_METHOD( SwapTest )
+        TEST_METHOD (SwapTest)
         {
             Framework::Array<int> array;
-            array.add( 100 );
-            array.add( 20, 1 );
-            array.add( 10, 0 );
-            array.add( 0 );
-            array.tausch( 0, 3 );
-            array.tausch( 1, 2 );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements and swap elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( array.get( 0 ) == 0, L"invalid value at index 0 of array after swapping elements" );
-            Assert::IsTrue( array.get( 1 ) == 20, L"invalid value at index 1 of array after swapping elements" );
-            Assert::IsTrue( array.get( 2 ) == 100, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( array.get( 3 ) == 10, L"invalid value at index 3 of array after swapping elements" );
-            array.tausch( 2, 0 );
-            Assert::IsTrue( array.get( 2 ) == 0, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( array.get( 0 ) == 100, L"invalid value at index 0 of array after swapping elements" );
+            array.add(100);
+            array.add(20, 1);
+            array.add(10, 0);
+            array.add(0);
+            array.tausch(0, 3);
+            array.tausch(1, 2);
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements and swap elements getEintragAnzahl() "
+                L"should be 4");
+            Assert::IsTrue(array.get(0) == 0,
+                L"invalid value at index 0 of array after swapping elements");
+            Assert::IsTrue(array.get(1) == 20,
+                L"invalid value at index 1 of array after swapping elements");
+            Assert::IsTrue(array.get(2) == 100,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue(array.get(3) == 10,
+                L"invalid value at index 3 of array after swapping elements");
+            array.tausch(2, 0);
+            Assert::IsTrue(array.get(2) == 0,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue(array.get(0) == 100,
+                L"invalid value at index 0 of array after swapping elements");
         }
 
-        TEST_METHOD( SetTest )
+        TEST_METHOD (SetTest)
         {
             Framework::Array<int> array;
-            array.add( 100 );
-            array.add( 20, 1 );
-            array.add( 10, 0 );
-            array.add( 0 );
-            array.set( 30, 0 );
-            array.set( 200, 3 );
-            array.set( 500, 1 );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements and changing elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( array.get( 0 ) == 30, L"invalid value at index 0 of array after swapping elements" );
-            Assert::IsTrue( array.get( 1 ) == 500, L"invalid value at index 1 of array after swapping elements" );
-            Assert::IsTrue( array.get( 2 ) == 20, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( array.get( 3 ) == 200, L"invalid value at index 3 of array after swapping elements" );
+            array.add(100);
+            array.add(20, 1);
+            array.add(10, 0);
+            array.add(0);
+            array.set(30, 0);
+            array.set(200, 3);
+            array.set(500, 1);
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements and changing elements "
+                L"getEintragAnzahl() should be 4");
+            Assert::IsTrue(array.get(0) == 30,
+                L"invalid value at index 0 of array after swapping elements");
+            Assert::IsTrue(array.get(1) == 500,
+                L"invalid value at index 1 of array after swapping elements");
+            Assert::IsTrue(array.get(2) == 20,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue(array.get(3) == 200,
+                L"invalid value at index 3 of array after swapping elements");
         }
 
-        TEST_METHOD( ValueTest )
+        TEST_METHOD (ValueTest)
         {
             Framework::Array<int> array;
-            array.add( 100 );
-            array.add( 20, 1 );
-            array.add( 10, 0 );
-            array.add( 0 );
-            array.removeValue( 10 );
-            Assert::IsTrue( array.getEintragAnzahl() == 3, L"after adding 4 elements and removing elements by value getEintragAnzahl() should be 3" );
-            Assert::IsTrue( array.getWertIndex( 0 ) == 2, L"invalid value index of value after removing elements" );
-            Assert::IsTrue( array.getWertIndex( 10 ) < 0, L"value is still in array after removeValue" );
+            array.add(100);
+            array.add(20, 1);
+            array.add(10, 0);
+            array.add(0);
+            array.removeValue(10);
+            Assert::IsTrue(array.getEintragAnzahl() == 3,
+                L"after adding 4 elements and removing elements by value "
+                L"getEintragAnzahl() should be 3");
+            Assert::IsTrue(array.getWertIndex(0) == 2,
+                L"invalid value index of value after removing elements");
+            Assert::IsTrue(array.getWertIndex(10) < 0,
+                L"value is still in array after removeValue");
         }
     };
 
-    template<typename T>
-    class Test : public Framework::ReferenceCounter
+    template<typename T> class Test : public Framework::ReferenceCounter
     {
         int val = 0;
         T* tc;
 
     public:
-        Test( const int v, T* tc )
+        Test(const int v, T* tc)
             : ReferenceCounter(),
-            val( v ),
-            tc( tc )
+              val(v),
+              tc(tc)
         {}
+
         ~Test()
         {
             tc->deleteCounter++;
         }
+
         operator int()
         {
             return val;
         }
+
         int getVal()
         {
             return val;
         }
     };
 
-    TEST_CLASS( RCArrayTests )
+    TEST_CLASS (RCArrayTests)
     {
     public:
         int deleteCounter = 0;
-        TEST_METHOD_INITIALIZE( InitTest )
+        TEST_METHOD_INITIALIZE(InitTest)
         {
             deleteCounter = 0;
         }
 
-        TEST_METHOD( EmtptyTest )
+        TEST_METHOD (EmtptyTest)
         {
             Framework::RCArray<Test<RCArrayTests>> array;
-            Assert::IsTrue( array.getEintragAnzahl() == 0, L"getEintragAnzahl() on empty array should be 0" );
+            Assert::IsTrue(array.getEintragAnzahl() == 0,
+                L"getEintragAnzahl() on empty array should be 0");
             int count = 0;
-            for( auto i : array ) count++;
-            Assert::IsTrue( count == 0, L"Iteration with : over an empty array should not do anything" );
+            for (auto i : array)
+                count++;
+            Assert::IsTrue(count == 0,
+                L"Iteration with : over an empty array should not do anything");
             auto end = array.end();
-            Assert::IsFalse( array.begin() != end, L"Iterator of an empty array should not have an element" );
-            Assert::IsFalse( array.hat( 0 ), L"Empty Array should not have an element" );
+            Assert::IsFalse(array.begin() != end,
+                L"Iterator of an empty array should not have an element");
+            Assert::IsFalse(
+                array.hat(0), L"Empty Array should not have an element");
         }
 
-        TEST_METHOD( AddTest )
+        TEST_METHOD (AddTest)
         {
             Framework::RCArray<Test<RCArrayTests>> array;
-            array.add( new Test<RCArrayTests>( 100, this ) );
-            array.add( new Test<RCArrayTests>( 20, this ), 1 );
-            array.add( new Test<RCArrayTests>( 10, this ), 0 );
-            array.add( new Test<RCArrayTests>( 0, this ) );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( (int)*array.z( 0 ) == 10, L"invalid value at index 0 of array after adding elements" );
-            Assert::IsTrue( (int)*array.z( 1 ) == 100, L"invalid value at index 1 of array after adding elements" );
-            Assert::IsTrue( (int)*array.z( 2 ) == 20, L"invalid value at index 1 of array after adding elements" );
-            Assert::IsTrue( (int)*array.z( 3 ) == 0, L"invalid value at index 1 of array after adding elements" );
+            array.add(new Test<RCArrayTests>(100, this));
+            array.add(new Test<RCArrayTests>(20, this), 1);
+            array.add(new Test<RCArrayTests>(10, this), 0);
+            array.add(new Test<RCArrayTests>(0, this));
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements getEintragAnzahl() should be 4");
+            Assert::IsTrue((int)*array.z(0) == 10,
+                L"invalid value at index 0 of array after adding elements");
+            Assert::IsTrue((int)*array.z(1) == 100,
+                L"invalid value at index 1 of array after adding elements");
+            Assert::IsTrue((int)*array.z(2) == 20,
+                L"invalid value at index 1 of array after adding elements");
+            Assert::IsTrue((int)*array.z(3) == 0,
+                L"invalid value at index 1 of array after adding elements");
             auto i = array.begin();
-            Assert::IsTrue( i->getVal() == 10, L"invalid value at index 0 of array after adding elements" );
+            Assert::IsTrue(i->getVal() == 10,
+                L"invalid value at index 0 of array after adding elements");
             i++;
-            Assert::IsTrue( i->getVal() == 100, L"invalid value at index 1 of array after adding elements" );
+            Assert::IsTrue(i->getVal() == 100,
+                L"invalid value at index 1 of array after adding elements");
             ++i;
-            Assert::IsTrue( i->getVal() == 20, L"invalid value at index 2 of array after adding elements" );
+            Assert::IsTrue(i->getVal() == 20,
+                L"invalid value at index 2 of array after adding elements");
             i = i.next();
-            Assert::IsTrue( i->getVal() == 0, L"invalid value at index 3 of array after adding elements" );
-            Assert::IsFalse( i.hasNext(), L"Iterator has to much elements after adding elements to array" );
+            Assert::IsTrue(i->getVal() == 0,
+                L"invalid value at index 3 of array after adding elements");
+            Assert::IsFalse(i.hasNext(),
+                L"Iterator has to much elements after adding elements to "
+                L"array");
             auto end = array.end();
-            Assert::IsFalse( ++i != end, L"iterator should match end() after iterating throu the array" );
+            Assert::IsFalse(++i != end,
+                L"iterator should match end() after iterating throu the array");
             array.leeren();
-            Assert::IsTrue( deleteCounter == 4, L"Memory leaks detected" );
+            Assert::IsTrue(deleteCounter == 4, L"Memory leaks detected");
         }
 
-        TEST_METHOD( RemoveTest )
+        TEST_METHOD (RemoveTest)
         {
             Framework::RCArray<Test<RCArrayTests>> array;
-            array.add( new Test<RCArrayTests>( 100, this ) );
-            array.add( new Test<RCArrayTests>( 20, this ), 1 );
-            array.add( new Test<RCArrayTests>( 10, this ), 0 );
-            array.add( new Test<RCArrayTests>( 0, this ) );
-            array.remove( 3 );
-            array.remove( 1 );
-            array.remove( 0 );
-            Assert::IsTrue( array.getEintragAnzahl() == 1, L"after adding 4 elements and removing 3 elements getEintragAnzahl() should be 1" );
-            Assert::IsTrue( (int)*array.z( 0 ) == 20, L"invalid value at index 0 of array after removing elements" );
-            Assert::IsTrue( array.begin()->getVal() == 20, L"invalid value at index 0 of array after removing elements" );
-            Assert::IsFalse( array.begin().hasNext(), L"Iterator has to many elements after removing elements" );
+            array.add(new Test<RCArrayTests>(100, this));
+            array.add(new Test<RCArrayTests>(20, this), 1);
+            array.add(new Test<RCArrayTests>(10, this), 0);
+            array.add(new Test<RCArrayTests>(0, this));
+            array.remove(3);
+            array.remove(1);
+            array.remove(0);
+            Assert::IsTrue(array.getEintragAnzahl() == 1,
+                L"after adding 4 elements and removing 3 elements "
+                L"getEintragAnzahl() should be 1");
+            Assert::IsTrue((int)*array.z(0) == 20,
+                L"invalid value at index 0 of array after removing elements");
+            Assert::IsTrue(array.begin()->getVal() == 20,
+                L"invalid value at index 0 of array after removing elements");
+            Assert::IsFalse(array.begin().hasNext(),
+                L"Iterator has to many elements after removing elements");
             auto end = array.end();
-            Assert::IsFalse( array.begin().next() != end, L"Iterator has to many elements after removing elements" );
-            Assert::IsTrue( deleteCounter == 3, L"Memory leaks detected" );
+            Assert::IsFalse(array.begin().next() != end,
+                L"Iterator has to many elements after removing elements");
+            Assert::IsTrue(deleteCounter == 3, L"Memory leaks detected");
             array.leeren();
-            Assert::IsTrue( deleteCounter == 4, L"Memory leaks detected" );
+            Assert::IsTrue(deleteCounter == 4, L"Memory leaks detected");
         }
 
-        TEST_METHOD( SwapTest )
+        TEST_METHOD (SwapTest)
         {
             Framework::RCArray<Test<RCArrayTests>> array;
-            array.add( new Test<RCArrayTests>( 100, this ) );
-            array.add( new Test<RCArrayTests>( 20, this ), 1 );
-            array.add( new Test<RCArrayTests>( 10, this ), 0 );
-            array.add( new Test<RCArrayTests>( 0, this ) );
-            array.tausch( 0, 3 );
-            array.tausch( 1, 2 );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements and swap elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( (int)*array.z( 0 ) == 0, L"invalid value at index 0 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 1 ) == 20, L"invalid value at index 1 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 2 ) == 100, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 3 ) == 10, L"invalid value at index 3 of array after swapping elements" );
-            array.tausch( 2, 0 );
-            Assert::IsTrue( (int)*array.z( 2 ) == 0, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 0 ) == 100, L"invalid value at index 0 of array after swapping elements" );
+            array.add(new Test<RCArrayTests>(100, this));
+            array.add(new Test<RCArrayTests>(20, this), 1);
+            array.add(new Test<RCArrayTests>(10, this), 0);
+            array.add(new Test<RCArrayTests>(0, this));
+            array.tausch(0, 3);
+            array.tausch(1, 2);
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements and swap elements getEintragAnzahl() "
+                L"should be 4");
+            Assert::IsTrue((int)*array.z(0) == 0,
+                L"invalid value at index 0 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(1) == 20,
+                L"invalid value at index 1 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(2) == 100,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(3) == 10,
+                L"invalid value at index 3 of array after swapping elements");
+            array.tausch(2, 0);
+            Assert::IsTrue((int)*array.z(2) == 0,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(0) == 100,
+                L"invalid value at index 0 of array after swapping elements");
             array.leeren();
-            Assert::IsTrue( deleteCounter == 4, L"Memory leaks detected" );
+            Assert::IsTrue(deleteCounter == 4, L"Memory leaks detected");
         }
 
-        TEST_METHOD( SetTest )
+        TEST_METHOD (SetTest)
         {
             Framework::RCArray<Test<RCArrayTests>> array;
-            array.add( new Test<RCArrayTests>( 100, this ) );
-            array.add( new Test<RCArrayTests>( 20, this ), 1 );
-            array.add( new Test<RCArrayTests>( 10, this ), 0 );
-            array.add( new Test<RCArrayTests>( 0, this ) );
-            array.set( new Test<RCArrayTests>( 30, this ), 0 );
-            array.set( new Test<RCArrayTests>( 200, this ), 3 );
-            array.set( new Test<RCArrayTests>( 500, this ), 1 );
-            Assert::IsTrue( array.getEintragAnzahl() == 4, L"after adding 4 elements and changing elements getEintragAnzahl() should be 4" );
-            Assert::IsTrue( (int)*array.z( 0 ) == 30, L"invalid value at index 0 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 1 ) == 500, L"invalid value at index 1 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 2 ) == 20, L"invalid value at index 2 of array after swapping elements" );
-            Assert::IsTrue( (int)*array.z( 3 ) == 200, L"invalid value at index 3 of array after swapping elements" );
-            Assert::IsTrue( deleteCounter == 3, L"Memory leaks detected" );
+            array.add(new Test<RCArrayTests>(100, this));
+            array.add(new Test<RCArrayTests>(20, this), 1);
+            array.add(new Test<RCArrayTests>(10, this), 0);
+            array.add(new Test<RCArrayTests>(0, this));
+            array.set(new Test<RCArrayTests>(30, this), 0);
+            array.set(new Test<RCArrayTests>(200, this), 3);
+            array.set(new Test<RCArrayTests>(500, this), 1);
+            Assert::IsTrue(array.getEintragAnzahl() == 4,
+                L"after adding 4 elements and changing elements "
+                L"getEintragAnzahl() should be 4");
+            Assert::IsTrue((int)*array.z(0) == 30,
+                L"invalid value at index 0 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(1) == 500,
+                L"invalid value at index 1 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(2) == 20,
+                L"invalid value at index 2 of array after swapping elements");
+            Assert::IsTrue((int)*array.z(3) == 200,
+                L"invalid value at index 3 of array after swapping elements");
+            Assert::IsTrue(deleteCounter == 3, L"Memory leaks detected");
             array.leeren();
-            Assert::IsTrue( deleteCounter == 7, L"Memory leaks detected" );
+            Assert::IsTrue(deleteCounter == 7, L"Memory leaks detected");
         }
     };
-}
+} // namespace FrameworkTests

Framework Tests/Base64.cpp

@@ -1,55 +1,92 @@
 #include "pch.h"
-#include "CppUnitTest.h"
 
 #include <Base64.h>
 #include <Text.h>
 
+#include "CppUnitTest.h"
+
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 // test class for base64 encoding and decoding
 namespace FrameworkTests
 {
-	TEST_CLASS(Base64Tests)
-	{
-	public:
-		TEST_METHOD(TestEncoding)
-		{
-			const char* data = "Hello World!";
-			const char* encoded = "SGVsbG8gV29ybGQh";
-			Framework::Text encodedData = Framework::base64Encode(data, Framework::textLength(data));
-			Assert::AreEqual(encoded, encodedData.getText());
-		}
-		
-		TEST_METHOD(TestDecoding)
-		{
-			const char* data = "SGVsbG8gV29ybGQh";
-			const char* decoded = "Hello World!";
-			char* decodedData = 0;
-			int decodecLength;
-			Framework::base64Decode(data, &decodedData, &decodecLength);
-			Assert::AreEqual(decoded, decodedData);
-			delete[] decodedData;
-		}
+    TEST_CLASS (Base64Tests)
+    {
+    public:
+        TEST_METHOD (TestEncoding)
+        {
+            const char* data = "Hello World!";
+            const char* encoded = "SGVsbG8gV29ybGQh";
+            Framework::Text encodedData
+                = Framework::base64Encode(data, Framework::textLength(data));
+            Assert::AreEqual(encoded, encodedData.getText());
+        }
+
+        TEST_METHOD (TestDecoding)
+        {
+            const char* data = "SGVsbG8gV29ybGQh";
+            const char* decoded = "Hello World!";
+            char* decodedData = 0;
+            int decodecLength;
+            Framework::base64Decode(data, &decodedData, &decodecLength);
+            Assert::AreEqual(decoded, decodedData);
+            delete[] decodedData;
+        }
 
-		TEST_METHOD(TestDecodingInvalid)
-		{
-			const char* data = "SGVsbG8.gVd29ybGQh";
-			char* decodedData = 0;
-			int decodecLength;
-			Framework::base64Decode(data, &decodedData, &decodecLength);
-			Assert::AreEqual(0, decodecLength);
-			delete[] decodedData;
-		}
+        TEST_METHOD (TestDecodingInvalid)
+        {
+            const char* data = "SGVsbG8.gVd29ybGQh";
+            char* decodedData = 0;
+            int decodecLength;
+            Framework::base64Decode(data, &decodedData, &decodecLength);
+            Assert::AreEqual(0, decodecLength);
+            delete[] decodedData;
+        }
 
-		TEST_METHOD(TestDecodeAndEncode)
-		{
-			const char* data = "g0OLN0EJepEiT8eiNdvb9PfJkIqSpiLqb3uvRwyg2Y7iZsQkbkC1kI99M8NaELhT2Erca/D+VmB6B6aFpoAViuXZrlQaZeSo4RhtPScmjwFwbGtha8DA5Mdna2/ngPjOWqgkdA4JHe8hiS1Ir7tIICmygZR0Qnk8qeSrkWWlYL5OhDRcjFBMrNl584o1Pape7izxZG1soBdRTKi28Ap2QI2pmxr55sbTYbtelfcK8+c15UyiUuy4ozliWitr0Gr3egYAE3Ts2UlOlafjjbDXdeS+wYcRrkGz56IPEw/efQgAAAAAWYMbzXDzF76JvaIYb3uNVDpQ20v9Hf3mvw75zet31Ub57xRr4ysqbujMhVhIFKuCY4jMYqTLSWXYRDTFuwoMtfggIt1KS0w0GdGLYOQ44ki/r6lle/LJVDf9GvEIAAAAACaoAgBFyt6PFyzCL/xPj+GGcipGItOqncd18f1zDfB7Mpp9d2VcCAAAAAB7h8qphRo5Z5+rkeXNZZFrLQdeLHpqHvWct3MUHc8cmFjlQ9z+fESeKNSF9TsXYWgev5OYKrCOxmgDAAAAANmF0fUfK9thCADVAQDa3Ex6BgAi/vpcF13DNB1Yy0cJWw5xXef2MN0XWrl3YpVVrRFbzhFWLCez71rQSCcZUYImwd4PuRDrz2mmSMo8nHlM90lcT3SDAwAAADG1AWXd06wFAAAAAOv8hxK/ZiB6dg1K3rKSqu4wJTwobZh24Rx5R/hN8v058IVLsetqLGJ3dkIqCuwaORJVYH7s1WAJT6cDAAAAAJuaAdSMhiA/c4pq1QIA4Bgs6gYARSQXmYOVhlr1j6mdkkU5kxvEGjoEAAAAAI3DbmPEUHvvO4A1XpbO4S1WPCPk5MB3K/gMRb4lf8KxQzEWCAAAAADFAgCBkPe8ES4cp/v81FI69jgguK9LsbqPcN8PM5JSZKda5TlSokl/vvB8u8XO9b0IAAAAABd2t2Eoc/CYVAHL5VIxjqsXxv25EX54AgD6NcfJLIXRQvuJoiT7k7xQlIg35bnEktCMkIqdDwQAAAAANQMAnwAACjln02TspaXoMEkOLdzJfHFTs1cNeencBgBVAwB6AABoo4lsQ5OkqWgKlg6vfz73jGrVV+ZHqZqethSIlBoEAAAAAPy8jWn+IQ6piBdBlsW/075NP5SkJtpOv3oGANMEAAAAAJntB5erkwGrtA5VPiWV0+pWqKmj5j5IDRqWzJScoZc3kJ3NPDLN5uXbPSQB0vfrKqCVzYjTF5XtrWOCSgUAAAAAGoGUt0/Q6B64z/j18vnI6uXyjHzAFVHXqj+FDsHPEttRppOgeH29MU23J0Gy7yyZ47gWpc1mfXilAwAAAACFZ9KXQyQ/1sO2VYLnojoQ4uv+EIXjx5uJlQMAAAAAMAQAAAAABw+oCpMR2yxU/morwyKARgojgBkGAGwZFvH73Y6FdJGMgjqVF0pyQp1yrMg2zUp812z78HJpC4dcB2bpjNl8Gly1r3IBIrSek2FnyDCwRgkeQviPqwQAAAAAkAQAAAAAGAgAAAAAC33xl1dusLMkYA==";
-			char* decodedData = 0;
-			int decodecLength;
-			Framework::base64Decode(data, &decodedData, &decodecLength);
-			Framework::Text encoded = Framework::base64Encode(decodedData, decodecLength);
-			Assert::IsTrue(encoded.istGleich(data));
-			delete[] decodedData;
-		}
-	};
-}
+        TEST_METHOD (TestDecodeAndEncode)
+        {
+            const char* data
+                = "g0OLN0EJepEiT8eiNdvb9PfJkIqSpiLqb3uvRwyg2Y7iZsQkbkC1kI99M8Na"
+                  "ELhT2Erca/"
+                  "D+VmB6B6aFpoAViuXZrlQaZeSo4RhtPScmjwFwbGtha8DA5Mdna2/"
+                  "ngPjOWqgkdA4JHe8hiS1Ir7tIICmygZR0Qnk8qeSrkWWlYL5OhDRcjFBMrNl"
+                  "584o1Pape7izxZG1soBdRTKi28Ap2QI2pmxr55sbTYbtelfcK8+"
+                  "c15UyiUuy4ozliWitr0Gr3egYAE3Ts2UlOlafjjbDXdeS+"
+                  "wYcRrkGz56IPEw/"
+                  "efQgAAAAAWYMbzXDzF76JvaIYb3uNVDpQ20v9Hf3mvw75zet31Ub57xRr4ys"
+                  "qbujMhVhIFKuCY4jMYqTLSWXYRDTFuwoMtfggIt1KS0w0GdGLYOQ44ki/"
+                  "r6lle/LJVDf9GvEIAAAAACaoAgBFyt6PFyzCL/"
+                  "xPj+GGcipGItOqncd18f1zDfB7Mpp9d2VcCAAAAAB7h8qphRo5Z5+"
+                  "rkeXNZZFrLQdeLHpqHvWct3MUHc8cmFjlQ9z+"
+                  "fESeKNSF9TsXYWgev5OYKrCOxmgDAAAAANmF0fUfK9thCADVAQDa3Ex6BgAi"
+                  "/vpcF13DNB1Yy0cJWw5xXef2MN0XWrl3YpVVrRFbzhFWLCez71rQSCcZUYIm"
+                  "wd4PuRDrz2mmSMo8nHlM90lcT3SDAwAAADG1AWXd06wFAAAAAOv8hxK/"
+                  "ZiB6dg1K3rKSqu4wJTwobZh24Rx5R/"
+                  "hN8v058IVLsetqLGJ3dkIqCuwaORJVYH7s1WAJT6cDAAAAAJuaAdSMhiA/"
+                  "c4pq1QIA4Bgs6gYARSQXmYOVhlr1j6mdkkU5kxvEGjoEAAAAAI3DbmPEUHvv"
+                  "O4A1XpbO4S1WPCPk5MB3K/gMRb4lf8KxQzEWCAAAAADFAgCBkPe8ES4cp/"
+                  "v81FI69jgguK9LsbqPcN8PM5JSZKda5TlSokl/"
+                  "vvB8u8XO9b0IAAAAABd2t2Eoc/"
+                  "CYVAHL5VIxjqsXxv25EX54AgD6NcfJLIXRQvuJoiT7k7xQlIg35bnEktCMkI"
+                  "qdDwQAAAAANQMAnwAACjln02TspaXoMEkOLdzJfHFTs1cNeencBgBVAwB6AA"
+                  "Boo4lsQ5OkqWgKlg6vfz73jGrVV+ZHqZqethSIlBoEAAAAAPy8jWn+"
+                  "IQ6piBdBlsW/"
+                  "075NP5SkJtpOv3oGANMEAAAAAJntB5erkwGrtA5VPiWV0+"
+                  "pWqKmj5j5IDRqWzJScoZc3kJ3NPDLN5uXbPSQB0vfrKqCVzYjTF5XtrWOCSg"
+                  "UAAAAAGoGUt0/Q6B64z/"
+                  "j18vnI6uXyjHzAFVHXqj+"
+                  "FDsHPEttRppOgeH29MU23J0Gy7yyZ47gWpc1mfXilAwAAAACFZ9KXQyQ/"
+                  "1sO2VYLnojoQ4uv+EIXjx5uJlQMAAAAAMAQAAAAABw+oCpMR2yxU/"
+                  "morwyKARgojgBkGAGwZFvH73Y6FdJGMgjqVF0pyQp1yrMg2zUp812z78HJpC"
+                  "4dcB2bpjNl8Gly1r3IBIrSek2FnyDCwRgkeQviPqwQAAAAAkAQAAAAAGAgAA"
+                  "AAAC33xl1dusLMkYA==";
+            char* decodedData = 0;
+            int decodecLength;
+            Framework::base64Decode(data, &decodedData, &decodecLength);
+            Framework::Text encoded
+                = Framework::base64Encode(decodedData, decodecLength);
+            Assert::IsTrue(encoded.istGleich(data));
+            delete[] decodedData;
+        }
+    };
+} // namespace FrameworkTests

Framework Tests/Cache.cpp

@@ -1,107 +1,143 @@
 #include "pch.h"
-#include "CppUnitTest.h"
+
 #include <Cache.h>
 
+#include "CppUnitTest.h"
+
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace FrameworkTests
 {
-	TEST_CLASS(CacheTests)
-	{
-	public:
-
-		TEST_METHOD(EmtptyTest)
-		{
-			Framework::Cache<int, int> cache(100, [](int i) {
-				return i;
-				}, Framework::CacheCleanupStrategy::RANDOM);
-			Assert::IsTrue(cache.getCurrentSize() == 0, L"getCurrentSize() on empty cache should be 0");
-			Assert::IsTrue(cache.getMaxSize() == 100, L"getMaxSize() on empty cache");
-		}
+    TEST_CLASS (CacheTests)
+    {
+    public:
+        TEST_METHOD (EmtptyTest)
+        {
+            Framework::Cache<int, int> cache(
+                100,
+                [](int i) { return i; },
+                Framework::CacheCleanupStrategy::RANDOM);
+            Assert::IsTrue(cache.getCurrentSize() == 0,
+                L"getCurrentSize() on empty cache should be 0");
+            Assert::IsTrue(
+                cache.getMaxSize() == 100, L"getMaxSize() on empty cache");
+        }
 
-		TEST_METHOD(PutTest)
-		{
-			Framework::Cache<int, int> cache(2, [](int i) {
-				return i;
-				}, Framework::CacheCleanupStrategy::RANDOM);
-			cache.put(0, 100);
-			cache.put(1, 10);
-			cache.put(2, 1000);
-			Assert::IsTrue(cache.getCurrentSize() == 2, L"unexpected count of elements in cache");
-			Assert::IsTrue(cache.has(0) ? cache.get(0) == 100 : 1, L"invalid value at key 0 in cache after adding elements");
-			Assert::IsTrue(cache.has(1) ? cache.get(1) == 10 : 1, L"invalid value at key 1 in cache after adding elements");
-			Assert::IsTrue(cache.get(2) == 1000, L"invalid value at key 2 in cache after adding elements");
-			int count = 0;
-			for (Framework::MapEntry< int, int > i : cache)
-			{
-				if (i.getKey() == 0)
-					Assert::IsTrue(i.getValue() == 100, L"invalid value at key 0 in cache after adding elements");
-				else if (i.getKey() == 1)
-					Assert::IsTrue(i.getValue() == 10, L"invalid value at key 1 in cache after adding elements");
-				else if (i.getKey() == 2)
-					Assert::IsTrue(i.getValue() == 1000, L"invalid value at key 2 in cache after adding elements");
-				else
-					Assert::Fail(L"invalid key in cache after adding elements");
-				count++;
-			}
-			Assert::IsTrue(count == 2, L"unexpected count of elements in cache");
-		}
+        TEST_METHOD (PutTest)
+        {
+            Framework::Cache<int, int> cache(
+                2,
+                [](int i) { return i; },
+                Framework::CacheCleanupStrategy::RANDOM);
+            cache.put(0, 100);
+            cache.put(1, 10);
+            cache.put(2, 1000);
+            Assert::IsTrue(cache.getCurrentSize() == 2,
+                L"unexpected count of elements in cache");
+            Assert::IsTrue(cache.has(0) ? cache.get(0) == 100 : 1,
+                L"invalid value at key 0 in cache after adding elements");
+            Assert::IsTrue(cache.has(1) ? cache.get(1) == 10 : 1,
+                L"invalid value at key 1 in cache after adding elements");
+            Assert::IsTrue(cache.get(2) == 1000,
+                L"invalid value at key 2 in cache after adding elements");
+            int count = 0;
+            for (Framework::MapEntry<int, int> i : cache)
+            {
+                if (i.getKey() == 0)
+                    Assert::IsTrue(i.getValue() == 100,
+                        L"invalid value at key 0 in cache after adding "
+                        L"elements");
+                else if (i.getKey() == 1)
+                    Assert::IsTrue(i.getValue() == 10,
+                        L"invalid value at key 1 in cache after adding "
+                        L"elements");
+                else if (i.getKey() == 2)
+                    Assert::IsTrue(i.getValue() == 1000,
+                        L"invalid value at key 2 in cache after adding "
+                        L"elements");
+                else
+                    Assert::Fail(L"invalid key in cache after adding elements");
+                count++;
+            }
+            Assert::IsTrue(
+                count == 2, L"unexpected count of elements in cache");
+        }
 
-		TEST_METHOD(OldestTest)
-		{
-			Framework::Cache<int, int> cache(2, [](int i) {
-				return i;
-				}, Framework::CacheCleanupStrategy::OLDEST);
-			cache.put(0, 100);
-			Sleep(1000);
-			cache.put(1, 10);
-			Sleep(1000);
-			cache.put(2, 1000);
-			Assert::IsTrue(cache.getCurrentSize() == 2, L"unexpected count of elements in cache");
-			Assert::IsFalse(cache.has(0), L"invalid value at key 0 in cache after adding elements");
-			Assert::IsTrue(cache.has(1) && cache.get(1) == 10, L"invalid value at key 1 in cache after adding elements");
-			Assert::IsTrue(cache.get(2) == 1000, L"invalid value at key 2 in cache after adding elements");
-			int count = 0;
-			for (Framework::MapEntry< int, int > i : cache)
-			{
-				if (i.getKey() == 1)
-					Assert::IsTrue(i.getValue() == 10, L"invalid value at key 1 in cache after adding elements");
-				else if (i.getKey() == 2)
-					Assert::IsTrue(i.getValue() == 1000, L"invalid value at key 2 in cache after adding elements");
-				else
-					Assert::Fail(L"invalid key in cache after adding elements");
-				count++;
-			}
-			Assert::IsTrue(count == 2, L"unexpected count of elements in cache");
-		}
+        TEST_METHOD (OldestTest)
+        {
+            Framework::Cache<int, int> cache(
+                2,
+                [](int i) { return i; },
+                Framework::CacheCleanupStrategy::OLDEST);
+            cache.put(0, 100);
+            Sleep(1000);
+            cache.put(1, 10);
+            Sleep(1000);
+            cache.put(2, 1000);
+            Assert::IsTrue(cache.getCurrentSize() == 2,
+                L"unexpected count of elements in cache");
+            Assert::IsFalse(cache.has(0),
+                L"invalid value at key 0 in cache after adding elements");
+            Assert::IsTrue(cache.has(1) && cache.get(1) == 10,
+                L"invalid value at key 1 in cache after adding elements");
+            Assert::IsTrue(cache.get(2) == 1000,
+                L"invalid value at key 2 in cache after adding elements");
+            int count = 0;
+            for (Framework::MapEntry<int, int> i : cache)
+            {
+                if (i.getKey() == 1)
+                    Assert::IsTrue(i.getValue() == 10,
+                        L"invalid value at key 1 in cache after adding "
+                        L"elements");
+                else if (i.getKey() == 2)
+                    Assert::IsTrue(i.getValue() == 1000,
+                        L"invalid value at key 2 in cache after adding "
+                        L"elements");
+                else
+                    Assert::Fail(L"invalid key in cache after adding elements");
+                count++;
+            }
+            Assert::IsTrue(
+                count == 2, L"unexpected count of elements in cache");
+        }
 
-		TEST_METHOD(LongestNotUsedTest)
-		{
-			Framework::Cache<int, int> cache(2, [](int i) {
-				return i;
-				}, Framework::CacheCleanupStrategy::LONGEST_NOT_USED);
-			cache.put(0, 100);
-			Sleep(1000);
-			cache.put(1, 10);
-			Sleep(1000);
-			cache.get(0);
-			cache.put(2, 1000);
-			Assert::IsTrue(cache.getCurrentSize() == 2, L"unexpected count of elements in cache");
-			Assert::IsTrue(cache.has(0) && cache.get(0) == 100, L"invalid value at key 0 in cache after adding elements");
-			Assert::IsFalse(cache.has(1), L"invalid value at key 1 in cache after adding elements");
-			Assert::IsTrue(cache.get(2) == 1000, L"invalid value at key 2 in cache after adding elements");
-			int count = 0;
-			for (Framework::MapEntry< int, int > i : cache)
-			{
-				if (i.getKey() == 0)
-					Assert::IsTrue(i.getValue() == 100, L"invalid value at key 0 in cache after adding elements");
-				else if (i.getKey() == 2)
-					Assert::IsTrue(i.getValue() == 1000, L"invalid value at key 2 in cache after adding elements");
-				else
-					Assert::Fail(L"invalid key in cache after adding elements");
-				count++;
-			}
-			Assert::IsTrue(count == 2, L"unexpected count of elements in cache");
-		}
-	};
-}
+        TEST_METHOD (LongestNotUsedTest)
+        {
+            Framework::Cache<int, int> cache(
+                2,
+                [](int i) { return i; },
+                Framework::CacheCleanupStrategy::LONGEST_NOT_USED);
+            cache.put(0, 100);
+            Sleep(1000);
+            cache.put(1, 10);
+            Sleep(1000);
+            cache.get(0);
+            cache.put(2, 1000);
+            Assert::IsTrue(cache.getCurrentSize() == 2,
+                L"unexpected count of elements in cache");
+            Assert::IsTrue(cache.has(0) && cache.get(0) == 100,
+                L"invalid value at key 0 in cache after adding elements");
+            Assert::IsFalse(cache.has(1),
+                L"invalid value at key 1 in cache after adding elements");
+            Assert::IsTrue(cache.get(2) == 1000,
+                L"invalid value at key 2 in cache after adding elements");
+            int count = 0;
+            for (Framework::MapEntry<int, int> i : cache)
+            {
+                if (i.getKey() == 0)
+                    Assert::IsTrue(i.getValue() == 100,
+                        L"invalid value at key 0 in cache after adding "
+                        L"elements");
+                else if (i.getKey() == 2)
+                    Assert::IsTrue(i.getValue() == 1000,
+                        L"invalid value at key 2 in cache after adding "
+                        L"elements");
+                else
+                    Assert::Fail(L"invalid key in cache after adding elements");
+                count++;
+            }
+            Assert::IsTrue(
+                count == 2, L"unexpected count of elements in cache");
+        }
+    };
+} // namespace FrameworkTests

Framework Tests/Framework Tests.vcxproj

@@ -175,6 +175,7 @@
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
     </ClCompile>
+    <ClCompile Include="Text.cpp" />
     <ClCompile Include="XML.cpp" />
   </ItemGroup>
   <ItemGroup>

Framework Tests/Framework Tests.vcxproj.filters

@@ -33,6 +33,9 @@
     <ClCompile Include="Base64.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Text.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="pch.h">

Framework Tests/Json.cpp

@@ -10,10 +10,10 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace FrameworkTests
 {
-    TEST_CLASS(JSONParserTests)
+    TEST_CLASS (JSONParserTests)
     {
     public:
-        TEST_METHOD(NullTest)
+        TEST_METHOD (NullTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("null");
@@ -26,7 +26,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(BooleanTest)
+        TEST_METHOD (BooleanTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("false");
@@ -58,7 +58,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(StringTest)
+        TEST_METHOD (StringTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("\"test\"");
@@ -92,7 +92,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(NumberTest)
+        TEST_METHOD (NumberTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("0");
@@ -151,7 +151,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(ArrayTest)
+        TEST_METHOD (ArrayTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("[]");
@@ -201,7 +201,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(MultipleArrayTest)
+        TEST_METHOD (MultipleArrayTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("[[1],2,[[]]]");
@@ -233,7 +233,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(ObjectTest)
+        TEST_METHOD (ObjectTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue("{\" \": []}");
@@ -256,7 +256,7 @@ namespace FrameworkTests
             value->release();
         }
 
-        TEST_METHOD(ToStringTest)
+        TEST_METHOD (ToStringTest)
         {
             Framework::JSON::JSONValue* value
                 = Framework::JSON::Parser::getValue(
@@ -334,7 +334,7 @@ namespace FrameworkTests
             return 1;
         }
 
-        TEST_METHOD(ToArrayTest)
+        TEST_METHOD (ToArrayTest)
         {
             Framework::JSON::JSONArray* jArray
                 = Framework::JSON::Parser::getValue("[1,2,3,4,5,6,7,8,9,10]")
@@ -364,7 +364,7 @@ namespace FrameworkTests
             jArray->release();
         }
 
-        TEST_METHOD(ToRCArrayTest)
+        TEST_METHOD (ToRCArrayTest)
         {
             Framework::JSON::JSONArray* jArray
                 = Framework::JSON::Parser::getValue(
@@ -403,7 +403,7 @@ namespace FrameworkTests
             Framework::Text value;
         };
 
-        TEST_METHOD(ParseObjectTest)
+        TEST_METHOD (ParseObjectTest)
         {
             Framework::JSON::JSONObject* jObj
                 = Framework::JSON::Parser::getValue(
@@ -430,7 +430,7 @@ namespace FrameworkTests
             jObj->release();
         }
 
-        TEST_METHOD(FromArrayTest)
+        TEST_METHOD (FromArrayTest)
         {
             Framework::Array<int> arr;
             arr.add(1);
@@ -469,7 +469,7 @@ namespace FrameworkTests
         }
     };
 
-    TEST_CLASS(JSONValidatorTests)
+    TEST_CLASS (JSONValidatorTests)
     {
     private:
         static OutputDebugStringBuf<char, std::char_traits<char>>
@@ -483,7 +483,7 @@ namespace FrameworkTests
             std::cout.rdbuf(&charDebugOutput);
         }
 
-        TEST_METHOD(ValidTest)
+        TEST_METHOD (ValidTest)
         {
             Framework::JSON::Validator::JSONValidator* validator
                 = Framework::JSON::Validator::JSONValidator::buildForArray()
@@ -506,7 +506,7 @@ namespace FrameworkTests
             validator->release();
         }
 
-        TEST_METHOD(ComplexTest)
+        TEST_METHOD (ComplexTest)
         {
             Framework::JSON::Validator::JSONValidator* validator
                 = Framework::JSON::Validator::JSONValidator::buildForArray()
@@ -607,7 +607,7 @@ namespace FrameworkTests
             validator->release();
         }
 
-        TEST_METHOD(ComplexRemoveInvalidTest)
+        TEST_METHOD (ComplexRemoveInvalidTest)
         {
             Framework::JSON::Validator::JSONValidator* validator
                 = Framework::JSON::Validator::JSONValidator::buildForArray()
@@ -728,7 +728,7 @@ namespace FrameworkTests
             validator->release();
         }
 
-        TEST_METHOD(DefaultValuesTest)
+        TEST_METHOD (DefaultValuesTest)
         {
             Framework::JSON::Validator::JSONValidator* validator
                 = Framework::JSON::Validator::JSONValidator::buildForArray()
@@ -889,7 +889,7 @@ namespace FrameworkTests
             validator->release();
         }
 
-        TEST_METHOD(RecursiveValidatorTest)
+        TEST_METHOD (RecursiveValidatorTest)
         {
             Framework::JSON::Validator::JSONValidator* validator
                 = Framework::JSON::Validator::JSONValidator::buildForObject()

Framework Tests/Text.cpp

@@ -0,0 +1,22 @@
+#include "pch.h"
+
+#include <Text.h>
+
+#include "CppUnitTest.h"
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace Framework;
+
+namespace FrameworkTests
+{
+    TEST_CLASS (TextTests)
+    {
+    public:
+        TEST_METHOD (AppendStreamTest)
+        {
+            Text test = "Test";
+            test.append() << " " << 1 << " " << 3.14;
+            Assert::AreEqual(test.getText(), "Test 1 3.14");
+        }
+    };
+} // namespace FrameworkTests

Framework Tests/XML.cpp

@@ -1,116 +1,183 @@
 #include "pch.h"
-#include "CppUnitTest.h"
+
 #include <XML.h>
 
+#include "CppUnitTest.h"
+
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace FrameworkTests
 {
-    TEST_CLASS(XMLParserTests)
+    TEST_CLASS (XMLParserTests)
     {
     public:
-        TEST_METHOD(EmptyElementTest)
+        TEST_METHOD (EmptyElementTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml attr attr2=\"\" attr3=\"true\"/>");
-            Assert::IsTrue(element->getAttributeCount() == 3, L"One ore more xml attributes are missing");
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 0, L"Das Element sollte keine Kinder haben");
-            Assert::IsTrue(element->hasAttribute("attr"), L"Das Attribut attr fehlt");
-            Assert::IsTrue(element->hasAttribute("attr2"), L"Das Attribut attr2 fehlt");
-            Assert::IsTrue(element->hasAttribute("attr3"), L"Das Attribut attr3 fehlt");
-            Assert::IsTrue(element->hasAttribute("") == 0, L"Es gibt ein falsches Attribut");
-            Assert::IsTrue(element->getAttributeName(0).istGleich("attr"), L"Der Attribut name ist falsch");
-            Assert::IsTrue(element->getAttributeName(1).istGleich("attr2"), L"Der Attribut name ist falsch");
-            Assert::IsTrue(element->getAttributeName(2).istGleich("attr3"), L"Der Attribut name ist falsch");
-            Assert::IsTrue(element->getAttributeValue("attr").istGleich(""), L"Der Wert des Attributes ist falsch");
-            Assert::IsTrue(element->getAttributeValue("attr2").istGleich(""), L"Der Wert des Attributes ist falsch");
-            Assert::IsTrue(element->getAttributeValue("attr3").istGleich("true"), L"Der Wert des Attributes ist falsch");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml attr attr2=\"\" attr3=\"true\"/>");
+            Assert::IsTrue(element->getAttributeCount() == 3,
+                L"One ore more xml attributes are missing");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 0,
+                L"Das Element sollte keine Kinder haben");
+            Assert::IsTrue(
+                element->hasAttribute("attr"), L"Das Attribut attr fehlt");
+            Assert::IsTrue(
+                element->hasAttribute("attr2"), L"Das Attribut attr2 fehlt");
+            Assert::IsTrue(
+                element->hasAttribute("attr3"), L"Das Attribut attr3 fehlt");
+            Assert::IsTrue(element->hasAttribute("") == 0,
+                L"Es gibt ein falsches Attribut");
+            Assert::IsTrue(element->getAttributeName(0).istGleich("attr"),
+                L"Der Attribut name ist falsch");
+            Assert::IsTrue(element->getAttributeName(1).istGleich("attr2"),
+                L"Der Attribut name ist falsch");
+            Assert::IsTrue(element->getAttributeName(2).istGleich("attr3"),
+                L"Der Attribut name ist falsch");
+            Assert::IsTrue(element->getAttributeValue("attr").istGleich(""),
+                L"Der Wert des Attributes ist falsch");
+            Assert::IsTrue(element->getAttributeValue("attr2").istGleich(""),
+                L"Der Wert des Attributes ist falsch");
+            Assert::IsTrue(
+                element->getAttributeValue("attr3").istGleich("true"),
+                L"Der Wert des Attributes ist falsch");
             element->release();
         }
 
-        TEST_METHOD(ChildrenElementTest)
+        TEST_METHOD (ChildrenElementTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml><a1/><a2/></xml>");
-            Assert::IsTrue(element->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 2, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"), L"Der Element Name ist falsch");
+            Framework::XML::Element* element
+                = new Framework::XML::Element("<xml><a1/><a2/></xml>");
+            Assert::IsTrue(element->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 2,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"),
+                L"Der Element Name ist falsch");
             element->release();
         }
 
-        TEST_METHOD(WhitespaceTest)
+        TEST_METHOD (WhitespaceTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml \t \r\n \t > \r\n <a1 x y z=\"\"/> <a2/>\t</xml     >");
-            Assert::IsTrue(element->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 2, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"), L"Der Element Name ist falsch");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml \t \r\n \t > \r\n <a1 x y z=\"\"/> <a2/>\t</xml     >");
+            Assert::IsTrue(element->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 2,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"),
+                L"Der Element Name ist falsch");
             element->release();
         }
     };
 
-    TEST_CLASS(XMLEditorTests)
+    TEST_CLASS (XMLEditorTests)
     {
     public:
-        TEST_METHOD(SetAttributeTest)
+        TEST_METHOD (SetAttributeTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml><a1 x y z=\"\"/><a2/></xml>");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml><a1 x y z=\"\"/><a2/></xml>");
             element->selectChildren().setAttribute("x", "true");
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 2, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 1, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeValue("x").istGleich("true"), L"Der Attribut wert ist falsch");
-            Assert::IsTrue(element->zChild(1)->getAttributeValue("x").istGleich("true"), L"Der Attribut wert ist falsch");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 2,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 1,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(
+                element->zChild(0)->getAttributeValue("x").istGleich("true"),
+                L"Der Attribut wert ist falsch");
+            Assert::IsTrue(
+                element->zChild(1)->getAttributeValue("x").istGleich("true"),
+                L"Der Attribut wert ist falsch");
             element->release();
         }
 
-        TEST_METHOD(RemoveAttributeTest)
+        TEST_METHOD (RemoveAttributeTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml><a1 x y z=\"\"/><a2/></xml>");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml><a1 x y z=\"\"/><a2/></xml>");
             element->selectChildren().removeAttribute("x");
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 2, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 2, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(0)->hasAttribute("x") == 0, L"Ein entferntes Attibut ist noch vorhanden");
-            Assert::IsTrue(element->zChild(1)->hasAttribute("x") == 0, L"Ein entferntes Attibut ist noch vorhanden");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 2,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 2,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(0)->hasAttribute("x") == 0,
+                L"Ein entferntes Attibut ist noch vorhanden");
+            Assert::IsTrue(element->zChild(1)->hasAttribute("x") == 0,
+                L"Ein entferntes Attibut ist noch vorhanden");
             element->release();
         }
 
-        TEST_METHOD(AddChildrenTest)
+        TEST_METHOD (AddChildrenTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml><a1 x y z=\"\"/><a2/></xml>");
-            element->selectChildren().whereAttributeExists("x").addChild(element->dublicate());
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 2, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
-            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->zChild(0)->getChildCount() == 1, L"Anzahl der Kinder ist Falsch");
-            Assert::IsTrue(element->zChild(1)->getChildCount() == 0, L"Anzahl der Kinder ist Falsch");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml><a1 x y z=\"\"/><a2/></xml>");
+            element->selectChildren().whereAttributeExists("x").addChild(
+                element->dublicate());
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 2,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 3,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(1)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->zChild(0)->getName().istGleich("a1"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(1)->getName().istGleich("a2"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->zChild(0)->getChildCount() == 1,
+                L"Anzahl der Kinder ist Falsch");
+            Assert::IsTrue(element->zChild(1)->getChildCount() == 0,
+                L"Anzahl der Kinder ist Falsch");
             element->release();
         }
 
-        TEST_METHOD(RemoveTest)
+        TEST_METHOD (RemoveTest)
         {
-            Framework::XML::Element* element = new Framework::XML::Element("<xml><a1 x y z=\"\"/><a2/></xml>");
+            Framework::XML::Element* element = new Framework::XML::Element(
+                "<xml><a1 x y z=\"\"/><a2/></xml>");
             element->selectChildren().whereAttributeExists("x").remove();
-            Assert::IsTrue(element->getName().istGleich("xml"), L"Der Element Name ist falsch");
-            Assert::IsTrue(element->getChildCount() == 1, L"Die Anzahl der Kinder ist falsch");
-            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 0, L"Die Anzahl der Attribute stimmt nicht");
+            Assert::IsTrue(element->getName().istGleich("xml"),
+                L"Der Element Name ist falsch");
+            Assert::IsTrue(element->getChildCount() == 1,
+                L"Die Anzahl der Kinder ist falsch");
+            Assert::IsTrue(element->zChild(0)->getAttributeCount() == 0,
+                L"Die Anzahl der Attribute stimmt nicht");
             element->release();
         }
     };
-}
+} // namespace FrameworkTests

Text.cpp

@@ -10,6 +10,25 @@
 
 using namespace Framework;
 
+DynamicBuffer::DynamicBuffer(std::function<int(std::stringbuf&)> onAppend)
+    : std::stringbuf(),
+      onAppend(onAppend)
+{}
+
+int DynamicBuffer::sync()
+{
+    return onAppend(*this);
+}
+
+FlushingOStream::FlushingOStream(DynamicBuffer* buffer)
+    : std::ostream(buffer)
+{}
+
+FlushingOStream::~FlushingOStream()
+{
+    flush();
+}
+
 // inhalt der Text Klasse aus Text.h
 // Konstruktor
 Text::Text()
@@ -17,7 +36,13 @@ Text::Text()
       txt(0),
       suchGBeg(0),
       suchGEnd(0),
-      precision(0)
+      precision(0),
+      stringWriter(DynamicBuffer([this](std::stringbuf& buf) {
+          std::string str = buf.str();
+          this->append(str.c_str());
+          buf.str("");
+          return 0;
+      }))
 {
     setText("");
 }
@@ -254,6 +279,12 @@ void Text::append(float num)
     append(ss.str().c_str());
 }
 
+//! Gibt einen ostream zurück, der alle ausgaben an diesen Text anhängt
+FlushingOStream Text::append()
+{
+    return FlushingOStream(&stringWriter);
+}
+
 void Text::insert(int p, char c) // Fügt an stelle p ein
 {
     if (p > getLength() || p < 0) // Auf unsinnige übergabe prüfen
@@ -401,7 +432,7 @@ void Text::ersetzen(const char* t1, Text* t2)
 void Text::ersetzen(Text* t1, Text* t2)
 {
     if (t1->getLength() > 0
-        && t2->getLength() >= 0)                // Auf unsinnige übergabe prüfen
+        && t2->getLength() >= 0) // Auf unsinnige übergabe prüfen
         ersetzen(t1->getText(), t2->getText()); // ersetzen
     t1->release();                              // Übergaben loslassen
     t2->release();

Text.h

@@ -1,6 +1,9 @@
 #ifndef Text_H
 #define Text_H
 
+#include <functional>
+#include <sstream>
+
 #include "Reader.h"
 #include "ReferenceCounter.h"
 
@@ -8,6 +11,25 @@ namespace Framework
 {
     class Text; //! aus dieser Datei
 
+    class DynamicBuffer : public std::stringbuf
+    {
+    private:
+        std::function<int(std::stringbuf&)> onAppend;
+
+    public:
+        DLLEXPORT DynamicBuffer(std::function<int(std::stringbuf&)> onAppend);
+
+        DLLEXPORT virtual int sync() override;
+    };
+
+    class FlushingOStream : public std::ostream
+    {
+    public:
+        DLLEXPORT FlushingOStream(DynamicBuffer* buffer);
+
+        DLLEXPORT ~FlushingOStream();
+    };
+
     //! Ein ersatz für String
     class Text : public virtual ReferenceCounter
     {
@@ -16,6 +38,7 @@ namespace Framework
         char suchGBeg;
         char suchGEnd;
         int precision;
+        DynamicBuffer stringWriter;
 
     public:
         //! Erstellt ein neues Text Objekt mit dem Wert ""
@@ -98,6 +121,8 @@ namespace Framework
         //! \param num Die Kommazahl, die am Ende des Textes angehängt werden
         //! soll
         DLLEXPORT void append(float num);
+        //! Gibt einen ostream zurück, der alle ausgaben an diesen Text anhängt
+        DLLEXPORT FlushingOStream append();
         //! Fügt an einer Bestimmten Stelle ein Zeichen in den Text ein
         //! \param p Die position im Text bei der das Zeichen eingefügt werden
         //! soll \param c Das Zeichen, das eingefügt werden soll

TextFeld.cpp

@@ -243,11 +243,11 @@ TextFeld::TextStyle TextFeld::TextStyleManager::getTextStyle(int index) const
 TextFeld::TextFeld()
     : ZeichnungHintergrund(),
       tm(new TextStyleManager()),
+      autoLineBreakSpacing(0),
       showChar(0),
       cpos(0),
       tickVal(0),
-      mausKlick(0),
-      autoLineBreakSpacing(0)
+      mausKlick(0)
 {
     charEvent = 0;
     horizontalScrollBar = new HScrollBar();