Show
Ignore:
Timestamp:
08/05/09 14:40:03 (15 years ago)
Author:
mido
Message:

panove, vite, jak jsem peclivej na upravu kodu.. snad se vam bude libit:) konfigurace je v souboru /system/astylerc

Location:
library/tests/unittest-cpp
Files:
44 modified

Legend:

Unmodified
Added
Removed

  • library/tests/unittest-cpp/AssertException.cpp

    r418 r477  
    44namespace UnitTest { 
    55 
    6 AssertException::AssertException(char const* description, char const* filename, int lineNumber) 
    7     : m_lineNumber(lineNumber) 
    8 { 
     6AssertException::AssertException ( char const* description, char const* filename, int lineNumber ) 
     7                : m_lineNumber ( lineNumber ) { 
    98        using namespace std; 
    109 
    11     strcpy(m_description, description); 
    12     strcpy(m_filename, filename); 
     10        strcpy ( m_description, description ); 
     11        strcpy ( m_filename, filename ); 
    1312} 
    1413 
    15 AssertException::~AssertException() throw() 
    16 { 
     14AssertException::~AssertException() throw() { 
    1715} 
    1816 
    19 char const* AssertException::what() const throw() 
    20 { 
    21     return m_description; 
     17char const* AssertException::what() const throw() { 
     18        return m_description; 
    2219} 
    2320 
    24 char const* AssertException::Filename() const 
    25 { 
    26     return m_filename; 
     21char const* AssertException::Filename() const { 
     22        return m_filename; 
    2723} 
    2824 
    29 int AssertException::LineNumber() const 
    30 { 
    31     return m_lineNumber; 
     25int AssertException::LineNumber() const { 
     26        return m_lineNumber; 
    3227} 
    3328 

  • library/tests/unittest-cpp/AssertException.h

    r418 r477  
    77namespace UnitTest { 
    88 
    9 class AssertException : public std::exception 
    10 { 
     9class AssertException : public std::exception { 
    1110public: 
    12     AssertException(char const* description, char const* filename, int lineNumber); 
    13     virtual ~AssertException() throw(); 
     11        AssertException ( char const* description, char const* filename, int lineNumber ); 
     12        virtual ~AssertException() throw(); 
    1413 
    15     virtual char const* what() const throw(); 
     14        virtual char const* what() const throw(); 
    1615 
    17     char const* Filename() const; 
    18     int LineNumber() const; 
     16        char const* Filename() const; 
     17        int LineNumber() const; 
    1918 
    2019private: 
    21     char m_description[512]; 
    22     char m_filename[256]; 
    23     int m_lineNumber; 
     20        char m_description[512]; 
     21        char m_filename[256]; 
     22        int m_lineNumber; 
    2423}; 
    2524 

  • library/tests/unittest-cpp/CheckMacros.h

    r418 r477  
    1 #ifndef UNITTEST_CHECKMACROS_H  
     1#ifndef UNITTEST_CHECKMACROS_H 
    22#define UNITTEST_CHECKMACROS_H 
    33 
    … …  
    99 
    1010#ifdef CHECK 
    11     #error UnitTest++ redefines CHECK 
     11#error UnitTest++ redefines CHECK 
    1212#endif 
    1313 
    1414#ifdef CHECK_EQUAL 
    15         #error UnitTest++ redefines CHECK_EQUAL 
     15#error UnitTest++ redefines CHECK_EQUAL 
    1616#endif 
    1717 
    1818#ifdef CHECK_CLOSE 
    19         #error UnitTest++ redefines CHECK_CLOSE 
     19#error UnitTest++ redefines CHECK_CLOSE 
    2020#endif 
    2121 
    2222#ifdef CHECK_ARRAY_EQUAL 
    23         #error UnitTest++ redefines CHECK_ARRAY_EQUAL 
     23#error UnitTest++ redefines CHECK_ARRAY_EQUAL 
    2424#endif 
    2525 
    2626#ifdef CHECK_ARRAY_CLOSE 
    27         #error UnitTest++ redefines CHECK_ARRAY_CLOSE 
     27#error UnitTest++ redefines CHECK_ARRAY_CLOSE 
    2828#endif 
    2929 
    3030#ifdef CHECK_ARRAY2D_CLOSE 
    31         #error UnitTest++ redefines CHECK_ARRAY2D_CLOSE 
     31#error UnitTest++ redefines CHECK_ARRAY2D_CLOSE 
    3232#endif 
    3333 

  • library/tests/unittest-cpp/Checks.cpp

    r418 r477  
    66namespace { 
    77 
    8 void CheckStringsEqual(TestResults& results, char const* expected, char const* actual,  
    9                        TestDetails const& details) 
    10 { 
     8void CheckStringsEqual ( TestResults& results, char const* expected, char const* actual, 
     9                         TestDetails const& details ) { 
    1110        using namespace std; 
    1211 
    13     if (strcmp(expected, actual)) 
    14     { 
    15         UnitTest::MemoryOutStream stream; 
    16         stream << "Expected " << expected << " but was " << actual; 
     12        if ( strcmp ( expected, actual ) ) { 
     13                UnitTest::MemoryOutStream stream; 
     14                stream << "Expected " << expected << " but was " << actual; 
    1715 
    18         results.OnTestFailure(details, stream.GetText()); 
    19     } 
     16                results.OnTestFailure ( details, stream.GetText() ); 
     17        } 
    2018} 
    2119 
    … …  
    2321 
    2422 
    25 void CheckEqual(TestResults& results, char const* expected, char const* actual, 
    26                 TestDetails const& details) 
    27 { 
    28     CheckStringsEqual(results, expected, actual, details); 
     23void CheckEqual ( TestResults& results, char const* expected, char const* actual, 
     24                  TestDetails const& details ) { 
     25        CheckStringsEqual ( results, expected, actual, details ); 
    2926} 
    3027 
    31 void CheckEqual(TestResults& results, char* expected, char* actual, 
    32                 TestDetails const& details) 
    33 { 
    34     CheckStringsEqual(results, expected, actual, details); 
     28void CheckEqual ( TestResults& results, char* expected, char* actual, 
     29                  TestDetails const& details ) { 
     30        CheckStringsEqual ( results, expected, actual, details ); 
    3531} 
    3632 
    37 void CheckEqual(TestResults& results, char* expected, char const* actual, 
    38                 TestDetails const& details) 
    39 { 
    40     CheckStringsEqual(results, expected, actual, details); 
     33void CheckEqual ( TestResults& results, char* expected, char const* actual, 
     34                  TestDetails const& details ) { 
     35        CheckStringsEqual ( results, expected, actual, details ); 
    4136} 
    4237 
    43 void CheckEqual(TestResults& results, char const* expected, char* actual, 
    44                 TestDetails const& details) 
    45 { 
    46     CheckStringsEqual(results, expected, actual, details); 
     38void CheckEqual ( TestResults& results, char const* expected, char* actual, 
     39                  TestDetails const& details ) { 
     40        CheckStringsEqual ( results, expected, actual, details ); 
    4741} 
    4842 

  • library/tests/unittest-cpp/Checks.h

    r418 r477  
    1010 
    1111template< typename Value > 
    12 bool Check(Value const value) 
    13 { 
    14     return !!value; // doing double negative to avoid silly VS warnings 
     12bool Check ( Value const value ) { 
     13        return !!value; // doing double negative to avoid silly VS warnings 
    1514} 
    1615 
    1716 
    1817template< typename Expected, typename Actual > 
    19 void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details) 
    20 { 
    21     if (!(expected == actual)) 
    22     { 
    23         UnitTest::MemoryOutStream stream; 
    24         stream << "Expected " << expected << " but was " << actual; 
     18void CheckEqual ( TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details ) { 
     19        if ( ! ( expected == actual ) ) { 
     20                UnitTest::MemoryOutStream stream; 
     21                stream << "Expected " << expected << " but was " << actual; 
    2522 
    26         results.OnTestFailure(details, stream.GetText()); 
    27     } 
     23                results.OnTestFailure ( details, stream.GetText() ); 
     24        } 
    2825} 
    2926 
    30 void CheckEqual(TestResults& results, char const* expected, char const* actual, TestDetails const& details); 
     27void CheckEqual ( TestResults& results, char const* expected, char const* actual, TestDetails const& details ); 
    3128 
    32 void CheckEqual(TestResults& results, char* expected, char* actual, TestDetails const& details); 
     29void CheckEqual ( TestResults& results, char* expected, char* actual, TestDetails const& details ); 
    3330 
    34 void CheckEqual(TestResults& results, char* expected, char const* actual, TestDetails const& details); 
     31void CheckEqual ( TestResults& results, char* expected, char const* actual, TestDetails const& details ); 
    3532 
    36 void CheckEqual(TestResults& results, char const* expected, char* actual, TestDetails const& details); 
     33void CheckEqual ( TestResults& results, char const* expected, char* actual, TestDetails const& details ); 
    3734 
    3835template< typename Expected, typename Actual, typename Tolerance > 
    39 bool AreClose(Expected const& expected, Actual const& actual, Tolerance const& tolerance) 
    40 { 
    41     return (actual >= (expected - tolerance)) && (actual <= (expected + tolerance)); 
     36bool AreClose ( Expected const& expected, Actual const& actual, Tolerance const& tolerance ) { 
     37        return ( actual >= ( expected - tolerance ) ) && ( actual <= ( expected + tolerance ) ); 
    4238} 
    4339 
    4440template< typename Expected, typename Actual, typename Tolerance > 
    45 void CheckClose(TestResults& results, Expected const& expected, Actual const& actual, Tolerance const& tolerance, 
    46                 TestDetails const& details) 
    47 { 
    48     if (!AreClose(expected, actual, tolerance)) 
    49     {  
    50         UnitTest::MemoryOutStream stream; 
    51         stream << "Expected " << expected << " +/- " << tolerance << " but was " << actual; 
     41void CheckClose ( TestResults& results, Expected const& expected, Actual const& actual, Tolerance const& tolerance, 
     42                  TestDetails const& details ) { 
     43        if ( !AreClose ( expected, actual, tolerance ) ) { 
     44                UnitTest::MemoryOutStream stream; 
     45                stream << "Expected " << expected << " +/- " << tolerance << " but was " << actual; 
    5246 
    53         results.OnTestFailure(details, stream.GetText()); 
    54     } 
     47                results.OnTestFailure ( details, stream.GetText() ); 
     48        } 
    5549} 
    5650 
    5751 
    5852template< typename Expected, typename Actual > 
    59 void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual, 
    60                 int const count, TestDetails const& details) 
    61 { 
    62     bool equal = true; 
    63     for (int i = 0; i < count; ++i) 
    64         equal &= (expected[i] == actual[i]); 
     53void CheckArrayEqual ( TestResults& results, Expected const& expected, Actual const& actual, 
     54                       int const count, TestDetails const& details ) { 
     55        bool equal = true; 
     56        for ( int i = 0; i < count; ++i ) 
     57                equal &= ( expected[i] == actual[i] ); 
    6558 
    66     if (!equal) 
    67     { 
    68         UnitTest::MemoryOutStream stream; 
     59        if ( !equal ) { 
     60                UnitTest::MemoryOutStream stream; 
    6961 
    7062                stream << "Expected [ "; 
    7163 
    72                 for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex) 
    73             stream << expected[expectedIndex] << " "; 
     64                for ( int expectedIndex = 0; expectedIndex < count; ++expectedIndex ) 
     65                        stream << expected[expectedIndex] << " "; 
    7466 
    7567                stream << "] but was [ "; 
    7668 
    77                 for (int actualIndex = 0; actualIndex < count; ++actualIndex) 
    78             stream << actual[actualIndex] << " "; 
     69                for ( int actualIndex = 0; actualIndex < count; ++actualIndex ) 
     70                        stream << actual[actualIndex] << " "; 
    7971 
    8072                stream << "]"; 
    8173 
    82         results.OnTestFailure(details, stream.GetText()); 
    83     } 
     74                results.OnTestFailure ( details, stream.GetText() ); 
     75        } 
    8476} 
    8577 
    8678template< typename Expected, typename Actual, typename Tolerance > 
    87 bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance) 
    88 { 
    89     bool equal = true; 
    90     for (int i = 0; i < count; ++i) 
    91         equal &= AreClose(expected[i], actual[i], tolerance); 
    92     return equal; 
     79bool ArrayAreClose ( Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance ) { 
     80        bool equal = true; 
     81        for ( int i = 0; i < count; ++i ) 
     82                equal &= AreClose ( expected[i], actual[i], tolerance ); 
     83        return equal; 
    9384} 
    9485 
    9586template< typename Expected, typename Actual, typename Tolerance > 
    96 void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual, 
    97                    int const count, Tolerance const& tolerance, TestDetails const& details) 
    98 { 
    99     bool equal = ArrayAreClose(expected, actual, count, tolerance); 
     87void CheckArrayClose ( TestResults& results, Expected const& expected, Actual const& actual, 
     88                       int const count, Tolerance const& tolerance, TestDetails const& details ) { 
     89        bool equal = ArrayAreClose ( expected, actual, count, tolerance ); 
    10090 
    101     if (!equal) 
    102     { 
    103         UnitTest::MemoryOutStream stream; 
     91        if ( !equal ) { 
     92                UnitTest::MemoryOutStream stream; 
    10493 
    105         stream << "Expected [ "; 
    106         for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex) 
    107             stream << expected[expectedIndex] << " "; 
    108         stream << "] +/- " << tolerance << " but was [ "; 
     94                stream << "Expected [ "; 
     95                for ( int expectedIndex = 0; expectedIndex < count; ++expectedIndex ) 
     96                        stream << expected[expectedIndex] << " "; 
     97                stream << "] +/- " << tolerance << " but was [ "; 
    10998 
    110                 for (int actualIndex = 0; actualIndex < count; ++actualIndex) 
    111             stream << actual[actualIndex] << " "; 
    112         stream << "]"; 
     99                for ( int actualIndex = 0; actualIndex < count; ++actualIndex ) 
     100                        stream << actual[actualIndex] << " "; 
     101                stream << "]"; 
    113102 
    114         results.OnTestFailure(details, stream.GetText()); 
    115     } 
     103                results.OnTestFailure ( details, stream.GetText() ); 
     104        } 
    116105} 
    117106 
    118107template< typename Expected, typename Actual, typename Tolerance > 
    119 void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual, 
    120                    int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details) 
    121 { 
    122     bool equal = true; 
    123     for (int i = 0; i < rows; ++i) 
    124         equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance); 
     108void CheckArray2DClose ( TestResults& results, Expected const& expected, Actual const& actual, 
     109                         int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details ) { 
     110        bool equal = true; 
     111        for ( int i = 0; i < rows; ++i ) 
     112                equal &= ArrayAreClose ( expected[i], actual[i], columns, tolerance ); 
    125113 
    126     if (!equal) 
    127     { 
    128         UnitTest::MemoryOutStream stream; 
     114        if ( !equal ) { 
     115                UnitTest::MemoryOutStream stream; 
    129116 
    130         stream << "Expected [ ";     
     117                stream << "Expected [ "; 
    131118 
    132                 for (int expectedRow = 0; expectedRow < rows; ++expectedRow) 
    133         { 
    134             stream << "[ "; 
    135             for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn) 
    136                 stream << expected[expectedRow][expectedColumn] << " "; 
    137             stream << "] "; 
    138         } 
     119                for ( int expectedRow = 0; expectedRow < rows; ++expectedRow ) { 
     120                        stream << "[ "; 
     121                        for ( int expectedColumn = 0; expectedColumn < columns; ++expectedColumn ) 
     122                                stream << expected[expectedRow][expectedColumn] << " "; 
     123                        stream << "] "; 
     124                } 
    139125 
    140126                stream << "] +/- " << tolerance << " but was [ "; 
    141127 
    142                 for (int actualRow = 0; actualRow < rows; ++actualRow) 
    143         { 
    144             stream << "[ "; 
    145             for (int actualColumn = 0; actualColumn < columns; ++actualColumn) 
    146                 stream << actual[actualRow][actualColumn] << " "; 
    147             stream << "] "; 
    148         } 
     128                for ( int actualRow = 0; actualRow < rows; ++actualRow ) { 
     129                        stream << "[ "; 
     130                        for ( int actualColumn = 0; actualColumn < columns; ++actualColumn ) 
     131                                stream << actual[actualRow][actualColumn] << " "; 
     132                        stream << "] "; 
     133                } 
    149134 
    150135                stream << "]"; 
    151136 
    152         results.OnTestFailure(details, stream.GetText()); 
    153     } 
     137                results.OnTestFailure ( details, stream.GetText() ); 
     138        } 
    154139} 
    155140 

  • library/tests/unittest-cpp/Config.h

    r418 r477  
    55 
    66#if defined(_MSC_VER) 
    7     #pragma warning(disable:4127) // conditional expression is constant 
    8         #pragma warning(disable:4702) // unreachable code 
    9         #pragma warning(disable:4722) // destructor never returns, potential memory leak 
     7#pragma warning(disable:4127) // conditional expression is constant 
     8#pragma warning(disable:4702) // unreachable code 
     9#pragma warning(disable:4722) // destructor never returns, potential memory leak 
    1010 
    11         #if (_MSC_VER == 1200)  // VC6 
    12                 #pragma warning(disable:4786) 
    13                 #pragma warning(disable:4290) 
    14         #endif 
     11#if (_MSC_VER == 1200)  // VC6 
     12#pragma warning(disable:4786) 
     13#pragma warning(disable:4290) 
     14#endif 
    1515#endif 
    1616 
    1717#if defined(unix) || defined(__unix__) || defined(__unix) || defined(linux) || \ 
    18     defined(__APPLE__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)         
    19     #define UNITTEST_POSIX 
     18    defined(__APPLE__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) 
     19#define UNITTEST_POSIX 
    2020#endif 
    2121 
    2222#if defined(__MINGW32__) 
    23     #define UNITTEST_MINGW 
     23#define UNITTEST_MINGW 
    2424#endif 
    2525 

  • library/tests/unittest-cpp/CurrentTest.cpp

    r418 r477  
    44namespace UnitTest { 
    55 
    6 TestResults*& CurrentTest::Results() 
    7 { 
     6TestResults*& CurrentTest::Results() { 
    87        static TestResults* testResults = NULL; 
    98        return testResults; 
    109} 
    1110 
    12 const TestDetails*& CurrentTest::Details() 
    13 { 
     11const TestDetails*& CurrentTest::Details() { 
    1412        static const TestDetails* testDetails = NULL; 
    1513        return testDetails; 

  • library/tests/unittest-cpp/CurrentTest.h

    r418 r477  
    77class TestDetails; 
    88 
    9 namespace CurrentTest 
    10 { 
    11         TestResults*& Results(); 
    12         const TestDetails*& Details(); 
     9namespace CurrentTest { 
     10TestResults*& Results(); 
     11const TestDetails*& Details(); 
    1312} 
    1413 

  • library/tests/unittest-cpp/DeferredTestReporter.cpp

    r418 r477  
    44using namespace UnitTest; 
    55 
    6 void DeferredTestReporter::ReportTestStart(TestDetails const& details) 
    7 { 
    8     m_results.push_back(DeferredTestResult(details.suiteName, details.testName)); 
     6void DeferredTestReporter::ReportTestStart ( TestDetails const& details ) { 
     7        m_results.push_back ( DeferredTestResult ( details.suiteName, details.testName ) ); 
    98} 
    109 
    11 void DeferredTestReporter::ReportFailure(TestDetails const& details, char const* failure) 
    12 { 
    13     DeferredTestResult& r = m_results.back(); 
    14     r.failed = true; 
    15     r.failures.push_back(DeferredTestResult::Failure(details.lineNumber, failure)); 
    16     r.failureFile = details.filename; 
     10void DeferredTestReporter::ReportFailure ( TestDetails const& details, char const* failure ) { 
     11        DeferredTestResult& r = m_results.back(); 
     12        r.failed = true; 
     13        r.failures.push_back ( DeferredTestResult::Failure ( details.lineNumber, failure ) ); 
     14        r.failureFile = details.filename; 
    1715} 
    1816 
    19 void DeferredTestReporter::ReportTestFinish(TestDetails const&, float secondsElapsed) 
    20 { 
    21     DeferredTestResult& r = m_results.back(); 
    22     r.timeElapsed = secondsElapsed; 
     17void DeferredTestReporter::ReportTestFinish ( TestDetails const&, float secondsElapsed ) { 
     18        DeferredTestResult& r = m_results.back(); 
     19        r.timeElapsed = secondsElapsed; 
    2320} 
    2421 
    25 DeferredTestReporter::DeferredTestResultList& DeferredTestReporter::GetResults() 
    26 { 
    27     return m_results; 
     22DeferredTestReporter::DeferredTestResultList& DeferredTestReporter::GetResults() { 
     23        return m_results; 
    2824} 

  • library/tests/unittest-cpp/DeferredTestReporter.h

    r418 r477  
    88#include <vector> 
    99 
    10 namespace UnitTest 
    11 { 
     10namespace UnitTest { 
    1211 
    13 class DeferredTestReporter : public TestReporter 
    14 { 
     12class DeferredTestReporter : public TestReporter { 
    1513public: 
    16     virtual void ReportTestStart(TestDetails const& details); 
    17     virtual void ReportFailure(TestDetails const& details, char const* failure); 
    18     virtual void ReportTestFinish(TestDetails const& details, float secondsElapsed); 
     14        virtual void ReportTestStart ( TestDetails const& details ); 
     15        virtual void ReportFailure ( TestDetails const& details, char const* failure ); 
     16        virtual void ReportTestFinish ( TestDetails const& details, float secondsElapsed ); 
    1917 
    20     typedef std::vector< DeferredTestResult > DeferredTestResultList; 
    21     DeferredTestResultList& GetResults(); 
     18        typedef std::vector< DeferredTestResult > DeferredTestResultList; 
     19        DeferredTestResultList& GetResults(); 
    2220 
    2321private: 
    24     DeferredTestResultList m_results; 
     22        DeferredTestResultList m_results; 
    2523}; 
    2624 

  • library/tests/unittest-cpp/DeferredTestResult.cpp

    r418 r477  
    22#include "Config.h" 
    33 
    4 namespace UnitTest 
    5 { 
     4namespace UnitTest { 
    65 
    76DeferredTestResult::DeferredTestResult() 
    8         : suiteName("") 
    9         , testName("") 
    10         , failureFile("") 
    11         , timeElapsed(0.0f) 
    12         , failed(false) 
    13 { 
     7                : suiteName ( "" ) 
     8                , testName ( "" ) 
     9                , failureFile ( "" ) 
     10                , timeElapsed ( 0.0f ) 
     11                , failed ( false ) { 
    1412} 
    1513 
    16 DeferredTestResult::DeferredTestResult(char const* suite, char const* test) 
    17         : suiteName(suite) 
    18         , testName(test) 
    19         , failureFile("") 
    20         , timeElapsed(0.0f) 
    21         , failed(false) 
    22 { 
     14DeferredTestResult::DeferredTestResult ( char const* suite, char const* test ) 
     15                : suiteName ( suite ) 
     16                , testName ( test ) 
     17                , failureFile ( "" ) 
     18                , timeElapsed ( 0.0f ) 
     19                , failed ( false ) { 
    2320} 
    2421 
    25 DeferredTestResult::~DeferredTestResult() 
    26 { 
     22DeferredTestResult::~DeferredTestResult() { 
    2723} 
    2824 

  • library/tests/unittest-cpp/DeferredTestResult.h

    r418 r477  
    77#include <vector> 
    88 
    9 namespace UnitTest 
    10 { 
     9namespace UnitTest { 
    1110 
    12 struct DeferredTestResult 
    13 { 
     11struct DeferredTestResult { 
    1412        DeferredTestResult(); 
    15     DeferredTestResult(char const* suite, char const* test); 
    16     ~DeferredTestResult(); 
    17      
    18     std::string suiteName; 
    19     std::string testName; 
    20     std::string failureFile; 
    21      
    22     typedef std::pair< int, std::string > Failure; 
    23     typedef std::vector< Failure > FailureVec; 
    24     FailureVec failures; 
    25      
    26     float timeElapsed; 
     13        DeferredTestResult ( char const* suite, char const* test ); 
     14        ~DeferredTestResult(); 
     15 
     16        std::string suiteName; 
     17        std::string testName; 
     18        std::string failureFile; 
     19 
     20        typedef std::pair< int, std::string > Failure; 
     21        typedef std::vector< Failure > FailureVec; 
     22        FailureVec failures; 
     23 
     24        float timeElapsed; 
    2725        bool failed; 
    2826}; 

  • library/tests/unittest-cpp/ExecuteTest.h

    r418 r477  
    88 
    99#ifdef UNITTEST_POSIX 
    10         #include "Posix/SignalTranslator.h" 
     10#include "Posix/SignalTranslator.h" 
    1111#endif 
    1212 
    … …  
    1414 
    1515template< typename T > 
    16 void ExecuteTest(T& testObject, TestDetails const& details) 
    17 { 
     16void ExecuteTest ( T& testObject, TestDetails const& details ) { 
    1817        CurrentTest::Details() = &details; 
    1918 
    20         try 
    21         { 
     19        try { 
    2220#ifdef UNITTEST_POSIX 
    2321                UNITTEST_THROW_SIGNALS 
    2422#endif 
    2523                testObject.RunImpl(); 
    26         } 
    27         catch (AssertException const& e) 
    28         { 
    29                 CurrentTest::Results()->OnTestFailure( 
    30                         TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what()); 
    31         } 
    32         catch (std::exception const& e) 
    33         { 
     24        } catch ( AssertException const& e ) { 
     25                CurrentTest::Results()->OnTestFailure ( 
     26                    TestDetails ( details.testName, details.suiteName, e.Filename(), e.LineNumber() ), e.what() ); 
     27        } catch ( std::exception const& e ) { 
    3428                MemoryOutStream stream; 
    3529                stream << "Unhandled exception: " << e.what(); 
    36                 CurrentTest::Results()->OnTestFailure(details, stream.GetText()); 
    37         } 
    38         catch (...) 
    39         { 
    40                 CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!"); 
     30                CurrentTest::Results()->OnTestFailure ( details, stream.GetText() ); 
     31        } catch ( ... ) { 
     32                CurrentTest::Results()->OnTestFailure ( details, "Unhandled exception: Crash!" ); 
    4133        } 
    4234} 

  • library/tests/unittest-cpp/MemoryOutStream.cpp

    r418 r477  
    66namespace UnitTest { 
    77 
    8 char const* MemoryOutStream::GetText() const 
    9 { 
    10     m_text = this->str(); 
    11     return m_text.c_str(); 
     8char const* MemoryOutStream::GetText() const { 
     9        m_text = this->str(); 
     10        return m_text.c_str(); 
    1211} 
    1312 
    … …  
    2726 
    2827template<typename ValueType> 
    29 void FormatToStream(MemoryOutStream& stream, char const* format, ValueType const& value) 
    30 { 
     28void FormatToStream ( MemoryOutStream& stream, char const* format, ValueType const& value ) { 
    3129        using namespace std; 
    3230 
    33     char txt[32]; 
    34     sprintf(txt, format, value); 
    35     stream << txt; 
     31        char txt[32]; 
     32        sprintf ( txt, format, value ); 
     33        stream << txt; 
    3634} 
    3735 
    38 int RoundUpToMultipleOfPow2Number (int n, int pow2Number) 
    39 { 
    40     return (n + (pow2Number - 1)) & ~(pow2Number - 1); 
     36int RoundUpToMultipleOfPow2Number ( int n, int pow2Number ) { 
     37        return ( n + ( pow2Number - 1 ) ) & ~ ( pow2Number - 1 ); 
    4138} 
    4239 
    … …  
    4441 
    4542 
    46 MemoryOutStream::MemoryOutStream(int const size) 
    47     : m_capacity (0) 
    48     , m_buffer (0) 
     43MemoryOutStream::MemoryOutStream ( int const size ) 
     44                : m_capacity ( 0 ) 
     45                , m_buffer ( 0 ) 
    4946 
    5047{ 
    51     GrowBuffer(size); 
     48        GrowBuffer ( size ); 
    5249} 
    5350 
    54 MemoryOutStream::~MemoryOutStream() 
    55 { 
    56     delete [] m_buffer; 
     51MemoryOutStream::~MemoryOutStream() { 
     52        delete [] m_buffer; 
    5753} 
    5854 
    59 char const* MemoryOutStream::GetText() const 
    60 { 
    61     return m_buffer; 
     55char const* MemoryOutStream::GetText() const { 
     56        return m_buffer; 
    6257} 
    6358 
    64 MemoryOutStream& MemoryOutStream::operator << (char const* txt) 
    65 { 
     59MemoryOutStream& MemoryOutStream::operator << ( char const* txt ) { 
    6660        using namespace std; 
    6761 
    68     int const bytesLeft = m_capacity - (int)strlen(m_buffer); 
    69     int const bytesRequired = (int)strlen(txt) + 1; 
     62        int const bytesLeft = m_capacity - ( int ) strlen ( m_buffer ); 
     63        int const bytesRequired = ( int ) strlen ( txt ) + 1; 
    7064 
    71     if (bytesRequired > bytesLeft) 
    72     { 
    73         int const requiredCapacity = bytesRequired + m_capacity - bytesLeft; 
    74         GrowBuffer(requiredCapacity); 
    75     } 
     65        if ( bytesRequired > bytesLeft ) { 
     66                int const requiredCapacity = bytesRequired + m_capacity - bytesLeft; 
     67                GrowBuffer ( requiredCapacity ); 
     68        } 
    7669 
    77     strcat(m_buffer, txt); 
    78     return *this; 
    79 } 
    80  
    81 MemoryOutStream& MemoryOutStream::operator << (int const n) 
    82 { 
    83     FormatToStream(*this, "%i", n); 
    84     return *this; 
    85 } 
    86  
    87 MemoryOutStream& MemoryOutStream::operator << (long const n) 
    88 { 
    89     FormatToStream(*this, "%li", n); 
    90     return *this; 
    91 } 
    92  
    93 MemoryOutStream& MemoryOutStream::operator << (unsigned long const n) 
    94 { 
    95     FormatToStream(*this, "%lu", n); 
    96     return *this; 
    97 } 
    98  
    99 MemoryOutStream& MemoryOutStream::operator << (float const f) 
    100 { 
    101     FormatToStream(*this, "%ff", f); 
    102     return *this;     
    103 } 
    104  
    105 MemoryOutStream& MemoryOutStream::operator << (void const* p) 
    106 { 
    107     FormatToStream(*this, "%p", p); 
    108     return *this;     
    109 } 
    110  
    111 MemoryOutStream& MemoryOutStream::operator << (unsigned int const s) 
    112 { 
    113     FormatToStream(*this, "%u", s); 
    114     return *this;     
    115 } 
    116  
    117 MemoryOutStream& MemoryOutStream::operator <<(double const d) 
    118 { 
    119         FormatToStream(*this, "%f", d); 
     70        strcat ( m_buffer, txt ); 
    12071        return *this; 
    12172} 
    12273 
    123 int MemoryOutStream::GetCapacity() const 
    124 { 
    125     return m_capacity; 
     74MemoryOutStream& MemoryOutStream::operator << ( int const n ) { 
     75        FormatToStream ( *this, "%i", n ); 
     76        return *this; 
     77} 
     78 
     79MemoryOutStream& MemoryOutStream::operator << ( long const n ) { 
     80        FormatToStream ( *this, "%li", n ); 
     81        return *this; 
     82} 
     83 
     84MemoryOutStream& MemoryOutStream::operator << ( unsigned long const n ) { 
     85        FormatToStream ( *this, "%lu", n ); 
     86        return *this; 
     87} 
     88 
     89MemoryOutStream& MemoryOutStream::operator << ( float const f ) { 
     90        FormatToStream ( *this, "%ff", f ); 
     91        return *this; 
     92} 
     93 
     94MemoryOutStream& MemoryOutStream::operator << ( void const* p ) { 
     95        FormatToStream ( *this, "%p", p ); 
     96        return *this; 
     97} 
     98 
     99MemoryOutStream& MemoryOutStream::operator << ( unsigned int const s ) { 
     100        FormatToStream ( *this, "%u", s ); 
     101        return *this; 
     102} 
     103 
     104MemoryOutStream& MemoryOutStream::operator << ( double const d ) { 
     105        FormatToStream ( *this, "%f", d ); 
     106        return *this; 
     107} 
     108 
     109int MemoryOutStream::GetCapacity() const { 
     110        return m_capacity; 
    126111} 
    127112 
    128113 
    129 void MemoryOutStream::GrowBuffer(int const desiredCapacity) 
    130 { 
    131     int const newCapacity = RoundUpToMultipleOfPow2Number(desiredCapacity, GROW_CHUNK_SIZE); 
     114void MemoryOutStream::GrowBuffer ( int const desiredCapacity ) { 
     115        int const newCapacity = RoundUpToMultipleOfPow2Number ( desiredCapacity, GROW_CHUNK_SIZE ); 
    132116 
    133117        using namespace std; 
    134118 
    135     char* buffer = new char[newCapacity]; 
    136     if (m_buffer) 
    137         strcpy(buffer, m_buffer); 
    138     else 
    139         strcpy(buffer, ""); 
     119        char* buffer = new char[newCapacity]; 
     120        if ( m_buffer ) 
     121                strcpy ( buffer, m_buffer ); 
     122        else 
     123                strcpy ( buffer, "" ); 
    140124 
    141     delete [] m_buffer; 
    142     m_buffer = buffer; 
    143     m_capacity = newCapacity; 
     125        delete [] m_buffer; 
     126        m_buffer = buffer; 
     127        m_capacity = newCapacity; 
    144128} 
    145129 

  • library/tests/unittest-cpp/MemoryOutStream.h

    r418 r477  
    88#include <sstream> 
    99 
    10 namespace UnitTest 
    11 { 
     10namespace UnitTest { 
    1211 
    13 class MemoryOutStream : public std::ostringstream 
    14 { 
     12class MemoryOutStream : public std::ostringstream { 
    1513public: 
    16     MemoryOutStream() {} 
    17     ~MemoryOutStream() {} 
    18     char const* GetText() const; 
     14        MemoryOutStream() {} 
     15        ~MemoryOutStream() {} 
     16        char const* GetText() const; 
    1917 
    2018private: 
    21     MemoryOutStream(MemoryOutStream const&); 
    22     void operator =(MemoryOutStream const&); 
     19        MemoryOutStream ( MemoryOutStream const& ); 
     20        void operator = ( MemoryOutStream const& ); 
    2321 
    24     mutable std::string m_text; 
     22        mutable std::string m_text; 
    2523}; 
    2624 
    … …  
    3129#include <cstddef> 
    3230 
    33 namespace UnitTest 
    34 { 
     31namespace UnitTest { 
    3532 
    36 class MemoryOutStream 
    37 { 
     33class MemoryOutStream { 
    3834public: 
    39     explicit MemoryOutStream(int const size = 256); 
    40     ~MemoryOutStream(); 
     35        explicit MemoryOutStream ( int const size = 256 ); 
     36        ~MemoryOutStream(); 
    4137 
    42     char const* GetText() const; 
     38        char const* GetText() const; 
    4339 
    44     MemoryOutStream& operator << (char const* txt); 
    45     MemoryOutStream& operator << (int n); 
    46     MemoryOutStream& operator << (long n); 
    47     MemoryOutStream& operator << (unsigned long n); 
    48     MemoryOutStream& operator << (float f); 
    49     MemoryOutStream& operator << (double d); 
    50     MemoryOutStream& operator << (void const* p); 
    51     MemoryOutStream& operator << (unsigned int s); 
     40        MemoryOutStream& operator << ( char const* txt ); 
     41        MemoryOutStream& operator << ( int n ); 
     42        MemoryOutStream& operator << ( long n ); 
     43        MemoryOutStream& operator << ( unsigned long n ); 
     44        MemoryOutStream& operator << ( float f ); 
     45        MemoryOutStream& operator << ( double d ); 
     46        MemoryOutStream& operator << ( void const* p ); 
     47        MemoryOutStream& operator << ( unsigned int s ); 
    5248 
    53     enum { GROW_CHUNK_SIZE = 32 }; 
    54     int GetCapacity() const; 
     49        enum { GROW_CHUNK_SIZE = 32 }; 
     50        int GetCapacity() const; 
    5551 
    5652private: 
    57     void operator= (MemoryOutStream const&); 
    58     void GrowBuffer(int capacity); 
     53        void operator= ( MemoryOutStream const& ); 
     54        void GrowBuffer ( int capacity ); 
    5955 
    60     int m_capacity; 
    61     char* m_buffer; 
     56        int m_capacity; 
     57        char* m_buffer; 
    6258}; 
    6359 

  • library/tests/unittest-cpp/Posix/SignalTranslator.cpp

    r418 r477  
    77namespace { 
    88 
    9 void SignalHandler(int sig) 
    10 { 
    11     siglongjmp(*SignalTranslator::s_jumpTarget, sig ); 
     9void SignalHandler ( int sig ) { 
     10        siglongjmp ( *SignalTranslator::s_jumpTarget, sig ); 
    1211} 
    1312 
    … …  
    1514 
    1615 
    17 SignalTranslator::SignalTranslator() 
    18 { 
    19     m_oldJumpTarget = s_jumpTarget; 
    20     s_jumpTarget = &m_currentJumpTarget; 
     16SignalTranslator::SignalTranslator() { 
     17        m_oldJumpTarget = s_jumpTarget; 
     18        s_jumpTarget = &m_currentJumpTarget; 
    2119 
    22     struct sigaction action; 
    23     action.sa_flags = 0; 
    24     action.sa_handler = SignalHandler; 
    25     sigemptyset( &action.sa_mask ); 
     20        struct sigaction action; 
     21        action.sa_flags = 0; 
     22        action.sa_handler = SignalHandler; 
     23        sigemptyset ( &action.sa_mask ); 
    2624 
    27     sigaction( SIGSEGV, &action, &m_old_SIGSEGV_action ); 
    28     sigaction( SIGFPE , &action, &m_old_SIGFPE_action ); 
    29     sigaction( SIGTRAP, &action, &m_old_SIGTRAP_action ); 
    30     sigaction( SIGBUS , &action, &m_old_SIGBUS_action ); 
    31     sigaction( SIGILL , &action, &m_old_SIGBUS_action ); 
     25        sigaction ( SIGSEGV, &action, &m_old_SIGSEGV_action ); 
     26        sigaction ( SIGFPE , &action, &m_old_SIGFPE_action ); 
     27        sigaction ( SIGTRAP, &action, &m_old_SIGTRAP_action ); 
     28        sigaction ( SIGBUS , &action, &m_old_SIGBUS_action ); 
     29        sigaction ( SIGILL , &action, &m_old_SIGBUS_action ); 
    3230} 
    3331 
    34 SignalTranslator::~SignalTranslator() 
    35 { 
    36     sigaction( SIGILL , &m_old_SIGBUS_action , 0 ); 
    37     sigaction( SIGBUS , &m_old_SIGBUS_action , 0 ); 
    38     sigaction( SIGTRAP, &m_old_SIGTRAP_action, 0 ); 
    39     sigaction( SIGFPE , &m_old_SIGFPE_action , 0 ); 
    40     sigaction( SIGSEGV, &m_old_SIGSEGV_action, 0 ); 
     32SignalTranslator::~SignalTranslator() { 
     33        sigaction ( SIGILL , &m_old_SIGBUS_action , 0 ); 
     34        sigaction ( SIGBUS , &m_old_SIGBUS_action , 0 ); 
     35        sigaction ( SIGTRAP, &m_old_SIGTRAP_action, 0 ); 
     36        sigaction ( SIGFPE , &m_old_SIGFPE_action , 0 ); 
     37        sigaction ( SIGSEGV, &m_old_SIGSEGV_action, 0 ); 
    4138 
    42     s_jumpTarget = m_oldJumpTarget; 
     39        s_jumpTarget = m_oldJumpTarget; 
    4340} 
    4441 

  • library/tests/unittest-cpp/Posix/SignalTranslator.h

    r418 r477  
    77namespace UnitTest { 
    88 
    9 class SignalTranslator 
    10 { 
     9class SignalTranslator { 
    1110public: 
    12     SignalTranslator(); 
    13     ~SignalTranslator(); 
     11        SignalTranslator(); 
     12        ~SignalTranslator(); 
    1413 
    15     static sigjmp_buf* s_jumpTarget; 
     14        static sigjmp_buf* s_jumpTarget; 
    1615 
    1716private: 
    18     sigjmp_buf m_currentJumpTarget; 
    19     sigjmp_buf* m_oldJumpTarget; 
     17        sigjmp_buf m_currentJumpTarget; 
     18        sigjmp_buf* m_oldJumpTarget; 
    2019 
    21     struct sigaction m_old_SIGFPE_action; 
    22     struct sigaction m_old_SIGTRAP_action; 
    23     struct sigaction m_old_SIGSEGV_action; 
    24     struct sigaction m_old_SIGBUS_action; 
    25     struct sigaction m_old_SIGABRT_action; 
    26     struct sigaction m_old_SIGALRM_action; 
     20        struct sigaction m_old_SIGFPE_action; 
     21        struct sigaction m_old_SIGTRAP_action; 
     22        struct sigaction m_old_SIGSEGV_action; 
     23        struct sigaction m_old_SIGBUS_action; 
     24        struct sigaction m_old_SIGABRT_action; 
     25        struct sigaction m_old_SIGALRM_action; 
    2726}; 
    2827 
    2928#if !defined (__GNUC__) 
    30     #define UNITTEST_EXTENSION 
     29#define UNITTEST_EXTENSION 
    3130#else 
    32     #define UNITTEST_EXTENSION __extension__ 
     31#define UNITTEST_EXTENSION __extension__ 
    3332#endif 
    3433 
    … …  
    3635        UnitTest::SignalTranslator sig; \ 
    3736        if (UNITTEST_EXTENSION sigsetjmp(*UnitTest::SignalTranslator::s_jumpTarget, 1) != 0) \ 
    38         throw ("Unhandled system exception");  
     37        throw ("Unhandled system exception"); 
    3938 
    4039} 

  • library/tests/unittest-cpp/Posix/TimeHelpers.cpp

    r418 r477  
    44namespace UnitTest { 
    55 
    6 Timer::Timer() 
    7 { 
    8     m_startTime.tv_sec = 0; 
    9     m_startTime.tv_usec = 0; 
     6Timer::Timer() { 
     7        m_startTime.tv_sec = 0; 
     8        m_startTime.tv_usec = 0; 
    109} 
    1110 
    12 void Timer::Start() 
    13 { 
    14     gettimeofday(&m_startTime, 0); 
     11void Timer::Start() { 
     12        gettimeofday ( &m_startTime, 0 ); 
    1513} 
    1614 
    17 double Timer::GetTimeInMs() const 
    18 { 
    19     struct timeval currentTime; 
    20     gettimeofday(&currentTime, 0); 
     15double Timer::GetTimeInMs() const { 
     16        struct timeval currentTime; 
     17        gettimeofday ( &currentTime, 0 ); 
    2118 
    2219        double const dsecs = currentTime.tv_sec - m_startTime.tv_sec; 
    23     double const dus = currentTime.tv_usec - m_startTime.tv_usec; 
     20        double const dus = currentTime.tv_usec - m_startTime.tv_usec; 
    2421 
    25         return (dsecs * 1000.0) + (dus / 1000.0); 
     22        return ( dsecs * 1000.0 ) + ( dus / 1000.0 ); 
    2623} 
    2724 
    28 void TimeHelpers::SleepMs(int ms) 
    29 { 
    30     usleep(ms * 1000); 
     25void TimeHelpers::SleepMs ( int ms ) { 
     26        usleep ( ms * 1000 ); 
    3127} 
    3228 

  • library/tests/unittest-cpp/Posix/TimeHelpers.h

    r418 r477  
    66namespace UnitTest { 
    77 
    8 class Timer 
    9 { 
     8class Timer { 
    109public: 
    11     Timer(); 
    12     void Start(); 
    13     double GetTimeInMs() const;     
     10        Timer(); 
     11        void Start(); 
     12        double GetTimeInMs() const; 
    1413 
    1514private: 
    16     struct timeval m_startTime;     
     15        struct timeval m_startTime; 
    1716}; 
    1817 
    1918 
    20 namespace TimeHelpers 
    21 { 
    22 void SleepMs (int ms); 
     19namespace TimeHelpers { 
     20void SleepMs ( int ms ); 
    2321} 
    2422 

  • library/tests/unittest-cpp/ReportAssert.cpp

    r418 r477  
    44namespace UnitTest { 
    55 
    6 void ReportAssert(char const* description, char const* filename, int lineNumber) 
    7 { 
    8     throw AssertException(description, filename, lineNumber); 
     6void ReportAssert ( char const* description, char const* filename, int lineNumber ) { 
     7        throw AssertException ( description, filename, lineNumber ); 
    98} 
    109 

  • library/tests/unittest-cpp/ReportAssert.h

    r418 r477  
    44namespace UnitTest { 
    55 
    6 void ReportAssert(char const* description, char const* filename, int lineNumber); 
    7      
     6void ReportAssert ( char const* description, char const* filename, int lineNumber ); 
     7 
    88} 
    99 

  • library/tests/unittest-cpp/Test.cpp

    r435 r477  
    99 
    1010#ifdef UNITTEST_POSIX 
    11     #include "Posix/SignalTranslator.h" 
     11#include "Posix/SignalTranslator.h" 
    1212#endif 
    1313 
    1414namespace UnitTest { 
    1515 
    16 TestList& Test::GetTestList() 
    17 { 
    18     static TestList s_list; 
    19     return s_list; 
     16TestList& Test::GetTestList() { 
     17        static TestList s_list; 
     18        return s_list; 
    2019} 
    2120 
    22 Test::Test(char const* testName, char const* suiteName, char const* filename, int lineNumber) 
    23     : m_details(testName, suiteName, filename, lineNumber) 
    24     , next(0) 
    25     , m_timeConstraintExempt(false) 
    26 { 
     21Test::Test ( char const* testName, char const* suiteName, char const* filename, int lineNumber ) 
     22                : m_details ( testName, suiteName, filename, lineNumber ) 
     23                , next ( 0 ) 
     24                , m_timeConstraintExempt ( false ) { 
    2725} 
    2826 
    29 Test::~Test() 
    30 { 
     27Test::~Test() { 
    3128} 
    3229 
    33 void Test::Run() 
    34 { 
     30void Test::Run() { 
    3531        // made more chatty; presumes the only used test reporter is 
    3632        // TestReporterStdout 
    37         std::printf("running %s...\n", m_details.testName); 
     33        std::printf ( "running %s...\n", m_details.testName ); 
    3834 
    39         ExecuteTest(*this, m_details); 
     35        ExecuteTest ( *this, m_details ); 
    4036} 
    4137 
    42 void Test::RunImpl() const 
    43 { 
     38void Test::RunImpl() const { 
    4439} 
    4540 

  • library/tests/unittest-cpp/Test.h

    r418 r477  
    99class TestList; 
    1010 
    11 class Test 
    12 { 
     11class Test { 
    1312public: 
    14     explicit Test(char const* testName, char const* suiteName = "DefaultSuite", char const* filename = "", int lineNumber = 0); 
    15     virtual ~Test(); 
    16     void Run(); 
     13        explicit Test ( char const* testName, char const* suiteName = "DefaultSuite", char const* filename = "", int lineNumber = 0 ); 
     14        virtual ~Test(); 
     15        void Run(); 
    1716 
    18     TestDetails const m_details; 
    19     Test* next; 
    20     mutable bool m_timeConstraintExempt; 
     17        TestDetails const m_details; 
     18        Test* next; 
     19        mutable bool m_timeConstraintExempt; 
    2120 
    22     static TestList& GetTestList(); 
     21        static TestList& GetTestList(); 
    2322 
    24     virtual void RunImpl() const; 
     23        virtual void RunImpl() const; 
    2524 
    2625private: 
    27         Test(Test const&); 
    28     Test& operator =(Test const&); 
     26        Test ( Test const& ); 
     27        Test& operator = ( Test const& ); 
    2928}; 
    3029 

  • library/tests/unittest-cpp/TestDetails.cpp

    r456 r477  
    33namespace UnitTest { 
    44 
    5 TestDetails::TestDetails(char const* testName_, char const* suiteName_, char const* filename_, int lineNumber_, bool useFilename_) 
    6     : suiteName(suiteName_) 
    7     , testName(testName_) 
    8     , filename(filename_) 
    9     , lineNumber(lineNumber_) 
    10     , useFilename(useFilename_) 
    11 { 
     5TestDetails::TestDetails ( char const* testName_, char const* suiteName_, char const* filename_, int lineNumber_, bool useFilename_ ) 
     6                : suiteName ( suiteName_ ) 
     7                , testName ( testName_ ) 
     8                , filename ( filename_ ) 
     9                , lineNumber ( lineNumber_ ) 
     10                , useFilename ( useFilename_ ) { 
    1211} 
    1312 
    14 TestDetails::TestDetails(const TestDetails& details, int lineNumber_, bool useFilename_) 
    15     : suiteName(details.suiteName) 
    16     , testName(details.testName) 
    17     , filename(details.filename) 
    18     , lineNumber(lineNumber_) 
    19     , useFilename(useFilename_) 
    20 { 
     13TestDetails::TestDetails ( const TestDetails& details, int lineNumber_, bool useFilename_ ) 
     14                : suiteName ( details.suiteName ) 
     15                , testName ( details.testName ) 
     16                , filename ( details.filename ) 
     17                , lineNumber ( lineNumber_ ) 
     18                , useFilename ( useFilename_ ) { 
    2119} 
    2220 

  • library/tests/unittest-cpp/TestDetails.h

    r456 r477  
    44namespace UnitTest { 
    55 
    6 class TestDetails 
    7 { 
     6class TestDetails { 
    87public: 
    9     TestDetails(char const* testName, char const* suiteName, char const* filename, int lineNumber, bool useFilename = true); 
    10     TestDetails(const TestDetails& details, int lineNumber, bool useFilename = true); 
     8        TestDetails ( char const* testName, char const* suiteName, char const* filename, int lineNumber, bool useFilename = true ); 
     9        TestDetails ( const TestDetails& details, int lineNumber, bool useFilename = true ); 
    1110 
    12     char const* const suiteName; 
    13     char const* const testName; 
    14     char const* const filename; 
    15     int const lineNumber; 
    16     bool const useFilename; 
     11        char const* const suiteName; 
     12        char const* const testName; 
     13        char const* const filename; 
     14        int const lineNumber; 
     15        bool const useFilename; 
    1716 
    18     TestDetails(TestDetails const&); // Why is it public? --> http://gcc.gnu.org/bugs.html#cxx_rvalbind 
     17        TestDetails ( TestDetails const& ); // Why is it public? --> http://gcc.gnu.org/bugs.html#cxx_rvalbind 
    1918private: 
    20     TestDetails& operator=(TestDetails const&); 
     19        TestDetails& operator= ( TestDetails const& ); 
    2120}; 
    2221 

  • library/tests/unittest-cpp/TestList.cpp

    r418 r477  
    66namespace UnitTest { 
    77 
    8 TestList::TestList()  
    9     : m_head(0) 
    10     , m_tail(0) 
    11 { 
     8TestList::TestList() 
     9                : m_head ( 0 ) 
     10                , m_tail ( 0 ) { 
    1211} 
    1312 
    14 void TestList::Add(Test* test) 
    15 { 
    16     if (m_tail == 0) 
    17     { 
    18         assert(m_head == 0); 
    19         m_head = test; 
    20         m_tail = test; 
    21     } 
    22     else 
    23     { 
    24         m_tail->next = test; 
    25         m_tail = test; 
    26     } 
     13void TestList::Add ( Test* test ) { 
     14        if ( m_tail == 0 ) { 
     15                assert ( m_head == 0 ); 
     16                m_head = test; 
     17                m_tail = test; 
     18        } else { 
     19                m_tail->next = test; 
     20                m_tail = test; 
     21        } 
    2722} 
    2823 
    29 Test* TestList::GetHead() const 
    30 { 
    31     return m_head; 
     24Test* TestList::GetHead() const { 
     25        return m_head; 
    3226} 
    3327 
    34 ListAdder::ListAdder(TestList& list, Test* test) 
    35 { 
    36     list.Add(test); 
     28ListAdder::ListAdder ( TestList& list, Test* test ) { 
     29        list.Add ( test ); 
    3730} 
    3831 

  • library/tests/unittest-cpp/TestList.h

    r418 r477  
    77class Test; 
    88 
    9 class TestList 
    10 { 
     9class TestList { 
    1110public: 
    12     TestList(); 
    13     void Add (Test* test); 
     11        TestList(); 
     12        void Add ( Test* test ); 
    1413 
    15     Test* GetHead() const; 
     14        Test* GetHead() const; 
    1615 
    1716private: 
    18     Test* m_head; 
    19     Test* m_tail; 
     17        Test* m_head; 
     18        Test* m_tail; 
    2019}; 
    2120 
    2221 
    23 class ListAdder 
    24 { 
     22class ListAdder { 
    2523public: 
    26     ListAdder(TestList& list, Test* test); 
     24        ListAdder ( TestList& list, Test* test ); 
    2725}; 
    2826 

  • library/tests/unittest-cpp/TestMacros.h

    r418 r477  
    99 
    1010#ifndef UNITTEST_POSIX 
    11         #define UNITTEST_THROW_SIGNALS 
     11#define UNITTEST_THROW_SIGNALS 
    1212#else 
    13         #include "Posix/SignalTranslator.h" 
     13#include "Posix/SignalTranslator.h" 
    1414#endif 
    1515 
    1616#ifdef TEST 
    17     #error UnitTest++ redefines TEST 
     17#error UnitTest++ redefines TEST 
    1818#endif 
    1919 
    2020#ifdef TEST_EX 
    21         #error UnitTest++ redefines TEST_EX 
     21#error UnitTest++ redefines TEST_EX 
    2222#endif 
    2323 
    2424#ifdef TEST_FIXTURE_EX 
    25         #error UnitTest++ redefines TEST_FIXTURE_EX 
     25#error UnitTest++ redefines TEST_FIXTURE_EX 
    2626#endif 
    2727 

  • library/tests/unittest-cpp/TestReporter.cpp

    r418 r477  
    44 
    55 
    6 TestReporter::~TestReporter() 
    7 { 
     6TestReporter::~TestReporter() { 
    87} 
    98 

  • library/tests/unittest-cpp/TestReporter.h

    r418 r477  
    66class TestDetails; 
    77 
    8 class TestReporter 
    9 { 
     8class TestReporter { 
    109public: 
    11     virtual ~TestReporter(); 
     10        virtual ~TestReporter(); 
    1211 
    13     virtual void ReportTestStart(TestDetails const& test) = 0; 
    14     virtual void ReportFailure(TestDetails const& test, char const* failure) = 0; 
    15     virtual void ReportTestFinish(TestDetails const& test, float secondsElapsed) = 0; 
    16     virtual void ReportSummary(int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed) = 0; 
     12        virtual void ReportTestStart ( TestDetails const& test ) = 0; 
     13        virtual void ReportFailure ( TestDetails const& test, char const* failure ) = 0; 
     14        virtual void ReportTestFinish ( TestDetails const& test, float secondsElapsed ) = 0; 
     15        virtual void ReportSummary ( int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed ) = 0; 
    1716}; 
    1817 

  • library/tests/unittest-cpp/TestReporterStdout.cpp

    r456 r477  
    66// cstdio doesn't pull in namespace std on VC6, so we do it here. 
    77#if defined(_MSC_VER) && (_MSC_VER == 1200) 
    8         namespace std {} 
     8namespace std {} 
    99#endif 
    1010 
    1111namespace UnitTest { 
    1212 
    13 void TestReporterStdout::ReportFailure(TestDetails const& details, char const* failure) 
    14 { 
     13void TestReporterStdout::ReportFailure ( TestDetails const& details, char const* failure ) { 
    1514#if defined(__APPLE__) || defined(__GNUG__) 
    16     char const* const errorFormat = "%s:%d: error: Failure in %s: %s\n"; 
     15        char const* const errorFormat = "%s:%d: error: Failure in %s: %s\n"; 
    1716#else 
    18     char const* const errorFormat = "%s(%d): error: Failure in %s: %s\n"; 
     17        char const* const errorFormat = "%s(%d): error: Failure in %s: %s\n"; 
    1918#endif 
    2019 
    21     using namespace std; 
     20        using namespace std; 
    2221 
    23     if (details.useFilename) { 
    24         // standard way 
    25         printf(errorFormat, details.filename, details.lineNumber, details.testName, failure); 
    26     } else {  
    27         // extended for BDM - the failure string already includes 
    28         // (custom) test location info 
    29         printf("%s\n", failure); 
    30     } 
     22        if ( details.useFilename ) { 
     23                // standard way 
     24                printf ( errorFormat, details.filename, details.lineNumber, details.testName, failure ); 
     25        } else { 
     26                // extended for BDM - the failure string already includes 
     27                // (custom) test location info 
     28                printf ( "%s\n", failure ); 
     29        } 
    3130} 
    3231 
    33 void TestReporterStdout::ReportTestStart(TestDetails const& /*test*/) 
    34 { 
     32void TestReporterStdout::ReportTestStart ( TestDetails const& /*test*/ ) { 
    3533} 
    3634 
    37 void TestReporterStdout::ReportTestFinish(TestDetails const& /*test*/, float) 
    38 { 
     35void TestReporterStdout::ReportTestFinish ( TestDetails const& /*test*/, float ) { 
    3936} 
    4037 
    41 void TestReporterStdout::ReportSummary(int const totalTestCount, int const failedTestCount, 
    42                                        int const failureCount, float secondsElapsed) 
    43 { 
     38void TestReporterStdout::ReportSummary ( int const totalTestCount, int const failedTestCount, 
     39        int const failureCount, float secondsElapsed ) { 
    4440        using namespace std; 
    4541 
    46     if (failureCount > 0) 
    47         printf("FAILURE: %d out of %d tests failed (%d failures).\n", failedTestCount, totalTestCount, failureCount); 
    48     else 
    49         printf("Success: %d tests passed.\n", totalTestCount); 
     42        if ( failureCount > 0 ) 
     43                printf ( "FAILURE: %d out of %d tests failed (%d failures).\n", failedTestCount, totalTestCount, failureCount ); 
     44        else 
     45                printf ( "Success: %d tests passed.\n", totalTestCount ); 
    5046 
    51     printf("Test time: %.2f seconds.\n", secondsElapsed); 
     47        printf ( "Test time: %.2f seconds.\n", secondsElapsed ); 
    5248} 
    5349 

  • library/tests/unittest-cpp/TestReporterStdout.h

    r418 r477  
    66namespace UnitTest { 
    77 
    8 class TestReporterStdout : public TestReporter 
    9 { 
     8class TestReporterStdout : public TestReporter { 
    109private: 
    11     virtual void ReportTestStart(TestDetails const& test); 
    12     virtual void ReportFailure(TestDetails const& test, char const* failure); 
    13     virtual void ReportTestFinish(TestDetails const& test, float secondsElapsed); 
    14     virtual void ReportSummary(int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed); 
     10        virtual void ReportTestStart ( TestDetails const& test ); 
     11        virtual void ReportFailure ( TestDetails const& test, char const* failure ); 
     12        virtual void ReportTestFinish ( TestDetails const& test, float secondsElapsed ); 
     13        virtual void ReportSummary ( int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed ); 
    1514}; 
    1615 
    1716} 
    1817 
    19 #endif  
     18#endif 

  • library/tests/unittest-cpp/TestResults.cpp

    r418 r477  
    66namespace UnitTest { 
    77 
    8 TestResults::TestResults(TestReporter* testReporter) 
    9     : m_testReporter(testReporter) 
    10     , m_totalTestCount(0) 
    11     , m_failedTestCount(0) 
    12     , m_failureCount(0) 
    13     , m_currentTestFailed(false) 
    14 { 
     8TestResults::TestResults ( TestReporter* testReporter ) 
     9                : m_testReporter ( testReporter ) 
     10                , m_totalTestCount ( 0 ) 
     11                , m_failedTestCount ( 0 ) 
     12                , m_failureCount ( 0 ) 
     13                , m_currentTestFailed ( false ) { 
    1514} 
    1615 
    17 void TestResults::OnTestStart(TestDetails const& test) 
    18 { 
    19     ++m_totalTestCount; 
    20     m_currentTestFailed = false; 
    21     if (m_testReporter) 
    22         m_testReporter->ReportTestStart(test); 
     16void TestResults::OnTestStart ( TestDetails const& test ) { 
     17        ++m_totalTestCount; 
     18        m_currentTestFailed = false; 
     19        if ( m_testReporter ) 
     20                m_testReporter->ReportTestStart ( test ); 
    2321} 
    2422 
    25 void TestResults::OnTestFailure(TestDetails const& test, char const* failure) 
    26 { 
    27     ++m_failureCount; 
    28     if (!m_currentTestFailed) 
    29     { 
    30         ++m_failedTestCount; 
    31         m_currentTestFailed = true; 
    32     } 
     23void TestResults::OnTestFailure ( TestDetails const& test, char const* failure ) { 
     24        ++m_failureCount; 
     25        if ( !m_currentTestFailed ) { 
     26                ++m_failedTestCount; 
     27                m_currentTestFailed = true; 
     28        } 
    3329 
    34     if (m_testReporter) 
    35         m_testReporter->ReportFailure(test, failure); 
     30        if ( m_testReporter ) 
     31                m_testReporter->ReportFailure ( test, failure ); 
    3632} 
    3733 
    38 void TestResults::OnTestFinish(TestDetails const& test, float secondsElapsed) 
    39 { 
    40     if (m_testReporter) 
    41         m_testReporter->ReportTestFinish(test, secondsElapsed); 
     34void TestResults::OnTestFinish ( TestDetails const& test, float secondsElapsed ) { 
     35        if ( m_testReporter ) 
     36                m_testReporter->ReportTestFinish ( test, secondsElapsed ); 
    4237} 
    4338 
    44 int TestResults::GetTotalTestCount() const 
    45 { 
    46     return m_totalTestCount; 
     39int TestResults::GetTotalTestCount() const { 
     40        return m_totalTestCount; 
    4741} 
    4842 
    49 int TestResults::GetFailedTestCount() const 
    50 { 
    51     return m_failedTestCount; 
     43int TestResults::GetFailedTestCount() const { 
     44        return m_failedTestCount; 
    5245} 
    5346 
    54 int TestResults::GetFailureCount() const 
    55 { 
    56     return m_failureCount; 
     47int TestResults::GetFailureCount() const { 
     48        return m_failureCount; 
    5749} 
    5850 

  • library/tests/unittest-cpp/TestResults.h

    r418 r477  
    77class TestDetails; 
    88 
    9 class TestResults 
    10 { 
     9class TestResults { 
    1110public: 
    12     explicit TestResults(TestReporter* reporter = 0); 
     11        explicit TestResults ( TestReporter* reporter = 0 ); 
    1312 
    14     void OnTestStart(TestDetails const& test); 
    15     void OnTestFailure(TestDetails const& test, char const* failure); 
    16     void OnTestFinish(TestDetails const& test, float secondsElapsed); 
     13        void OnTestStart ( TestDetails const& test ); 
     14        void OnTestFailure ( TestDetails const& test, char const* failure ); 
     15        void OnTestFinish ( TestDetails const& test, float secondsElapsed ); 
    1716 
    18     int GetTotalTestCount() const; 
    19     int GetFailedTestCount() const; 
    20     int GetFailureCount() const; 
     17        int GetTotalTestCount() const; 
     18        int GetFailedTestCount() const; 
     19        int GetFailureCount() const; 
    2120 
    2221private: 
    23     TestReporter* m_testReporter; 
    24     int m_totalTestCount; 
    25     int m_failedTestCount; 
    26     int m_failureCount; 
     22        TestReporter* m_testReporter; 
     23        int m_totalTestCount; 
     24        int m_failedTestCount; 
     25        int m_failureCount; 
    2726 
    28     bool m_currentTestFailed; 
     27        bool m_currentTestFailed; 
    2928 
    30     TestResults(TestResults const&); 
    31     TestResults& operator =(TestResults const&); 
     29        TestResults ( TestResults const& ); 
     30        TestResults& operator = ( TestResults const& ); 
    3231}; 
    3332 

  • library/tests/unittest-cpp/TestRunner.cpp

    r418 r477  
    1111namespace UnitTest { 
    1212 
    13 int RunAllTests() 
    14 { 
     13int RunAllTests() { 
    1514        TestReporterStdout reporter; 
    16         TestRunner runner(reporter); 
    17         return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0); 
     15        TestRunner runner ( reporter ); 
     16        return runner.RunTestsIf ( Test::GetTestList(), NULL, True(), 0 ); 
    1817} 
    1918 
    2019 
    21 TestRunner::TestRunner(TestReporter& reporter) 
    22         : m_reporter(&reporter) 
    23         , m_result(new TestResults(&reporter)) 
    24         , m_timer(new Timer) 
    25 { 
     20TestRunner::TestRunner ( TestReporter& reporter ) 
     21                : m_reporter ( &reporter ) 
     22                , m_result ( new TestResults ( &reporter ) ) 
     23                , m_timer ( new Timer ) { 
    2624        m_timer->Start(); 
    2725} 
    2826 
    29 TestRunner::~TestRunner() 
    30 { 
     27TestRunner::~TestRunner() { 
    3128        delete m_result; 
    3229        delete m_timer; 
    3330} 
    3431 
    35 int TestRunner::Finish() const 
    36 { 
    37     float const secondsElapsed = static_cast<float>(m_timer->GetTimeInMs() / 1000.0); 
    38     m_reporter->ReportSummary(m_result->GetTotalTestCount(),  
    39                                                           m_result->GetFailedTestCount(),  
    40                                                           m_result->GetFailureCount(),  
    41                                                           secondsElapsed); 
    42      
     32int TestRunner::Finish() const { 
     33        float const secondsElapsed = static_cast<float> ( m_timer->GetTimeInMs() / 1000.0 ); 
     34        m_reporter->ReportSummary ( m_result->GetTotalTestCount(), 
     35                                    m_result->GetFailedTestCount(), 
     36                                    m_result->GetFailureCount(), 
     37                                    secondsElapsed ); 
     38 
    4339        return m_result->GetFailureCount(); 
    4440} 
    4541 
    46 bool TestRunner::IsTestInSuite(const Test* const curTest, char const* suiteName) const 
    47 { 
     42bool TestRunner::IsTestInSuite ( const Test* const curTest, char const* suiteName ) const { 
    4843        using namespace std; 
    49         return (suiteName == NULL) || !strcmp(curTest->m_details.suiteName, suiteName); 
     44        return ( suiteName == NULL ) || !strcmp ( curTest->m_details.suiteName, suiteName ); 
    5045} 
    5146 
    52 void TestRunner::RunTest(TestResults* const result, Test* const curTest, int const maxTestTimeInMs) const 
    53 { 
     47void TestRunner::RunTest ( TestResults* const result, Test* const curTest, int const maxTestTimeInMs ) const { 
    5448        CurrentTest::Results() = result; 
    5549 
    … …  
    5751        testTimer.Start(); 
    5852 
    59         result->OnTestStart(curTest->m_details); 
     53        result->OnTestStart ( curTest->m_details ); 
    6054 
    6155        curTest->Run(); 
    6256 
    6357        double const testTimeInMs = testTimer.GetTimeInMs(); 
    64         if (maxTestTimeInMs > 0 && testTimeInMs > maxTestTimeInMs && !curTest->m_timeConstraintExempt) 
    65         { 
    66             MemoryOutStream stream; 
    67             stream << "Global time constraint failed. Expected under " << maxTestTimeInMs << 
    68                     "ms but took " << testTimeInMs << "ms."; 
     58        if ( maxTestTimeInMs > 0 && testTimeInMs > maxTestTimeInMs && !curTest->m_timeConstraintExempt ) { 
     59                MemoryOutStream stream; 
     60                stream << "Global time constraint failed. Expected under " << maxTestTimeInMs << 
     61                "ms but took " << testTimeInMs << "ms."; 
    6962 
    70             result->OnTestFailure(curTest->m_details, stream.GetText()); 
     63                result->OnTestFailure ( curTest->m_details, stream.GetText() ); 
    7164        } 
    7265 
    73         result->OnTestFinish(curTest->m_details, static_cast<float>(testTimeInMs/1000.0)); 
     66        result->OnTestFinish ( curTest->m_details, static_cast<float> ( testTimeInMs / 1000.0 ) ); 
    7467} 
    7568 

  • library/tests/unittest-cpp/TestRunner.h

    r418 r477  
    1414int RunAllTests(); 
    1515 
    16 struct True 
    17 { 
    18         bool operator()(const Test* const) const 
    19         { 
    20                 return true;     
     16struct True { 
     17        bool operator() ( const Test* const ) const { 
     18                return true; 
    2119        } 
    2220}; 
    2321 
    24 class TestRunner 
    25 { 
     22class TestRunner { 
    2623public: 
    27         explicit TestRunner(TestReporter& reporter); 
     24        explicit TestRunner ( TestReporter& reporter ); 
    2825        ~TestRunner(); 
    2926 
    3027        template <class Predicate> 
    31         int RunTestsIf(TestList const& list, char const* suiteName,  
    32                                    const Predicate& predicate, int maxTestTimeInMs) const 
    33         { 
    34             Test* curTest = list.GetHead(); 
     28        int RunTestsIf ( TestList const& list, char const* suiteName, 
     29                         const Predicate& predicate, int maxTestTimeInMs ) const { 
     30                Test* curTest = list.GetHead(); 
    3531 
    36             while (curTest != 0) 
    37             { 
    38                     if (IsTestInSuite(curTest, suiteName) && predicate(curTest)) 
    39                                 RunTest(m_result, curTest, maxTestTimeInMs); 
     32                while ( curTest != 0 ) { 
     33                        if ( IsTestInSuite ( curTest, suiteName ) && predicate ( curTest ) ) 
     34                                RunTest ( m_result, curTest, maxTestTimeInMs ); 
    4035 
    4136                        curTest = curTest->next; 
    42             } 
     37                } 
    4338 
    44             return Finish(); 
    45         }        
     39                return Finish(); 
     40        } 
    4641 
    4742private: 
    … …  
    5146 
    5247        int Finish() const; 
    53         bool IsTestInSuite(const Test* const curTest, char const* suiteName) const; 
    54         void RunTest(TestResults* const result, Test* const curTest, int const maxTestTimeInMs) const; 
     48        bool IsTestInSuite ( const Test* const curTest, char const* suiteName ) const; 
     49        void RunTest ( TestResults* const result, Test* const curTest, int const maxTestTimeInMs ) const; 
    5550}; 
    5651 

  • library/tests/unittest-cpp/TestSuite.h

    r418 r477  
    22#define UNITTEST_TESTSUITE_H 
    33 
    4 namespace UnitTestSuite  
    5 { 
    6     inline char const* GetSuiteName () 
    7     { 
    8         return "DefaultSuite"; 
    9     } 
     4namespace UnitTestSuite { 
     5inline char const* GetSuiteName () { 
     6        return "DefaultSuite"; 
     7} 
    108} 
    119 

  • library/tests/unittest-cpp/TimeConstraint.cpp

    r418 r477  
    77 
    88 
    9 TimeConstraint::TimeConstraint(int ms, TestDetails const& details) 
    10         : m_details(details) 
    11     , m_maxMs(ms) 
    12 { 
    13     m_timer.Start(); 
     9TimeConstraint::TimeConstraint ( int ms, TestDetails const& details ) 
     10                : m_details ( details ) 
     11                , m_maxMs ( ms ) { 
     12        m_timer.Start(); 
    1413} 
    1514 
    16 TimeConstraint::~TimeConstraint() 
    17 { 
    18     double const totalTimeInMs = m_timer.GetTimeInMs(); 
    19     if (totalTimeInMs > m_maxMs) 
    20     { 
    21         MemoryOutStream stream; 
    22         stream << "Time constraint failed. Expected to run test under " << m_maxMs << 
    23                   "ms but took " << totalTimeInMs << "ms."; 
     15TimeConstraint::~TimeConstraint() { 
     16        double const totalTimeInMs = m_timer.GetTimeInMs(); 
     17        if ( totalTimeInMs > m_maxMs ) { 
     18                MemoryOutStream stream; 
     19                stream << "Time constraint failed. Expected to run test under " << m_maxMs << 
     20                "ms but took " << totalTimeInMs << "ms."; 
    2421 
    25                 UnitTest::CurrentTest::Results()->OnTestFailure(m_details, stream.GetText()); 
    26     } 
     22                UnitTest::CurrentTest::Results()->OnTestFailure ( m_details, stream.GetText() ); 
     23        } 
    2724} 
    2825 

  • library/tests/unittest-cpp/TimeConstraint.h

    r418 r477  
    99class TestDetails; 
    1010 
    11 class TimeConstraint 
    12 { 
     11class TimeConstraint { 
    1312public: 
    14     TimeConstraint(int ms, TestDetails const& details); 
    15     ~TimeConstraint(); 
     13        TimeConstraint ( int ms, TestDetails const& details ); 
     14        ~TimeConstraint(); 
    1615 
    1716private: 
    18     void operator=(TimeConstraint const&);  
    19         TimeConstraint(TimeConstraint const&); 
     17        void operator= ( TimeConstraint const& ); 
     18        TimeConstraint ( TimeConstraint const& ); 
    2019 
    2120        Timer m_timer; 
    22     TestDetails const& m_details; 
     21        TestDetails const& m_details; 
    2322        int const m_maxMs; 
    2423}; 

  • library/tests/unittest-cpp/TimeHelpers.h

    r418 r477  
    22 
    33#if defined UNITTEST_POSIX 
    4     #include "Posix/TimeHelpers.h" 
     4#include "Posix/TimeHelpers.h" 
    55#else 
    6     #include "Win32/TimeHelpers.h" 
     6#include "Win32/TimeHelpers.h" 
    77#endif 

  • library/tests/unittest-cpp/Win32/TimeHelpers.cpp

    r418 r477  
    55 
    66Timer::Timer() 
    7         : m_threadHandle(::GetCurrentThread()) 
    8         , m_startTime(0) 
    9 { 
     7                : m_threadHandle ( ::GetCurrentThread() ) 
     8                , m_startTime ( 0 ) { 
    109#if defined(_MSC_VER) && (_MSC_VER == 1200) // VC6 doesn't have DWORD_PTR? 
    1110        typedef unsigned long DWORD_PTR; 
    … …  
    1312 
    1413        DWORD_PTR systemMask; 
    15         ::GetProcessAffinityMask(GetCurrentProcess(), &m_processAffinityMask, &systemMask); 
    16         ::SetThreadAffinityMask(m_threadHandle, 1); 
    17         ::QueryPerformanceFrequency(reinterpret_cast< LARGE_INTEGER* >(&m_frequency)); 
    18         ::SetThreadAffinityMask(m_threadHandle, m_processAffinityMask); 
     14        ::GetProcessAffinityMask ( GetCurrentProcess(), &m_processAffinityMask, &systemMask ); 
     15        ::SetThreadAffinityMask ( m_threadHandle, 1 ); 
     16        ::QueryPerformanceFrequency ( reinterpret_cast< LARGE_INTEGER* > ( &m_frequency ) ); 
     17        ::SetThreadAffinityMask ( m_threadHandle, m_processAffinityMask ); 
    1918} 
    2019 
    21 void Timer::Start() 
    22 { 
     20void Timer::Start() { 
    2321        m_startTime = GetTime(); 
    2422} 
    2523 
    26 double Timer::GetTimeInMs() const 
    27 { 
     24double Timer::GetTimeInMs() const { 
    2825        __int64 const elapsedTime = GetTime() - m_startTime; 
    29         double const seconds = double(elapsedTime) / double(m_frequency); 
     26        double const seconds = double ( elapsedTime ) / double ( m_frequency ); 
    3027        return seconds * 1000.0; 
    3128} 
    3229 
    33 __int64 Timer::GetTime() const 
    34 { 
     30__int64 Timer::GetTime() const { 
    3531        LARGE_INTEGER curTime; 
    36         ::SetThreadAffinityMask(m_threadHandle, 1); 
    37         ::QueryPerformanceCounter(&curTime); 
    38         ::SetThreadAffinityMask(m_threadHandle, m_processAffinityMask); 
     32        ::SetThreadAffinityMask ( m_threadHandle, 1 ); 
     33        ::QueryPerformanceCounter ( &curTime ); 
     34        ::SetThreadAffinityMask ( m_threadHandle, m_processAffinityMask ); 
    3935        return curTime.QuadPart; 
    4036} 
    4137 
    42 void TimeHelpers::SleepMs(int const ms) 
    43 { 
    44         ::Sleep(ms); 
     38void TimeHelpers::SleepMs ( int const ms ) { 
     39        ::Sleep ( ms ); 
    4540} 
    4641 

  • library/tests/unittest-cpp/Win32/TimeHelpers.h

    r418 r477  
    66 
    77#ifdef UNITTEST_MINGW 
    8     #ifndef __int64 
    9         #define __int64 long long 
    10     #endif 
     8#ifndef __int64 
     9#define __int64 long long 
     10#endif 
    1111#endif 
    1212 
    1313namespace UnitTest { 
    1414 
    15 class Timer 
    16 { 
     15class Timer { 
    1716public: 
    18     Timer(); 
     17        Timer(); 
    1918        void Start(); 
    20         double GetTimeInMs() const;     
     19        double GetTimeInMs() const; 
    2120 
    2221private: 
    23     __int64 GetTime() const; 
     22        __int64 GetTime() const; 
    2423 
    25     void* m_threadHandle; 
     24        void* m_threadHandle; 
    2625 
    2726#if defined(_WIN64) 
    28     unsigned __int64 m_processAffinityMask; 
     27        unsigned __int64 m_processAffinityMask; 
    2928#else 
    30     unsigned long m_processAffinityMask; 
     29        unsigned long m_processAffinityMask; 
    3130#endif 
    3231 
    … …  
    3635 
    3736 
    38 namespace TimeHelpers 
    39 { 
    40 void SleepMs (int ms); 
     37namespace TimeHelpers { 
     38void SleepMs ( int ms ); 
    4139} 
    4240 

  • library/tests/unittest-cpp/XmlTestReporter.cpp

    r418 r477  
    1212namespace { 
    1313 
    14 void ReplaceChar(string& str, char c, string const& replacement) 
    15 { 
    16     for (size_t pos = str.find(c); pos != string::npos; pos = str.find(c, pos + 1)) 
    17         str.replace(pos, 1, replacement); 
     14void ReplaceChar ( string& str, char c, string const& replacement ) { 
     15        for ( size_t pos = str.find ( c ); pos != string::npos; pos = str.find ( c, pos + 1 ) ) 
     16                str.replace ( pos, 1, replacement ); 
    1817} 
    1918 
    20 string XmlEscape(string const& value) 
    21 { 
    22     string escaped = value; 
     19string XmlEscape ( string const& value ) { 
     20        string escaped = value; 
    2321 
    24     ReplaceChar(escaped, '&', "&amp;"); 
    25     ReplaceChar(escaped, '<', "&lt;"); 
    26     ReplaceChar(escaped, '>', "&gt;"); 
    27     ReplaceChar(escaped, '\'', "&apos;"); 
    28     ReplaceChar(escaped, '\"', "&quot;"); 
    29   
    30     return escaped; 
     22        ReplaceChar ( escaped, '&', "&amp;" ); 
     23        ReplaceChar ( escaped, '<', "&lt;" ); 
     24        ReplaceChar ( escaped, '>', "&gt;" ); 
     25        ReplaceChar ( escaped, '\'', "&apos;" ); 
     26        ReplaceChar ( escaped, '\"', "&quot;" ); 
     27 
     28        return escaped; 
    3129} 
    3230 
    33 string BuildFailureMessage(string const& file, int line, string const& message) 
    34 { 
    35     ostringstream failureMessage; 
    36     failureMessage << file << "(" << line << ") : " << message; 
    37     return failureMessage.str(); 
     31string BuildFailureMessage ( string const& file, int line, string const& message ) { 
     32        ostringstream failureMessage; 
     33        failureMessage << file << "(" << line << ") : " << message; 
     34        return failureMessage.str(); 
    3835} 
    3936 
    … …  
    4239namespace UnitTest { 
    4340 
    44 XmlTestReporter::XmlTestReporter(ostream& ostream) 
    45     : m_ostream(ostream) 
    46 { 
     41XmlTestReporter::XmlTestReporter ( ostream& ostream ) 
     42                : m_ostream ( ostream ) { 
    4743} 
    4844 
    49 void XmlTestReporter::ReportSummary(int totalTestCount, int failedTestCount, 
    50                                     int failureCount, float secondsElapsed) 
    51 { 
    52     AddXmlElement(m_ostream, NULL); 
     45void XmlTestReporter::ReportSummary ( int totalTestCount, int failedTestCount, 
     46                                      int failureCount, float secondsElapsed ) { 
     47        AddXmlElement ( m_ostream, NULL ); 
    5348 
    54     BeginResults(m_ostream, totalTestCount, failedTestCount, failureCount, secondsElapsed); 
     49        BeginResults ( m_ostream, totalTestCount, failedTestCount, failureCount, secondsElapsed ); 
    5550 
    56     DeferredTestResultList const& results = GetResults(); 
    57     for (DeferredTestResultList::const_iterator i = results.begin(); i != results.end(); ++i) 
    58     { 
    59         BeginTest(m_ostream, *i); 
     51        DeferredTestResultList const& results = GetResults(); 
     52        for ( DeferredTestResultList::const_iterator i = results.begin(); i != results.end(); ++i ) { 
     53                BeginTest ( m_ostream, *i ); 
    6054 
    61         if (i->failed) 
    62             AddFailure(m_ostream, *i); 
     55                if ( i->failed ) 
     56                        AddFailure ( m_ostream, *i ); 
    6357 
    64         EndTest(m_ostream, *i); 
    65     } 
     58                EndTest ( m_ostream, *i ); 
     59        } 
    6660 
    67     EndResults(m_ostream); 
     61        EndResults ( m_ostream ); 
    6862} 
    6963 
    70 void XmlTestReporter::AddXmlElement(ostream& os, char const* encoding) 
    71 { 
    72     os << "<?xml version=\"1.0\""; 
     64void XmlTestReporter::AddXmlElement ( ostream& os, char const* encoding ) { 
     65        os << "<?xml version=\"1.0\""; 
    7366 
    74     if (encoding != NULL) 
    75         os << " encoding=\"" << encoding << "\""; 
     67        if ( encoding != NULL ) 
     68                os << " encoding=\"" << encoding << "\""; 
    7669 
    77     os << "?>"; 
     70        os << "?>"; 
    7871} 
    7972 
    80 void XmlTestReporter::BeginResults(std::ostream& os, int totalTestCount, int failedTestCount,  
    81                                    int failureCount, float secondsElapsed) 
    82 { 
    83    os << "<unittest-results" 
    84        << " tests=\"" << totalTestCount << "\""  
    85        << " failedtests=\"" << failedTestCount << "\""  
    86        << " failures=\"" << failureCount << "\""  
    87        << " time=\"" << secondsElapsed << "\"" 
    88        << ">"; 
     73void XmlTestReporter::BeginResults ( std::ostream& os, int totalTestCount, int failedTestCount, 
     74                                     int failureCount, float secondsElapsed ) { 
     75        os << "<unittest-results" 
     76        << " tests=\"" << totalTestCount << "\"" 
     77        << " failedtests=\"" << failedTestCount << "\"" 
     78        << " failures=\"" << failureCount << "\"" 
     79        << " time=\"" << secondsElapsed << "\"" 
     80        << ">"; 
    8981} 
    9082 
    91 void XmlTestReporter::EndResults(std::ostream& os) 
    92 { 
    93     os << "</unittest-results>"; 
     83void XmlTestReporter::EndResults ( std::ostream& os ) { 
     84        os << "</unittest-results>"; 
    9485} 
    9586 
    96 void XmlTestReporter::BeginTest(std::ostream& os, DeferredTestResult const& result) 
    97 { 
    98     os << "<test" 
    99         << " suite=\"" << result.suiteName << "\""  
    100         << " name=\"" << result.testName << "\"" 
    101         << " time=\"" << result.timeElapsed << "\""; 
     87void XmlTestReporter::BeginTest ( std::ostream& os, DeferredTestResult const& result ) { 
     88        os << "<test" 
     89        << " suite=\"" << result.suiteName << "\"" 
     90        << " name=\"" << result.testName << "\"" 
     91        << " time=\"" << result.timeElapsed << "\""; 
    10292} 
    10393 
    104 void XmlTestReporter::EndTest(std::ostream& os, DeferredTestResult const& result) 
    105 { 
    106     if (result.failed) 
    107         os << "</test>"; 
    108     else 
    109         os << "/>"; 
     94void XmlTestReporter::EndTest ( std::ostream& os, DeferredTestResult const& result ) { 
     95        if ( result.failed ) 
     96                os << "</test>"; 
     97        else 
     98                os << "/>"; 
    11099} 
    111100 
    112 void XmlTestReporter::AddFailure(std::ostream& os, DeferredTestResult const& result) 
    113 { 
    114     os << ">"; // close <test> element 
     101void XmlTestReporter::AddFailure ( std::ostream& os, DeferredTestResult const& result ) { 
     102        os << ">"; // close <test> element 
    115103 
    116     for (DeferredTestResult::FailureVec::const_iterator it = result.failures.begin();  
    117          it != result.failures.end();  
    118          ++it) 
    119     { 
    120         string const escapedMessage = XmlEscape(it->second); 
    121         string const message = BuildFailureMessage(result.failureFile, it->first, escapedMessage); 
     104        for ( DeferredTestResult::FailureVec::const_iterator it = result.failures.begin(); 
     105                it != result.failures.end(); 
     106                ++it ) { 
     107                string const escapedMessage = XmlEscape ( it->second ); 
     108                string const message = BuildFailureMessage ( result.failureFile, it->first, escapedMessage ); 
    122109 
    123         os << "<failure" << " message=\"" << message << "\"" << "/>"; 
    124     } 
     110                os << "<failure" << " message=\"" << message << "\"" << "/>"; 
     111        } 
    125112} 
    126113 

  • library/tests/unittest-cpp/XmlTestReporter.h

    r418 r477  
    66#include <iosfwd> 
    77 
    8 namespace UnitTest 
    9 { 
     8namespace UnitTest { 
    109 
    11 class XmlTestReporter : public DeferredTestReporter 
    12 { 
     10class XmlTestReporter : public DeferredTestReporter { 
    1311public: 
    14     explicit XmlTestReporter(std::ostream& ostream); 
     12        explicit XmlTestReporter ( std::ostream& ostream ); 
    1513 
    16     virtual void ReportSummary(int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed); 
     14        virtual void ReportSummary ( int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed ); 
    1715 
    1816private: 
    19     XmlTestReporter(XmlTestReporter const&); 
    20     XmlTestReporter& operator=(XmlTestReporter const&); 
     17        XmlTestReporter ( XmlTestReporter const& ); 
     18        XmlTestReporter& operator= ( XmlTestReporter const& ); 
    2119 
    22     void AddXmlElement(std::ostream& os, char const* encoding); 
    23     void BeginResults(std::ostream& os, int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed); 
    24     void EndResults(std::ostream& os); 
    25     void BeginTest(std::ostream& os, DeferredTestResult const& result); 
    26     void AddFailure(std::ostream& os, DeferredTestResult const& result); 
    27     void EndTest(std::ostream& os, DeferredTestResult const& result); 
     20        void AddXmlElement ( std::ostream& os, char const* encoding ); 
     21        void BeginResults ( std::ostream& os, int totalTestCount, int failedTestCount, int failureCount, float secondsElapsed ); 
     22        void EndResults ( std::ostream& os ); 
     23        void BeginTest ( std::ostream& os, DeferredTestResult const& result ); 
     24        void AddFailure ( std::ostream& os, DeferredTestResult const& result ); 
     25        void EndTest ( std::ostream& os, DeferredTestResult const& result ); 
    2826 
    29     std::ostream& m_ostream; 
     27        std::ostream& m_ostream; 
    3028}; 
    3129