boost/test/impl/results_collector.ipp

   1 //  (C) Copyright Gennadiy Rozental 2001.
   2 //  Distributed under the Boost Software License, Version 1.0.
   3 //  (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  See http://www.boost.org/libs/test for the library home page.
   7 //
   8 /// @file
   9 /// Test results collecting facility.
  10 ///
  11 // ***************************************************************************
  12
  13 #ifndef BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
  14 #define BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
  15
  16 // Boost.Test
  17 #include <boost/test/unit_test_log.hpp>
  18 #include <boost/test/results_collector.hpp>
  19 #include <boost/test/framework.hpp>
  20 #include <boost/test/execution_monitor.hpp>
  21
  22 #include <boost/test/tree/test_unit.hpp>
  23 #include <boost/test/tree/visitor.hpp>
  24 #include <boost/test/tree/test_case_counter.hpp>
  25 #include <boost/test/tree/traverse.hpp>
  26
  27 // Boost
  28 #include <boost/cstdlib.hpp>
  29
  30 // STL
  31 #include <map>
  32
  33 #include <boost/test/detail/suppress_warnings.hpp>
  34
  35 //____________________________________________________________________________//
  36
  37 namespace boost {
  38 namespace unit_test {
  39
  40 // ************************************************************************** //
  41 // **************                 test_results                 ************** //
  42 // ************************************************************************** //
  43
  44 test_results::test_results()
  45 {
  46     clear();
  47 }
  48
  49 //____________________________________________________________________________//
  50
  51 bool
  52 test_results::passed() const
  53 {
  54     // if it is skipped, it is not passed. However, if any children is not failed/aborted
  55     // then their skipped status is not taken into account.
  56     return  !p_skipped                                  &&
  57             p_test_cases_failed == 0                    &&
  58             p_assertions_failed <= p_expected_failures  &&
  59             // p_test_cases_skipped == 0                   &&
  60             !p_timed_out                                 &&
  61             p_test_cases_timed_out == 0                  &&
  62             !aborted();
  63 }
  64
  65 //____________________________________________________________________________//
  66
  67 bool
  68 test_results::aborted() const
  69 {
  70     return  p_aborted;
  71 }
  72
  73 //____________________________________________________________________________//
  74
  75 bool
  76 test_results::skipped() const
  77 {
  78     return  p_skipped;
  79 }
  80
  81 //____________________________________________________________________________//
  82
  83 int
  84 test_results::result_code() const
  85 {
  86     return passed() ? exit_success
  87            : ( (p_assertions_failed > p_expected_failures || p_skipped || p_timed_out || p_test_cases_timed_out )
  88                     ? exit_test_failure
  89                     : exit_exception_failure );
  90 }
  91
  92 //____________________________________________________________________________//
  93
  94 void
  95 test_results::operator+=( test_results const& tr )
  96 {
  97     p_test_suites.value         += tr.p_test_suites;
  98     p_assertions_passed.value   += tr.p_assertions_passed;
  99     p_assertions_failed.value   += tr.p_assertions_failed;
 100     p_warnings_failed.value     += tr.p_warnings_failed;
 101     p_test_cases_passed.value   += tr.p_test_cases_passed;
 102     p_test_cases_warned.value   += tr.p_test_cases_warned;
 103     p_test_cases_failed.value   += tr.p_test_cases_failed;
 104     p_test_cases_skipped.value  += tr.p_test_cases_skipped;
 105     p_test_cases_aborted.value  += tr.p_test_cases_aborted;
 106     p_test_cases_timed_out.value += tr.p_test_cases_timed_out;
 107     p_test_suites_timed_out.value += tr.p_test_suites_timed_out;
 108     p_duration_microseconds.value += tr.p_duration_microseconds;
 109 }
 110
 111 //____________________________________________________________________________//
 112
 113 void
 114 test_results::clear()
 115 {
 116     p_test_suites.value         = 0;
 117     p_assertions_passed.value   = 0;
 118     p_assertions_failed.value   = 0;
 119     p_warnings_failed.value     = 0;
 120     p_expected_failures.value   = 0;
 121     p_test_cases_passed.value   = 0;
 122     p_test_cases_warned.value   = 0;
 123     p_test_cases_failed.value   = 0;
 124     p_test_cases_skipped.value  = 0;
 125     p_test_cases_aborted.value  = 0;
 126     p_test_cases_timed_out.value = 0;
 127     p_test_suites_timed_out.value = 0;
 128     p_duration_microseconds.value= 0;
 129     p_aborted.value             = false;
 130     p_skipped.value             = false;
 131     p_timed_out.value           = false;
 132 }
 133
 134 //____________________________________________________________________________//
 135
 136 // ************************************************************************** //
 137 // **************               results_collector              ************** //
 138 // ************************************************************************** //
 139
 140 namespace {
 141
 142 struct results_collector_impl {
 143     std::map<test_unit_id,test_results> m_results_store;
 144 };
 145
 146 results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
 147
 148 } // local namespace
 149
 150 //____________________________________________________________________________//
 151
 152 BOOST_TEST_SINGLETON_CONS_IMPL( results_collector_t )
 153
 154 //____________________________________________________________________________//
 155
 156 void
 157 results_collector_t::test_start( counter_t )
 158 {
 159     s_rc_impl().m_results_store.clear();
 160 }
 161
 162 //____________________________________________________________________________//
 163
 164 void
 165 results_collector_t::test_unit_start( test_unit const& tu )
 166 {
 167     // init test_results entry
 168     test_results& tr = s_rc_impl().m_results_store[tu.p_id];
 169
 170     tr.clear();
 171
 172     tr.p_expected_failures.value = tu.p_expected_failures;
 173 }
 174
 175 //____________________________________________________________________________//
 176
 177 class results_collect_helper : public test_tree_visitor {
 178 public:
 179     explicit results_collect_helper( test_results& tr, test_unit const& ts ) : m_tr( tr ), m_ts( ts ) {}
 180
 181     void    visit( test_case const& tc )
 182     {
 183         test_results const& tr = results_collector.results( tc.p_id );
 184         m_tr += tr;
 185
 186         if( tr.passed() ) {
 187             if( tr.p_warnings_failed )
 188                 m_tr.p_test_cases_warned.value++;
 189             else
 190                 m_tr.p_test_cases_passed.value++;
 191         }
 192         else if( tr.p_timed_out ) {
 193             m_tr.p_test_cases_timed_out.value++;
 194         }
 195         else if( tr.p_skipped || !tc.is_enabled() ) {
 196             m_tr.p_test_cases_skipped.value++;
 197         }
 198         else {
 199             if( tr.p_aborted )
 200                 m_tr.p_test_cases_aborted.value++;
 201
 202             m_tr.p_test_cases_failed.value++;
 203         }
 204     }
 205     bool    test_suite_start( test_suite const& ts )
 206     {
 207         if( m_ts.p_id == ts.p_id )
 208             return true;
 209
 210         m_tr += results_collector.results( ts.p_id );
 211         m_tr.p_test_suites.value++;
 212
 213         if( results_collector.results( ts.p_id ).p_timed_out )
 214             m_tr.p_test_suites_timed_out.value++;
 215         return false;
 216     }
 217
 218 private:
 219     // Data members
 220     test_results&       m_tr;
 221     test_unit const&    m_ts;
 222 };
 223
 224 //____________________________________________________________________________//
 225
 226 void
 227 results_collector_t::test_unit_finish( test_unit const& tu, unsigned long elapsed_in_microseconds )
 228 {
 229     test_results & tr = s_rc_impl().m_results_store[tu.p_id];
 230     if( tu.p_type == TUT_SUITE ) {
 231         results_collect_helper ch( tr, tu );
 232         traverse_test_tree( tu, ch, true ); // true to ignore the status: we need to count the skipped/disabled tests
 233     }
 234     else {
 235         bool num_failures_match = tr.p_aborted || tr.p_assertions_failed >= tr.p_expected_failures;
 236         if( !num_failures_match )
 237             BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " has fewer failures than expected" );
 238
 239         bool check_any_assertions = tr.p_aborted || (tr.p_assertions_failed != 0) || (tr.p_assertions_passed != 0);
 240         if( !check_any_assertions )
 241             BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " did not check any assertions" );
 242     }
 243     tr.p_duration_microseconds.value = elapsed_in_microseconds;
 244 }
 245
 246 //____________________________________________________________________________//
 247
 248 void
 249 results_collector_t::test_unit_skipped( test_unit const& tu, const_string /*reason*/ )
 250 {
 251     test_results& tr = s_rc_impl().m_results_store[tu.p_id];
 252     tr.clear();
 253
 254     tr.p_skipped.value = true;
 255
 256     if( tu.p_type == TUT_SUITE ) {
 257         test_case_counter tcc(true);
 258         traverse_test_tree( tu, tcc, true ); // true because need to count the disabled tests/units
 259
 260         tr.p_test_cases_skipped.value = tcc.p_count;
 261     }
 262 }
 263
 264 //____________________________________________________________________________//
 265
 266 void
 267 results_collector_t::test_unit_timed_out(test_unit const& tu)
 268 {
 269     test_results& tr = s_rc_impl().m_results_store[tu.p_id];
 270     tr.p_timed_out.value = true;
 271 }
 272
 273 //____________________________________________________________________________//
 274
 275 void
 276 results_collector_t::assertion_result( unit_test::assertion_result ar )
 277 {
 278     test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
 279
 280     switch( ar ) {
 281     case AR_PASSED: tr.p_assertions_passed.value++; break;
 282     case AR_FAILED: tr.p_assertions_failed.value++; break;
 283     case AR_TRIGGERED: tr.p_warnings_failed.value++; break;
 284     }
 285
 286     if( tr.p_assertions_failed == 1 )
 287         first_failed_assertion();
 288 }
 289
 290 //____________________________________________________________________________//
 291
 292 void
 293 results_collector_t::exception_caught( execution_exception const& ex)
 294 {
 295     test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
 296
 297     tr.p_assertions_failed.value++;
 298     if( ex.code() == execution_exception::timeout_error ) {
 299         tr.p_timed_out.value = true;
 300     }
 301 }
 302
 303 //____________________________________________________________________________//
 304
 305 void
 306 results_collector_t::test_unit_aborted( test_unit const& tu )
 307 {
 308     s_rc_impl().m_results_store[tu.p_id].p_aborted.value = true;
 309 }
 310
 311 //____________________________________________________________________________//
 312
 313 test_results const&
 314 results_collector_t::results( test_unit_id id ) const
 315 {
 316     return s_rc_impl().m_results_store[id];
 317 }
 318
 319 //____________________________________________________________________________//
 320
 321 } // namespace unit_test
 322 } // namespace boost
 323
 324 #include <boost/test/detail/enable_warnings.hpp>
 325
 326 #endif // BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER