unittest-cpp
diff --git a/‎.uncrustify
Lines changed: 488 additions & 0 deletions b/‎.uncrustify
Lines changed: 488 additions & 0 deletions
diff --git a/‎UnitTest++/AssertException.cpp
Lines changed: 4 additions & 6 deletions b/‎UnitTest++/AssertException.cpp
Lines changed: 4 additions & 6 deletions
diff --git a/‎UnitTest++/AssertException.h
Lines changed: 6 additions & 6 deletions b/‎UnitTest++/AssertException.h
Lines changed: 6 additions & 6 deletions
diff --git a/‎UnitTest++/CheckMacros.h
Lines changed: 144 additions & 144 deletions b/‎UnitTest++/CheckMacros.h
Lines changed: 144 additions & 144 deletions
diff --git a/‎UnitTest++/Checks.cpp
Lines changed: 42 additions & 42 deletions b/‎UnitTest++/Checks.cpp
Lines changed: 42 additions & 42 deletions
diff --git a/‎UnitTest++/Checks.h
Lines changed: 107 additions & 107 deletions b/‎UnitTest++/Checks.h
Lines changed: 107 additions & 107 deletions
@@ -4,13 +4,11 @@
 
 namespace UnitTest {
 
-AssertException::AssertException()
-{
-}
+   AssertException::AssertException()
+   {}
 
-AssertException::~AssertException() throw()
-{
-}
+   AssertException::~AssertException() throw()
+   {}
 
 }
 
 
@@ -9,12 +9,12 @@
 
 namespace UnitTest {
 
-class UNITTEST_LINKAGE AssertException : public std::exception
-{
-public:
-    AssertException();
-    virtual ~AssertException() throw();
-};
+   class UNITTEST_LINKAGE AssertException : public std::exception
+   {
+   public:
+      AssertException();
+      virtual ~AssertException() throw();
+   };
 
 }
 
 
