boost/test/impl/unit_test_log.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        : $RCSfile$
   9 //
  10 //  Version     : $Revision$
  11 //
  12 //  Description : implemets Unit Test Log
  13 // ***************************************************************************
  14
  15 #ifndef BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
  16 #define BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
  17
  18 // Boost.Test
  19 #include <boost/test/unit_test_log.hpp>
  20 #include <boost/test/unit_test_log_formatter.hpp>
  21 #include <boost/test/execution_monitor.hpp>
  22 #include <boost/test/framework.hpp>
  23 #include <boost/test/unit_test_parameters.hpp>
  24
  25 #include <boost/test/utils/basic_cstring/compare.hpp>
  26 #include <boost/test/utils/foreach.hpp>
  27
  28 #include <boost/test/output/compiler_log_formatter.hpp>
  29 #include <boost/test/output/xml_log_formatter.hpp>
  30 #include <boost/test/output/junit_log_formatter.hpp>
  31
  32 // Boost
  33 #include <boost/shared_ptr.hpp>
  34 #include <boost/io/ios_state.hpp>
  35 typedef ::boost::io::ios_base_all_saver io_saver_type;
  36
  37 #include <boost/test/detail/suppress_warnings.hpp>
  38
  39 //____________________________________________________________________________//
  40
  41 namespace boost {
  42 namespace unit_test {
  43
  44 // ************************************************************************** //
  45 // **************             entry_value_collector            ************** //
  46 // ************************************************************************** //
  47
  48 namespace ut_detail {
  49
  50 entry_value_collector const&
  51 entry_value_collector::operator<<( lazy_ostream const& v ) const
  52 {
  53     unit_test_log << v;
  54
  55     return *this;
  56 }
  57
  58 //____________________________________________________________________________//
  59
  60 entry_value_collector const&
  61 entry_value_collector::operator<<( const_string v ) const
  62 {
  63     unit_test_log << v;
  64
  65     return *this;
  66 }
  67
  68 //____________________________________________________________________________//
  69
  70 entry_value_collector::~entry_value_collector()
  71 {
  72     if( m_last )
  73         unit_test_log << log::end();
  74 }
  75
  76 //____________________________________________________________________________//
  77
  78 } // namespace ut_detail
  79
  80 // ************************************************************************** //
  81 // **************                 unit_test_log                ************** //
  82 // ************************************************************************** //
  83
  84 namespace {
  85
  86 // log data
  87 struct unit_test_log_data_helper_impl {
  88   typedef boost::shared_ptr<unit_test_log_formatter> formatter_ptr;
  89   typedef boost::shared_ptr<io_saver_type>           saver_ptr;
  90
  91   bool                m_enabled;
  92   output_format       m_format;
  93   std::ostream*       m_stream;
  94   saver_ptr           m_stream_state_saver;
  95   formatter_ptr       m_log_formatter;
  96   bool                m_entry_in_progress;
  97
  98   unit_test_log_data_helper_impl(unit_test_log_formatter* p_log_formatter, output_format format, bool enabled = false)
  99     : m_enabled( enabled )
 100     , m_format( format )
 101     , m_stream( &std::cout )
 102     , m_stream_state_saver( new io_saver_type( std::cout ) )
 103     , m_log_formatter()
 104     , m_entry_in_progress( false )
 105   {
 106     m_log_formatter.reset(p_log_formatter);
 107     m_log_formatter->set_log_level(log_all_errors);
 108   }
 109
 110   // helper functions
 111   std::ostream&       stream()
 112   {
 113       return *m_stream;
 114   }
 115
 116   log_level get_log_level() const
 117   {
 118       return m_log_formatter->get_log_level();
 119   }
 120 };
 121
 122 struct unit_test_log_impl {
 123     // Constructor
 124     unit_test_log_impl()
 125     {
 126       m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::compiler_log_formatter, OF_CLF, true) ); // only this one is active by default,
 127       m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::xml_log_formatter, OF_XML, false) );
 128       m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::junit_log_formatter, OF_JUNIT, false) );
 129     }
 130
 131     typedef std::vector<unit_test_log_data_helper_impl> v_formatter_data_t;
 132     v_formatter_data_t m_log_formatter_data;
 133
 134     // entry data
 135     log_entry_data      m_entry_data;
 136
 137     bool has_entry_in_progress() const {
 138         BOOST_TEST_FOREACH( unit_test_log_data_helper_impl const&, current_logger_data, m_log_formatter_data ) {
 139             if( current_logger_data.m_entry_in_progress )
 140                 return true;
 141         }
 142         return false;
 143     }
 144
 145     // check point data
 146     log_checkpoint_data m_checkpoint_data;
 147
 148     void                set_checkpoint( const_string file, std::size_t line_num, const_string msg )
 149     {
 150         assign_op( m_checkpoint_data.m_message, msg, 0 );
 151         m_checkpoint_data.m_file_name   = file;
 152         m_checkpoint_data.m_line_num    = line_num;
 153     }
 154 };
 155
 156 unit_test_log_impl& s_log_impl() { static unit_test_log_impl the_inst; return the_inst; }
 157
 158 } // local namespace
 159
 160 //____________________________________________________________________________//
 161
 162 BOOST_TEST_SINGLETON_CONS_IMPL( unit_test_log_t )
 163
 164 //____________________________________________________________________________//
 165
 166 void
 167 unit_test_log_t::test_start( counter_t test_cases_amount )
 168 {
 169     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 170       if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
 171           continue;
 172
 173       current_logger_data.m_log_formatter->log_start( current_logger_data.stream(), test_cases_amount );
 174
 175       current_logger_data.m_log_formatter->log_build_info(
 176           current_logger_data.stream(),
 177           runtime_config::get<bool>( runtime_config::btrt_build_info ));
 178
 179       //current_logger_data.stream().flush();
 180
 181       current_logger_data.m_entry_in_progress = false;
 182     }
 183 }
 184
 185 //____________________________________________________________________________//
 186
 187 void
 188 unit_test_log_t::test_finish()
 189 {
 190     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 191       if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
 192           continue;
 193
 194       current_logger_data.m_log_formatter->log_finish( current_logger_data.stream() );
 195
 196       current_logger_data.stream().flush();
 197     }
 198 }
 199
 200 //____________________________________________________________________________//
 201
 202 void
 203 unit_test_log_t::test_aborted()
 204 {
 205     BOOST_TEST_LOG_ENTRY( log_messages ) << "Test is aborted";
 206 }
 207
 208 //____________________________________________________________________________//
 209
 210 void
 211 unit_test_log_t::test_unit_start( test_unit const& tu )
 212 {
 213     if( s_log_impl().has_entry_in_progress() )
 214         *this << log::end();
 215     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 216         if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
 217             continue;
 218         current_logger_data.m_log_formatter->test_unit_start( current_logger_data.stream(), tu );
 219     }
 220 }
 221
 222 //____________________________________________________________________________//
 223
 224 void
 225 unit_test_log_t::test_unit_finish( test_unit const& tu, unsigned long elapsed )
 226 {
 227     s_log_impl().m_checkpoint_data.clear();
 228
 229     if( s_log_impl().has_entry_in_progress() )
 230         *this << log::end();
 231
 232     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 233
 234         if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
 235             continue;
 236
 237         current_logger_data.m_log_formatter->test_unit_finish( current_logger_data.stream(), tu, elapsed );
 238     }
 239 }
 240
 241 //____________________________________________________________________________//
 242
 243 void
 244 unit_test_log_t::test_unit_skipped( test_unit const& tu, const_string reason )
 245 {
 246     if( s_log_impl().has_entry_in_progress() )
 247         *this << log::end();
 248
 249     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 250         if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
 251             continue;
 252
 253         current_logger_data.m_log_formatter->test_unit_skipped( current_logger_data.stream(), tu, reason );
 254     }
 255 }
 256
 257 void
 258 unit_test_log_t::test_unit_aborted( test_unit const& tu )
 259 {
 260     if( s_log_impl().has_entry_in_progress() )
 261         *this << log::end();
 262
 263     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 264         if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
 265             continue;
 266
 267         current_logger_data.m_log_formatter->test_unit_aborted(current_logger_data.stream(), tu );
 268     }
 269 }
 270
 271 void
 272 unit_test_log_t::test_unit_timed_out( test_unit const& tu )
 273 {
 274     if( s_log_impl().has_entry_in_progress() )
 275         *this << log::end();
 276
 277     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 278         if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
 279             continue;
 280
 281         current_logger_data.m_log_formatter->test_unit_timed_out(current_logger_data.stream(), tu );
 282     }
 283 }
 284
 285 //____________________________________________________________________________//
 286
 287 void
 288 unit_test_log_t::exception_caught( execution_exception const& ex )
 289 {
 290     log_level l =
 291         ex.code() <= execution_exception::cpp_exception_error   ? log_cpp_exception_errors :
 292         (ex.code() <= execution_exception::timeout_error        ? log_system_errors
 293                                                                 : log_fatal_errors );
 294
 295     if( s_log_impl().has_entry_in_progress() )
 296         *this << log::end();
 297
 298     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 299
 300       if( current_logger_data.m_enabled && l >= current_logger_data.get_log_level() ) {
 301
 302           current_logger_data.m_log_formatter->log_exception_start( current_logger_data.stream(), s_log_impl().m_checkpoint_data, ex );
 303
 304           log_entry_context( l );
 305
 306           current_logger_data.m_log_formatter->log_exception_finish( current_logger_data.stream() );
 307       }
 308     }
 309     clear_entry_context();
 310 }
 311
 312 //____________________________________________________________________________//
 313
 314 void
 315 unit_test_log_t::set_checkpoint( const_string file, std::size_t line_num, const_string msg )
 316 {
 317     s_log_impl().set_checkpoint( file, line_num, msg );
 318 }
 319
 320 //____________________________________________________________________________//
 321
 322 char
 323 set_unix_slash( char in )
 324 {
 325     return in == '\\' ? '/' : in;
 326 }
 327
 328 unit_test_log_t&
 329 unit_test_log_t::operator<<( log::begin const& b )
 330 {
 331     if( s_log_impl().has_entry_in_progress() )
 332         *this << log::end();
 333
 334     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 335         if( current_logger_data.m_enabled ) {
 336             current_logger_data.m_stream_state_saver->restore();
 337         }
 338     }
 339
 340     s_log_impl().m_entry_data.clear();
 341
 342     assign_op( s_log_impl().m_entry_data.m_file_name, b.m_file_name, 0 );
 343
 344     // normalize file name
 345     std::transform( s_log_impl().m_entry_data.m_file_name.begin(), s_log_impl().m_entry_data.m_file_name.end(),
 346                     s_log_impl().m_entry_data.m_file_name.begin(),
 347                     &set_unix_slash );
 348
 349     s_log_impl().m_entry_data.m_line_num = b.m_line_num;
 350
 351     return *this;
 352 }
 353
 354 //____________________________________________________________________________//
 355
 356 unit_test_log_t&
 357 unit_test_log_t::operator<<( log::end const& )
 358 {
 359     if( s_log_impl().has_entry_in_progress() ) {
 360         log_entry_context( s_log_impl().m_entry_data.m_level );
 361
 362         BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 363             if( current_logger_data.m_enabled && current_logger_data.m_entry_in_progress ) {
 364                 current_logger_data.m_log_formatter->log_entry_finish( current_logger_data.stream() );
 365             }
 366             current_logger_data.m_entry_in_progress = false;
 367         }
 368     }
 369
 370     clear_entry_context();
 371
 372     return *this;
 373 }
 374
 375 //____________________________________________________________________________//
 376
 377 unit_test_log_t&
 378 unit_test_log_t::operator<<( log_level l )
 379 {
 380     s_log_impl().m_entry_data.m_level = l;
 381
 382     return *this;
 383 }
 384
 385 //____________________________________________________________________________//
 386
 387 ut_detail::entry_value_collector
 388 unit_test_log_t::operator()( log_level l )
 389 {
 390     *this << l;
 391
 392     return ut_detail::entry_value_collector();
 393 }
 394
 395 //____________________________________________________________________________//
 396
 397 bool
 398 unit_test_log_t::log_entry_start(output_format log_format)
 399 {
 400     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 401
 402         if( current_logger_data.m_format != log_format )
 403             continue;
 404
 405         if( current_logger_data.m_entry_in_progress )
 406             return true;
 407
 408         if( !current_logger_data.m_enabled )
 409             return false;
 410
 411         switch( s_log_impl().m_entry_data.m_level ) {
 412         case log_successful_tests:
 413             current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
 414                                                   unit_test_log_formatter::BOOST_UTL_ET_INFO );
 415             break;
 416         case log_messages:
 417             current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
 418                                                   unit_test_log_formatter::BOOST_UTL_ET_MESSAGE );
 419             break;
 420         case log_warnings:
 421             current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
 422                                                   unit_test_log_formatter::BOOST_UTL_ET_WARNING );
 423             break;
 424         case log_all_errors:
 425         case log_cpp_exception_errors:
 426         case log_system_errors:
 427             current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
 428                                                   unit_test_log_formatter::BOOST_UTL_ET_ERROR );
 429             break;
 430         case log_fatal_errors:
 431             current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
 432                                                   unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR );
 433             break;
 434         case log_nothing:
 435         case log_test_units:
 436         case invalid_log_level:
 437             return false;
 438         }
 439
 440         current_logger_data.m_entry_in_progress = true;
 441         return true;
 442     }
 443
 444     return false;
 445 }
 446
 447 //____________________________________________________________________________//
 448
 449 unit_test_log_t&
 450 unit_test_log_t::operator<<( const_string value )
 451 {
 452     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 453         if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() && log_entry_start(current_logger_data.m_format) )
 454             current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
 455
 456     }
 457     return *this;
 458 }
 459
 460 //____________________________________________________________________________//
 461
 462 unit_test_log_t&
 463 unit_test_log_t::operator<<( lazy_ostream const& value )
 464 {
 465     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 466         if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() ) {
 467             if( log_entry_start(current_logger_data.m_format) ) {
 468                 current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
 469             }
 470         }
 471     }
 472     return *this;
 473 }
 474
 475 //____________________________________________________________________________//
 476
 477 void
 478 unit_test_log_t::log_entry_context( log_level l )
 479 {
 480     framework::context_generator const& context = framework::get_context();
 481     if( context.is_empty() )
 482         return;
 483
 484     const_string frame;
 485
 486     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 487         if( current_logger_data.m_enabled ) {
 488             current_logger_data.m_log_formatter->entry_context_start( current_logger_data.stream(), l );
 489         }
 490     }
 491
 492     while( !(frame=context.next()).is_empty() )
 493     {
 494         BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 495             if( current_logger_data.m_enabled ) {
 496                 current_logger_data.m_log_formatter->log_entry_context( current_logger_data.stream(), l, frame );
 497             }
 498         }
 499     }
 500
 501     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 502         if( current_logger_data.m_enabled ) {
 503             current_logger_data.m_log_formatter->entry_context_finish( current_logger_data.stream(), l );
 504         }
 505     }
 506 }
 507
 508 //____________________________________________________________________________//
 509
 510 void
 511 unit_test_log_t::clear_entry_context()
 512 {
 513     framework::clear_context();
 514 }
 515
 516 //____________________________________________________________________________//
 517
 518 void
 519 unit_test_log_t::set_stream( std::ostream& str )
 520 {
 521     if( s_log_impl().has_entry_in_progress() )
 522         return;
 523
 524     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 525         current_logger_data.m_stream = &str;
 526         current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
 527     }
 528 }
 529
 530 //____________________________________________________________________________//
 531
 532 void
 533 unit_test_log_t::set_stream( output_format log_format, std::ostream& str )
 534 {
 535     if( s_log_impl().has_entry_in_progress() )
 536         return;
 537
 538     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 539         if( current_logger_data.m_format == log_format) {
 540             current_logger_data.m_stream = &str;
 541             current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
 542             break;
 543         }
 544     }
 545 }
 546
 547 std::ostream*
 548 unit_test_log_t::get_stream( output_format log_format ) const
 549 {
 550     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 551         if( current_logger_data.m_format == log_format) {
 552             return current_logger_data.m_stream;
 553         }
 554     }
 555     return 0;
 556 }
 557
 558 //____________________________________________________________________________//
 559
 560 void
 561 unit_test_log_t::set_threshold_level( log_level lev )
 562 {
 563     if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
 564         return;
 565
 566     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 567         current_logger_data.m_log_formatter->set_log_level( lev );
 568     }
 569 }
 570
 571 //____________________________________________________________________________//
 572
 573 void
 574 unit_test_log_t::set_threshold_level( output_format log_format, log_level lev )
 575 {
 576     if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
 577         return;
 578
 579     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 580         if( current_logger_data.m_format == log_format) {
 581             current_logger_data.m_log_formatter->set_log_level( lev );
 582             break;
 583         }
 584     }
 585 }
 586
 587 //____________________________________________________________________________//
 588
 589 void
 590 unit_test_log_t::set_format( output_format log_format )
 591 {
 592     if( s_log_impl().has_entry_in_progress() )
 593         return;
 594
 595     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 596         current_logger_data.m_enabled = current_logger_data.m_format == log_format;
 597     }
 598 }
 599
 600 //____________________________________________________________________________//
 601
 602 void
 603 unit_test_log_t::add_format( output_format log_format )
 604 {
 605     if( s_log_impl().has_entry_in_progress() )
 606         return;
 607
 608     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 609         if( current_logger_data.m_format == log_format) {
 610             current_logger_data.m_enabled = true;
 611             break;
 612         }
 613     }
 614 }
 615
 616 //____________________________________________________________________________//
 617
 618 unit_test_log_formatter*
 619 unit_test_log_t::get_formatter( output_format log_format ) {
 620     BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
 621         if( current_logger_data.m_format == log_format) {
 622             return current_logger_data.m_log_formatter.get();
 623         }
 624     }
 625     return 0;
 626 }
 627
 628
 629 void
 630 unit_test_log_t::add_formatter( unit_test_log_formatter* the_formatter )
 631 {
 632     // remove only user defined logger
 633     for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
 634             ite(s_log_impl().m_log_formatter_data.end());
 635         it != ite;
 636         ++it)
 637     {
 638         if( it->m_format == OF_CUSTOM_LOGGER) {
 639             s_log_impl().m_log_formatter_data.erase(it);
 640             break;
 641         }
 642     }
 643
 644     if( the_formatter ) {
 645         s_log_impl().m_log_formatter_data.push_back( unit_test_log_data_helper_impl(the_formatter, OF_CUSTOM_LOGGER, true) );
 646     }
 647 }
 648
 649 void
 650 unit_test_log_t::set_formatter( unit_test_log_formatter* the_formatter )
 651 {
 652     // remove only user defined logger
 653     log_level current_level = invalid_log_level;
 654     std::ostream *current_stream = 0;
 655     output_format previous_format = OF_INVALID;
 656     for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
 657             ite(s_log_impl().m_log_formatter_data.end());
 658         it != ite;
 659         ++it)
 660     {
 661         if( it->m_enabled ) {
 662             if( current_level == invalid_log_level || it->m_format < previous_format || it->m_format == OF_CUSTOM_LOGGER) {
 663                 current_level = it->get_log_level();
 664                 current_stream = &(it->stream());
 665                 previous_format = it->m_format;
 666             }
 667         }
 668     }
 669
 670     if( the_formatter ) {
 671         add_formatter(the_formatter);
 672         set_format(OF_CUSTOM_LOGGER);
 673         set_threshold_level(OF_CUSTOM_LOGGER, current_level);
 674         set_stream(OF_CUSTOM_LOGGER, *current_stream);
 675     }
 676 }
 677
 678 //____________________________________________________________________________//
 679
 680 // ************************************************************************** //
 681 // **************            unit_test_log_formatter           ************** //
 682 // ************************************************************************** //
 683
 684 void
 685 unit_test_log_formatter::log_entry_value( std::ostream& ostr, lazy_ostream const& value )
 686 {
 687     log_entry_value( ostr, (wrap_stringstream().ref() << value).str() );
 688 }
 689
 690 void
 691 unit_test_log_formatter::set_log_level(log_level new_log_level)
 692 {
 693     m_log_level = new_log_level;
 694 }
 695
 696 log_level
 697 unit_test_log_formatter::get_log_level() const
 698 {
 699     return m_log_level;
 700 }
 701
 702 //____________________________________________________________________________//
 703
 704 } // namespace unit_test
 705 } // namespace boost
 706
 707 #include <boost/test/detail/enable_warnings.hpp>
 708
 709 #endif // BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
 710