@@ -3,48 +3,48 @@
 
 namespace UnitTest {
 
-namespace {
-
-void CheckStringsEqual(TestResults& results, char const* expected, char const* actual, 
-                       TestDetails const& details)
-{
-	using namespace std;
-
-    if ((expected && actual) ? strcmp(expected, actual) : (expected || actual))
-    {
-        UnitTest::MemoryOutStream stream;
-        stream << "Expected " << (expected ? expected : "<NULLPTR>") << " but was " << (actual ? actual : "<NULLPTR>");
-
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
-
-}
-
-
-void CheckEqual(TestResults& results, char const* expected, char const* actual,
-                TestDetails const& details)
-{
-    CheckStringsEqual(results, expected, actual, details);
-}
-
-void CheckEqual(TestResults& results, char* expected, char* actual,
-                TestDetails const& details)
-{
-    CheckStringsEqual(results, expected, actual, details);
-}
-
-void CheckEqual(TestResults& results, char* expected, char const* actual,
-                TestDetails const& details)
-{
-    CheckStringsEqual(results, expected, actual, details);
-}
-
-void CheckEqual(TestResults& results, char const* expected, char* actual,
-                TestDetails const& details)
-{
-    CheckStringsEqual(results, expected, actual, details);
-}
+   namespace {
+
+      void CheckStringsEqual(TestResults& results, char const* expected, char const* actual,
+                             TestDetails const& details)
+         using namespace std;
+
+         if ((expected && actual) ? strcmp(expected, actual) : (expected || actual))
+         {
+            UnitTest::MemoryOutStream stream;
+            stream << "Expected " << (expected ? expected : "<NULLPTR>") << " but was " << (actual ? actual : "<NULLPTR>");
+
+            results.OnTestFailure(details, stream.GetText());
+         }
+      }
+
+   }
+
+
+   void CheckEqual(TestResults& results, char const* expected, char const* actual,
+                   TestDetails const& details)
+   {
+      CheckStringsEqual(results, expected, actual, details);
+   }
+
+   void CheckEqual(TestResults& results, char* expected, char* actual,
+                   TestDetails const& details)
+   {
+      CheckStringsEqual(results, expected, actual, details);
+   }
+
+   void CheckEqual(TestResults& results, char* expected, char const* actual,
+                   TestDetails const& details)
+   {
+      CheckStringsEqual(results, expected, actual, details);
+   }
+
+   void CheckEqual(TestResults& results, char const* expected, char* actual,
+                   TestDetails const& details)
+   {
+      CheckStringsEqual(results, expected, actual, details);
+   }
 
 
 }
@@ -8,150 +8,150 @@
 namespace UnitTest {
 
 
-template< typename Value >
-bool Check(Value const value)
-{
-    return !!value; // doing double negative to avoid silly VS warnings
-}
+   template< typename Value >
+   bool Check(Value const value)
+   {
+      return !!value; // doing double negative to avoid silly VS warnings
+   }
 
 
-template< typename Expected, typename Actual >
-void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
-{
-    if (!(expected == actual))
-    {
-        UnitTest::MemoryOutStream stream;
-        stream << "Expected " << expected << " but was " << actual;
+   template< typename Expected, typename Actual >
+   void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
+   {
+      if (!(expected == actual))
+      {
+         UnitTest::MemoryOutStream stream;
+         stream << "Expected " << expected << " but was " << actual;
 
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
+         results.OnTestFailure(details, stream.GetText());
+      }
+   }
 
-UNITTEST_LINKAGE void CheckEqual(TestResults& results, char const* expected, char const* actual, TestDetails const& details);
+   UNITTEST_LINKAGE void CheckEqual(TestResults& results, char const* expected, char const* actual, TestDetails const& details);
 
-UNITTEST_LINKAGE void CheckEqual(TestResults& results, char* expected, char* actual, TestDetails const& details);
+   UNITTEST_LINKAGE void CheckEqual(TestResults& results, char* expected, char* actual, TestDetails const& details);
 
-UNITTEST_LINKAGE void CheckEqual(TestResults& results, char* expected, char const* actual, TestDetails const& details);
+   UNITTEST_LINKAGE void CheckEqual(TestResults& results, char* expected, char const* actual, TestDetails const& details);
 
-UNITTEST_LINKAGE void CheckEqual(TestResults& results, char const* expected, char* actual, TestDetails const& details);
+   UNITTEST_LINKAGE void CheckEqual(TestResults& results, char const* expected, char* actual, TestDetails const& details);
 
-template< typename Expected, typename Actual, typename Tolerance >
-bool AreClose(Expected const& expected, Actual const& actual, Tolerance const& tolerance)
-{
-    return (actual >= (expected - tolerance)) && (actual <= (expected + tolerance));
-}
+   template< typename Expected, typename Actual, typename Tolerance >
+   bool AreClose(Expected const& expected, Actual const& actual, Tolerance const& tolerance)
+   {
+      return (actual >= (expected - tolerance)) && (actual <= (expected + tolerance));
+   }
 
-template< typename Expected, typename Actual, typename Tolerance >
-void CheckClose(TestResults& results, Expected const& expected, Actual const& actual, Tolerance const& tolerance,
-                TestDetails const& details)
-{
-    if (!AreClose(expected, actual, tolerance))
-    { 
-        UnitTest::MemoryOutStream stream;
-        stream << "Expected " << expected << " +/- " << tolerance << " but was " << actual;
-
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
+   template< typename Expected, typename Actual, typename Tolerance >
+   void CheckClose(TestResults& results, Expected const& expected, Actual const& actual, Tolerance const& tolerance,
+                   TestDetails const& details)
+   {
+      if (!AreClose(expected, actual, tolerance))
+      {
+         UnitTest::MemoryOutStream stream;
+         stream << "Expected " << expected << " +/- " << tolerance << " but was " << actual;
 
+         results.OnTestFailure(details, stream.GetText());
+      }
+   }
 
-template< typename Expected, typename Actual >
-void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual,
-                int const count, TestDetails const& details)
-{
-    bool equal = true;
-    for (int i = 0; i < count; ++i)
-        equal &= (expected[i] == actual[i]);
 
-    if (!equal)
-    {
-        UnitTest::MemoryOutStream stream;
+   template< typename Expected, typename Actual >
+   void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual,
+                        int const count, TestDetails const& details)
+   {
+      bool equal = true;
+      for (int i = 0; i < count; ++i)
+         equal &= (expected[i] == actual[i]);
 
-		stream << "Expected [ ";
+      if (!equal)
+      {
+         UnitTest::MemoryOutStream stream;
 
-		for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
+         stream << "Expected [ ";
+
+         for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
             stream << expected[expectedIndex] << " ";
 
-		stream << "] but was [ ";
+         stream << "] but was [ ";
 
-		for (int actualIndex = 0; actualIndex < count; ++actualIndex)
+         for (int actualIndex = 0; actualIndex < count; ++actualIndex)
             stream << actual[actualIndex] << " ";
 
-		stream << "]";
-
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
-
-template< typename Expected, typename Actual, typename Tolerance >
-bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
-{
-    bool equal = true;
-    for (int i = 0; i < count; ++i)
-        equal &= AreClose(expected[i], actual[i], tolerance);
-    return equal;
-}
-
-template< typename Expected, typename Actual, typename Tolerance >
-void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual,
-                   int const count, Tolerance const& tolerance, TestDetails const& details)
-{
-    bool equal = ArrayAreClose(expected, actual, count, tolerance);
-
-    if (!equal)
-    {
-        UnitTest::MemoryOutStream stream;
-
-        stream << "Expected [ ";
-        for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
+         stream << "]";
+
+         results.OnTestFailure(details, stream.GetText());
+      }
+   }
+
+   template< typename Expected, typename Actual, typename Tolerance >
+   bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
+   {
+      bool equal = true;
+      for (int i = 0; i < count; ++i)
+         equal &= AreClose(expected[i], actual[i], tolerance);
+      return equal;
+   }
+
+   template< typename Expected, typename Actual, typename Tolerance >
+   void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual,
+                        int const count, Tolerance const& tolerance, TestDetails const& details)
+   {
+      bool equal = ArrayAreClose(expected, actual, count, tolerance);
+
+      if (!equal)
+      {
+         UnitTest::MemoryOutStream stream;
+
+         stream << "Expected [ ";
+         for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
             stream << expected[expectedIndex] << " ";
-        stream << "] +/- " << tolerance << " but was [ ";
+         stream << "] +/- " << tolerance << " but was [ ";
 
-		for (int actualIndex = 0; actualIndex < count; ++actualIndex)
+         for (int actualIndex = 0; actualIndex < count; ++actualIndex)
             stream << actual[actualIndex] << " ";
-        stream << "]";
+         stream << "]";
 
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
+         results.OnTestFailure(details, stream.GetText());
+      }
+   }
 
-template< typename Expected, typename Actual, typename Tolerance >
-void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual,
-                   int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details)
-{
-    bool equal = true;
-    for (int i = 0; i < rows; ++i)
-        equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance);
+   template< typename Expected, typename Actual, typename Tolerance >
+   void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual,
+                          int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details)
+   {
+      bool equal = true;
+      for (int i = 0; i < rows; ++i)
+         equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance);
 
-    if (!equal)
-    {
-        UnitTest::MemoryOutStream stream;
+      if (!equal)
+      {
+         UnitTest::MemoryOutStream stream;
 
-        stream << "Expected [ ";    
+         stream << "Expected [ ";
 
-		for (int expectedRow = 0; expectedRow < rows; ++expectedRow)
-        {
+         for (int expectedRow = 0; expectedRow < rows; ++expectedRow)
+         {
             stream << "[ ";
             for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn)
-                stream << expected[expectedRow][expectedColumn] << " ";
+               stream << expected[expectedRow][expectedColumn] << " ";
             stream << "] ";
-        }
+         }
 
-		stream << "] +/- " << tolerance << " but was [ ";
+         stream << "] +/- " << tolerance << " but was [ ";
 
-		for (int actualRow = 0; actualRow < rows; ++actualRow)
-        {
+         for (int actualRow = 0; actualRow < rows; ++actualRow)
+         {
             stream << "[ ";
             for (int actualColumn = 0; actualColumn < columns; ++actualColumn)
-                stream << actual[actualRow][actualColumn] << " ";
+               stream << actual[actualRow][actualColumn] << " ";
             stream << "] ";
-        }
+         }
 
-		stream << "]";
+         stream << "]";
 
-        results.OnTestFailure(details, stream.GetText());
-    }
-}
+         results.OnTestFailure(details, stream.GetText());
+      }
+   }
 
 }