1 // (C) Copyright Gennadiy Rozental 2001-2015.
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 : tests all Test Tools but output_test_stream
13 // ***************************************************************************
14
15 // Boost.Test
16 #define BOOST_TEST_MAIN
17 #include <boost/test/unit_test.hpp>
18 #include <boost/test/unit_test_log.hpp>
19 #include <boost/test/tools/output_test_stream.hpp>
20 #include <boost/test/execution_monitor.hpp>
21 #include <boost/test/unit_test_parameters.hpp>
22 #include <boost/test/output/compiler_log_formatter.hpp>
23 #include <boost/test/framework.hpp>
24 #include <boost/core/noncopyable.hpp>
25 #include <boost/test/detail/suppress_warnings.hpp>
26
27 // Boost
28 #include <boost/bind.hpp>
29 #include <boost/noncopyable.hpp>
30
31 // STL
32 #include <iostream>
33 #include <iomanip>
34
35 #ifdef BOOST_MSVC
36 # pragma warning(push)
37 # pragma warning(disable: 4702) // unreachable code
38 #endif
39
40 namespace ut=boost::unit_test;
41 namespace tt=boost::test_tools;
42
43 //____________________________________________________________________________//
44
45 #define CHECK_CRITICAL_TOOL_USAGE( tool_usage ) \
46 { \
47 bool throw_ = false; \
48 try { \
49 tool_usage; \
50 } catch( boost::execution_aborted const& ) { \
51 throw_ = true; \
52 } \
53 \
54 BOOST_CHECK_MESSAGE( throw_, "not aborted" ); \
55 } \
56 /**/
57
58 //____________________________________________________________________________//
59
60 // thanks to http://stackoverflow.com/questions/9226400/portable-printing-of-exponent-of-a-double-to-c-iostreams
61 #if defined(BOOST_MSVC) && (BOOST_MSVC < 1900)
62 struct ScientificNotationExponentOutputNormalizer {
ScientificNotationExponentOutputNormalizerScientificNotationExponentOutputNormalizer63 ScientificNotationExponentOutputNormalizer() : m_old_format(_set_output_format(_TWO_DIGIT_EXPONENT)) {}
64
~ScientificNotationExponentOutputNormalizerScientificNotationExponentOutputNormalizer65 ~ScientificNotationExponentOutputNormalizer() { _set_output_format(m_old_format); }
66 private:
67 unsigned m_old_format;
68 };
69 #else
70 struct ScientificNotationExponentOutputNormalizer {};
71 #endif
72
73 //____________________________________________________________________________//
74
75 class bool_convertible
76 {
77 struct Tester {};
78 public:
operator Tester*() const79 operator Tester*() const { return static_cast<Tester*>( 0 ) + 1; }
80 };
81
82 //____________________________________________________________________________//
83
84 struct shorten_lf : public boost::unit_test::output::compiler_log_formatter
85 {
print_prefixshorten_lf86 void print_prefix( std::ostream& output, boost::unit_test::const_string, std::size_t line )
87 {
88 }
89 };
90
91 //____________________________________________________________________________//
92
93 std::string match_file_name( "./baseline-outputs/test_tools-test.pattern" );
94 std::string save_file_name( "test_tools-test.pattern" );
95
96 static tt::output_test_stream&
ots()97 ots()
98 {
99 static boost::shared_ptr<tt::output_test_stream> inst;
100
101 if( !inst ) {
102 inst.reset(
103 ut::framework::master_test_suite().argc <= 1
104 ? new tt::output_test_stream( ut::runtime_config::save_pattern() ? save_file_name : match_file_name, !ut::runtime_config::save_pattern() )
105 : new tt::output_test_stream( ut::framework::master_test_suite().argv[1], !ut::runtime_config::save_pattern() ) );
106 }
107
108 return *inst;
109 }
110
111 //____________________________________________________________________________//
112
113 #define TEST_CASE( name ) \
114 static void name ## _impl(); \
115 static void name ## _impl_defer(); \
116 \
117 BOOST_AUTO_TEST_CASE( name ) \
118 { \
119 ut::test_case* impl = ut::make_test_case(&name ## _impl, \
120 #name, \
121 __FILE__, \
122 __LINE__ ); \
123 impl->p_default_status.value = ut::test_unit::RS_ENABLED; \
124 \
125 ut::unit_test_log.set_stream( ots() ); \
126 ut::unit_test_log.set_threshold_level( ut::log_nothing ); \
127 ut::unit_test_log.set_formatter( new shorten_lf ); \
128 ut::framework::finalize_setup_phase( impl->p_id ); \
129 ut::framework::run( impl ); \
130 \
131 ut::log_level ll = ut::runtime_config::get<ut::log_level>( \
132 ut::runtime_config::btrt_log_level ); \
133 ut::output_format lf = ut::runtime_config::get<ut::output_format>( \
134 ut::runtime_config::btrt_log_format ); \
135 \
136 ut::unit_test_log.set_threshold_level( \
137 ll != ut::invalid_log_level ? ll : ut::log_all_errors ); \
138 ut::unit_test_log.set_format( lf ); \
139 ut::unit_test_log.set_stream( std::cout ); \
140 BOOST_CHECK( ots().match_pattern() ); \
141 } \
142 \
143 void name ## _impl() \
144 { \
145 ut::unit_test_log.set_threshold_level( ut::log_all_errors ); \
146 \
147 name ## _impl_defer(); \
148 \
149 ut::unit_test_log.set_threshold_level( ut::log_nothing ); \
150 } \
151 \
152 void name ## _impl_defer() \
153 /**/
154
155 //____________________________________________________________________________//
156
TEST_CASE(test_BOOST_WARN)157 TEST_CASE( test_BOOST_WARN )
158 {
159 ut::unit_test_log.set_threshold_level( ut::log_warnings );
160 BOOST_WARN( sizeof(int) == sizeof(short) );
161
162 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
163 BOOST_WARN( sizeof(unsigned char) == sizeof(char) );
164 }
165
166 //____________________________________________________________________________//
167
TEST_CASE(test_BOOST_CHECK)168 TEST_CASE( test_BOOST_CHECK )
169 {
170 // check correct behavior in if clause
171 if( true )
172 BOOST_CHECK( true );
173
174 // check correct behavior in else clause
175 if( false )
176 {}
177 else
178 BOOST_CHECK( true );
179
180 bool_convertible bc;
181 BOOST_CHECK( bc );
182
183 int i=2;
184
185 BOOST_CHECK( false );
186 BOOST_CHECK( 1==2 );
187 BOOST_CHECK( i==1 );
188
189 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
190 BOOST_CHECK( i==2 );
191 }
192
193 //____________________________________________________________________________//
194
TEST_CASE(test_BOOST_REQUIRE)195 TEST_CASE( test_BOOST_REQUIRE )
196 {
197 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE( true ) );
198
199 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE( false ) );
200
201 int j = 3;
202
203 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE( j > 5 ) );
204
205 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
206 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE( j < 5 ) );
207 }
208
209 //____________________________________________________________________________//
210
TEST_CASE(test_BOOST_WARN_MESSAGE)211 TEST_CASE( test_BOOST_WARN_MESSAGE )
212 {
213 BOOST_WARN_MESSAGE( sizeof(int) == sizeof(short), "memory won't be used efficiently" );
214 int obj_size = 33;
215
216 BOOST_WARN_MESSAGE( obj_size <= 8,
217 "object size " << obj_size << " is too big to be efficiently passed by value" );
218
219 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
220 BOOST_WARN_MESSAGE( obj_size > 8, "object size " << obj_size << " is too small" );
221 }
222
223 //____________________________________________________________________________//
224
225 boost::test_tools::predicate_result
test_pred1()226 test_pred1()
227 {
228 boost::test_tools::predicate_result res( false );
229
230 res.message() << "Some explanation";
231
232 return res;
233 }
234
TEST_CASE(test_BOOST_CHECK_MESSAGE)235 TEST_CASE( test_BOOST_CHECK_MESSAGE )
236 {
237 BOOST_CHECK_MESSAGE( 2+2 == 5, "Well, may be that what I believe in" );
238
239 BOOST_CHECK_MESSAGE( test_pred1(), "Checking predicate failed" );
240
241 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
242 BOOST_CHECK_MESSAGE( 2+2 == 4, "Could it fail?" );
243
244 int i = 1;
245 int j = 2;
246 std::string msg = "some explanation";
247 BOOST_CHECK_MESSAGE( i > j, "Comparing " << i << " and " << j << ": " << msg );
248 }
249
250 //____________________________________________________________________________//
251
TEST_CASE(test_BOOST_REQUIRE_MESSAGE)252 TEST_CASE( test_BOOST_REQUIRE_MESSAGE )
253 {
254 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_MESSAGE( false, "Here we should stop" ) );
255
256 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
257 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_MESSAGE( true, "That's OK" ) );
258 }
259
260 //____________________________________________________________________________//
261
TEST_CASE(test_BOOST_ERROR)262 TEST_CASE( test_BOOST_ERROR )
263 {
264 BOOST_ERROR( "Fail to miss an error" );
265 }
266
267 //____________________________________________________________________________//
268
TEST_CASE(test_BOOST_FAIL)269 TEST_CASE( test_BOOST_FAIL )
270 {
271 CHECK_CRITICAL_TOOL_USAGE( BOOST_FAIL( "No! No! Show must go on." ) );
272 }
273
274 //____________________________________________________________________________//
275
276 struct my_exception {
my_exceptionmy_exception277 explicit my_exception( int ec = 0 ) : m_error_code( ec ) {}
278
279 int m_error_code;
280 };
281
is_critical(my_exception const & ex)282 bool is_critical( my_exception const& ex ) { return ex.m_error_code < 0; }
283
TEST_CASE(test_BOOST_CHECK_THROW)284 TEST_CASE( test_BOOST_CHECK_THROW )
285 {
286 int i=0;
287 BOOST_CHECK_THROW( i++, my_exception );
288
289 ut::unit_test_log.set_threshold_level( ut::log_warnings );
290 BOOST_WARN_THROW( i++, my_exception );
291
292 ut::unit_test_log.set_threshold_level( ut::log_all_errors );
293 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_THROW( i++, my_exception ) );
294
295 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
296 if( i/10 > 10 )
297 {}
298 else
299 BOOST_CHECK_THROW( throw my_exception(), my_exception ); // unreachable code warning is expected
300 }
301
302 //____________________________________________________________________________//
303
TEST_CASE(test_BOOST_CHECK_EXCEPTION)304 TEST_CASE( test_BOOST_CHECK_EXCEPTION )
305 {
306 BOOST_CHECK_EXCEPTION( throw my_exception( 1 ), my_exception, is_critical ); // unreachable code warning is expected
307
308 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
309 BOOST_CHECK_EXCEPTION( throw my_exception( -1 ), my_exception, is_critical ); // unreachable code warning is expected
310 }
311
312 //____________________________________________________________________________//
313
TEST_CASE(test_BOOST_CHECK_NO_THROW)314 TEST_CASE( test_BOOST_CHECK_NO_THROW )
315 {
316 int i=0;
317 if( i*10 == 0 )
318 BOOST_CHECK_NO_THROW( i++ );
319 else {}
320
321 BOOST_CHECK_NO_THROW( throw my_exception() ); // unreachable code warning is expected
322 }
323
324 //____________________________________________________________________________//
325
326 struct B {
BB327 B( int i ) : m_i( i ) {}
328
329 int m_i;
330 };
331
operator ==(B const & b1,B const & b2)332 bool operator==( B const& b1, B const& b2 ) { return b1.m_i == b2.m_i; }
operator <<(std::ostream & str,B const & b)333 std::ostream& operator<<( std::ostream& str, B const& b ) { return str << "B(" << b.m_i << ")"; }
334
335 //____________________________________________________________________________//
336
337 struct C {
CC338 C( int i, int id ) : m_i( i ), m_id( id ) {}
339
340 int m_i;
341 int m_id;
342 };
343
344 boost::test_tools::predicate_result
operator ==(C const & c1,C const & c2)345 operator==( C const& c1, C const& c2 )
346 {
347 boost::test_tools::predicate_result res( c1.m_i == c2.m_i && c1.m_id == c2.m_id );
348
349 if( !res ) {
350 if( c1.m_i != c2.m_i )
351 res.message() << "Index mismatch";
352 else
353 res.message() << "Id mismatch";
354 }
355
356 return res;
357 }
358
operator <<(std::ostream & str,C const & c)359 std::ostream& operator<<( std::ostream& str, C const& c ) { return str << "C(" << c.m_i << ',' << c.m_id << ")"; }
360
361 //____________________________________________________________________________//
362
TEST_CASE(test_BOOST_CHECK_EQUAL)363 TEST_CASE( test_BOOST_CHECK_EQUAL )
364 {
365 int i=1;
366 int j=2;
367 BOOST_CHECK_EQUAL( i, j );
368 BOOST_CHECK_EQUAL( ++i, j );
369 BOOST_CHECK_EQUAL( i++, j );
370
371 char const* str1 = "test1";
372 char const* str2 = "test12";
373 BOOST_CHECK_EQUAL( str1, str2 );
374
375 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
376 BOOST_CHECK_EQUAL( i+1, j );
377
378 char const* str3 = "1test1";
379 BOOST_CHECK_EQUAL( str1, str3+1 );
380
381 ut::unit_test_log.set_threshold_level( ut::log_all_errors );
382 str1 = NULL;
383 str2 = NULL;
384 BOOST_CHECK_EQUAL( str1, str2 );
385
386 str1 = "test";
387 str2 = NULL;
388 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_EQUAL( str1, str2 ) );
389
390 B b1(1);
391 B b2(2);
392
393 ut::unit_test_log.set_threshold_level( ut::log_warnings );
394 BOOST_WARN_EQUAL( b1, b2 );
395
396 ut::unit_test_log.set_threshold_level( ( ut::log_all_errors ) );
397 C c1( 0, 100 );
398 C c2( 0, 101 );
399 C c3( 1, 102 );
400 BOOST_CHECK_EQUAL( c1, c3 );
401 BOOST_CHECK_EQUAL( c1, c2 );
402
403 char ch1 = -2;
404 char ch2 = -3;
405 BOOST_CHECK_EQUAL(ch1, ch2);
406 }
407
408 //____________________________________________________________________________//
409
TEST_CASE(test_BOOST_CHECK_LOGICAL_EXPR)410 TEST_CASE( test_BOOST_CHECK_LOGICAL_EXPR )
411 {
412 int i=1;
413 int j=2;
414 BOOST_CHECK_NE( i, j );
415
416 BOOST_CHECK_NE( ++i, j );
417
418 BOOST_CHECK_LT( i, j );
419 BOOST_CHECK_GT( i, j );
420
421 BOOST_CHECK_LE( i, j );
422 BOOST_CHECK_GE( i, j );
423
424 ++i;
425
426 BOOST_CHECK_LE( i, j );
427 BOOST_CHECK_GE( j, i );
428
429 char const* str1 = "test1";
430 char const* str2 = "test1";
431
432 BOOST_CHECK_NE( str1, str2 );
433 }
434
435 //____________________________________________________________________________//
436
is_even(int i)437 bool is_even( int i ) { return i%2 == 0; }
foo(int arg,int mod)438 int foo( int arg, int mod ) { return arg % mod; }
moo(int arg1,int arg2,int mod)439 bool moo( int arg1, int arg2, int mod ) { return ((arg1+arg2) % mod) == 0; }
440
BOOST_TEST_DONT_PRINT_LOG_VALUE(std::list<int>)441 BOOST_TEST_DONT_PRINT_LOG_VALUE( std::list<int> )
442
443 boost::test_tools::assertion_result
444 compare_lists( std::list<int> const& l1, std::list<int> const& l2 )
445 {
446 if( l1.size() != l2.size() ) {
447 boost::test_tools::predicate_result res( false );
448
449 res.message() << "Different sizes [" << l1.size() << "!=" << l2.size() << "]";
450
451 return res;
452 }
453
454 return true;
455 }
456
TEST_CASE(test_BOOST_CHECK_PREDICATE)457 TEST_CASE( test_BOOST_CHECK_PREDICATE )
458 {
459 BOOST_CHECK_PREDICATE( is_even, (14) );
460
461 int i = 17;
462 BOOST_CHECK_PREDICATE( is_even, (i) );
463
464 using std::not_equal_to;
465 BOOST_CHECK_PREDICATE( not_equal_to<int>(), (i)(17) );
466
467 int j=15;
468 BOOST_CHECK_PREDICATE( boost::bind( is_even, boost::bind( &foo, _1, _2 ) ), (i)(j) );
469
470 ut::unit_test_log.set_threshold_level( ut::log_warnings );
471 BOOST_WARN_PREDICATE( moo, (12)(i)(j) );
472
473 ut::unit_test_log.set_threshold_level( ( ut::log_all_errors ) );
474 std::list<int> l1, l2, l3;
475 l1.push_back( 1 );
476 l3.push_back( 1 );
477 l1.push_back( 2 );
478 l3.push_back( 3 );
479 BOOST_CHECK_PREDICATE( compare_lists, (l1)(l2) );
480 }
481
482 //____________________________________________________________________________//
483
TEST_CASE(test_BOOST_REQUIRE_PREDICATE)484 TEST_CASE( test_BOOST_REQUIRE_PREDICATE )
485 {
486 int arg1 = 1;
487 int arg2 = 2;
488
489 using std::less_equal;
490 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_PREDICATE( less_equal<int>(), (arg1)(arg2) ) );
491
492 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_PREDICATE( less_equal<int>(), (arg2)(arg1) ) );
493 }
494
495 //____________________________________________________________________________//
496
TEST_CASE(test_BOOST_CHECK_EQUAL_COLLECTIONS)497 TEST_CASE( test_BOOST_CHECK_EQUAL_COLLECTIONS )
498 {
499 ut::unit_test_log.set_threshold_level( ( ut::log_all_errors ) );
500
501 int pattern [] = { 1, 2, 3, 4, 5, 6, 7 };
502
503 std::list<int> testlist;
504
505 testlist.push_back( 1 );
506 testlist.push_back( 2 );
507 testlist.push_back( 4 ); // 3
508 testlist.push_back( 4 );
509 testlist.push_back( 5 );
510 testlist.push_back( 7 ); // 6
511 testlist.push_back( 7 );
512
513 BOOST_CHECK_EQUAL_COLLECTIONS( testlist.begin(), testlist.end(), pattern, pattern+7 );
514 BOOST_CHECK_EQUAL_COLLECTIONS( testlist.begin(), testlist.end(), pattern, pattern+2 );
515 }
516
517 //____________________________________________________________________________//
518
TEST_CASE(test_BOOST_CHECK_BITWISE_EQUAL)519 TEST_CASE( test_BOOST_CHECK_BITWISE_EQUAL )
520 {
521 BOOST_CHECK_BITWISE_EQUAL( 0x16, 0x16 );
522
523 BOOST_CHECK_BITWISE_EQUAL( (char)0x06, (char)0x16 );
524
525 ut::unit_test_log.set_threshold_level( ut::log_warnings );
526 BOOST_WARN_BITWISE_EQUAL( (char)0x26, (char)0x04 );
527
528 ut::unit_test_log.set_threshold_level( ( ut::log_all_errors ) );
529 CHECK_CRITICAL_TOOL_USAGE( BOOST_REQUIRE_BITWISE_EQUAL( (char)0x26, (int)0x26 ) );
530 }
531
532 //____________________________________________________________________________//
533
534 struct A {
operator <<(std::ostream & str,A const &)535 friend std::ostream& operator<<( std::ostream& str, A const& ) { str << "struct A"; return str;}
536 };
537
TEST_CASE(test_BOOST_TEST_MESSAGE)538 TEST_CASE( test_BOOST_TEST_MESSAGE )
539 {
540 ut::unit_test_log.set_threshold_level( ut::log_messages );
541
542 BOOST_TEST_MESSAGE( "still testing" );
543 BOOST_TEST_MESSAGE( "1+1=" << 2 );
544
545 int i = 2;
546 BOOST_TEST_MESSAGE( i << "+" << i << "=" << (i+i) );
547
548 A a = A();
549 BOOST_TEST_MESSAGE( a );
550
551 #if BOOST_TEST_USE_STD_LOCALE
552 BOOST_TEST_MESSAGE( std::hex << std::showbase << 20 );
553 #else
554 BOOST_TEST_MESSAGE( "0x14" );
555 #endif
556
557 BOOST_TEST_MESSAGE( std::setw( 4 ) << 20 );
558 }
559
560 //____________________________________________________________________________//
561
TEST_CASE(test_BOOST_TEST_CHECKPOINT)562 TEST_CASE( test_BOOST_TEST_CHECKPOINT )
563 {
564 BOOST_TEST_CHECKPOINT( "Going to do a silly things" );
565
566 throw "some error";
567 }
568
569 //____________________________________________________________________________//
570
foo()571 bool foo() { throw 1; return true; }
572
TEST_CASE(test_BOOST_TEST_PASSPOINT)573 TEST_CASE( test_BOOST_TEST_PASSPOINT )
574 {
575 BOOST_CHECK( foo() );
576 }
577
578 //____________________________________________________________________________//
579
BOOST_AUTO_TEST_CASE(test_BOOST_IS_DEFINED)580 BOOST_AUTO_TEST_CASE( test_BOOST_IS_DEFINED )
581 {
582 #define SYMBOL1
583 #define SYMBOL2 std::cout
584 #define ONE_ARG( arg ) arg
585 #define TWO_ARG( arg1, arg2 ) BOOST_JOIN( arg1, arg2 )
586
587 BOOST_CHECK( BOOST_IS_DEFINED(SYMBOL1) );
588 BOOST_CHECK( BOOST_IS_DEFINED(SYMBOL2) );
589 BOOST_CHECK( !BOOST_IS_DEFINED( SYMBOL3 ) );
590 BOOST_CHECK( BOOST_IS_DEFINED( ONE_ARG(arg1) ) );
591 BOOST_CHECK( !BOOST_IS_DEFINED( ONE_ARG1(arg1) ) );
592 BOOST_CHECK( BOOST_IS_DEFINED( TWO_ARG(arg1,arg2) ) );
593 BOOST_CHECK( !BOOST_IS_DEFINED( TWO_ARG1(arg1,arg2) ) );
594 }
595
596 //____________________________________________________________________________//
597
TEST_CASE(test_context_logging)598 TEST_CASE( test_context_logging )
599 {
600 BOOST_TEST_INFO( "some context" );
601 BOOST_CHECK( false );
602
603 int i = 12;
604 BOOST_TEST_INFO( "some more context: " << i );
605 BOOST_CHECK( false );
606
607 BOOST_TEST_INFO( "info 1" );
608 BOOST_TEST_INFO( "info 2" );
609 BOOST_TEST_INFO( "info 3" );
610 BOOST_CHECK( false );
611
612 BOOST_TEST_CONTEXT( "some sticky context" ) {
613 BOOST_CHECK( false );
614
615 BOOST_TEST_INFO( "more context" );
616 BOOST_CHECK( false );
617
618 BOOST_TEST_INFO( "different subcontext" );
619 BOOST_CHECK( false );
620 }
621
622 BOOST_TEST_CONTEXT( "outer context" ) {
623 BOOST_CHECK( false );
624
625 BOOST_TEST_CONTEXT( "inner context" ) {
626 BOOST_CHECK( false );
627 }
628
629 BOOST_CHECK( false );
630 }
631 }
632
633 //____________________________________________________________________________//
634
635 class FooType {
636 public:
operator *()637 FooType& operator*() { return *this; }
operator bool() const638 operator bool() const { return false; }
operator &()639 int operator&() { return 10; }
640 };
641
TEST_CASE(test_BOOST_TEST_basic_arithmetic_op)642 TEST_CASE( test_BOOST_TEST_basic_arithmetic_op )
643 {
644 ut::unit_test_log.set_threshold_level( ut::log_successful_tests );
645
646 BOOST_TEST( true );
647 BOOST_TEST( false );
648
649 bool_convertible bc;
650 BOOST_TEST( bc );
651
652 int i = 1;
653
654 BOOST_TEST( i == 2 );
655 BOOST_TEST( i != 1 );
656 BOOST_TEST( i > 2 );
657 BOOST_TEST( i < 1 );
658 BOOST_TEST( i <= 0 );
659 BOOST_TEST( i >= 5 );
660
661 int j = 2;
662 BOOST_TEST( i+j >= 5 );
663 BOOST_TEST( j-i == 2 );
664
665 int* p = &i;
666 BOOST_TEST( *p == 2 );
667
668 BOOST_TEST( j-*p == 0 );
669
670 FooType F;
671
672 BOOST_TEST( FooType() );
673 BOOST_TEST( *F );
674 BOOST_TEST( **F );
675 BOOST_TEST( ***F );
676 BOOST_TEST( &F > 100 );
677 BOOST_TEST( &*F > 100 );
678
679 BOOST_TEST( (i == 1) & (j == 1) );
680 BOOST_TEST( (i == 2) | (j == 1) );
681
682 BOOST_TEST(( i == 1 && j == 1 ));
683 BOOST_TEST(( i == 2 || j == 1 ));
684
685 // check correct behavior in if clause
686 if( true )
687 BOOST_TEST( true );
688
689 // check correct behavior in else clause
690 if( false )
691 {}
692 else
693 BOOST_TEST( true );
694
695 BOOST_TEST( i+j==15, "This message reported instead including " << i << " and " << j );
696
697 // Does not work
698 // BOOST_TEST( i == 1 && j == 1 );
699 // BOOST_TEST( i == 2 || j == 1 );
700 // BOOST_TEST( i > 5 ? false : true );
701 }
702
703 BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(std::vector<int>)
704
TEST_CASE(test_BOOST_TEST_collection_comp)705 TEST_CASE( test_BOOST_TEST_collection_comp )
706 {
707 std::vector<int> v;
708 v.push_back( 1 );
709 v.push_back( 2 );
710 v.push_back( 3 );
711
712 std::vector<int> v2 = v;
713
714 std::vector<int> l;
715 l.push_back( 1 );
716 l.push_back( 3 );
717 l.push_back( 2 );
718
719 BOOST_TEST( v == l );
720 BOOST_TEST( v != v2 );
721 BOOST_TEST( v < l );
722 BOOST_TEST( v > l );
723
724 BOOST_TEST( v <= l );
725 BOOST_TEST( v >= l );
726 }
727
728 //____________________________________________________________________________//
729
730 namespace boost{ namespace test_tools{ namespace tt_detail{
731 template<>
732 struct print_log_value<double> {
operator ()boost::test_tools::tt_detail::print_log_value733 void operator()( std::ostream& os, double d )
734 {
735 std::streamsize curr_prec = os.precision();
736 os << std::setprecision(1) << d << std::setprecision( curr_prec );
737 }
738 };
739 }}}
740
TEST_CASE(test_BOOST_TEST_fpv_comp)741 TEST_CASE( test_BOOST_TEST_fpv_comp )
742 {
743 ScientificNotationExponentOutputNormalizer norm;
744 boost::ignore_unused( norm );
745
746 double d1 = 1.1e-5;
747 double d2 = 1.101e-5;
748 float f1 = 1.1e-5f;
749
750 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
751 BOOST_TEST( d1 == d2 );
752 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
753 BOOST_TEST( d1 == d2, tt::tolerance( 1e-7 ) );
754 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
755 BOOST_TEST( d1 != f1, tt::tolerance( 1e-7 ) );
756 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
757 BOOST_TEST( tt::fpc_tolerance<float>() == 0 );
758
759 BOOST_TEST( d1 > d2 );
760 BOOST_TEST( d1+1./1e20 > d2, 1e-5% tt::tolerance() );
761 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
762 BOOST_TEST( d2 <= d1, tt::tolerance( tt::fpc::percent_tolerance( 1e-5 ) ) );
763 BOOST_TEST( tt::fpc_tolerance<double>() == 0 );
764
765 BOOST_TEST( d1-1e-5 == 0., tt::tolerance( 1e-7 ) );
766 BOOST_TEST( d1-1e-5 != 0., tt::tolerance( 1e-4 ) );
767 BOOST_TEST( 0. != 1e-5-d1, tt::tolerance( 1e-4 ) );
768 BOOST_TEST( d2-1e-5 < 0., tt::tolerance( 1e-6 ) );
769
770 const double cd = 1.0;
771 BOOST_TEST( cd == 1.0);
772 BOOST_TEST( 1.0 == cd );
773 BOOST_TEST( cd == 1.01, 10.% tt::tolerance());
774 BOOST_TEST( 1.01 == cd, 0.1% tt::tolerance() );
775
776 BOOST_TEST( 0.0 == 0.0);
777 }
778
779 //____________________________________________________________________________//
780
TEST_CASE(test_BOOST_TEST_cstring_comp)781 TEST_CASE( test_BOOST_TEST_cstring_comp )
782 {
783 char const* str1 = "test1";
784 char const* str2 = "test12";
785 std::string str3 = "test2";
786 char str4[] = "test3";
787 char const* str5 = NULL;
788 char const* str6 = "1test1";
789
790 BOOST_TEST( str1 == str2 );
791 BOOST_TEST( str1 == str3 );
792 BOOST_TEST( str3 == str2 );
793 BOOST_TEST( str1 == str4 );
794 BOOST_TEST( str3 == str4 );
795 BOOST_TEST( str1 == str5 );
796
797 BOOST_TEST( str1 != (str6+1) );
798 BOOST_TEST( str5 != str5 );
799
800 BOOST_TEST( str3 < str1 );
801 BOOST_TEST( str1 >= str2 );
802 }
803
804 //____________________________________________________________________________//
805
TEST_CASE(string_comparison_per_element)806 TEST_CASE( string_comparison_per_element )
807 {
808 using namespace boost::test_tools;
809
810 std::string s1 = "asdfhjk";
811 std::string s2 = "asdfgjk";
812
813 BOOST_TEST( s1 == s2, tt::per_element() );
814
815 std::string s3 = "hello world";
816 std::string s4 = "helko worlt";
817
818 BOOST_TEST( s3 == s4, tt::per_element() );
819 }
820
821 //____________________________________________________________________________//
822
TEST_CASE(test_BOOST_TEST_bitwise)823 TEST_CASE( test_BOOST_TEST_bitwise )
824 {
825 int a = 0xAB;
826 int b = 0x88;
827 short c = 0x8A;
828 // decltype is needed for this to work. Not the case for eg. MSVC 2008.
829 BOOST_TEST( a == b, tt::bitwise() );
830 BOOST_TEST( c == b, tt::bitwise() );
831 }
832
833 //____________________________________________________________________________//
834
goo()835 int goo()
836 {
837 static int i = 0;
838 return i++;
839 }
840
841 struct copy_counter : boost::noncopyable {
842 static int s_value;
843
copy_countercopy_counter844 copy_counter() {}
copy_countercopy_counter845 copy_counter( copy_counter const& ) { s_value++; }
copy_countercopy_counter846 copy_counter( copy_counter&& ) {}
847 };
848
849 int copy_counter::s_value = 0;
850
operator ==(copy_counter const &,copy_counter const &)851 bool operator==( copy_counter const&, copy_counter const& ) { return true; }
operator <<(std::ostream & os,copy_counter const &)852 std::ostream& operator<<( std::ostream& os, copy_counter const& ) { return os << "copy_counter"; }
853
BOOST_AUTO_TEST_CASE(test_argument_handling)854 BOOST_AUTO_TEST_CASE( test_argument_handling )
855 {
856 BOOST_TEST( goo() == 0 );
857 BOOST_TEST( goo() == 1 );
858 BOOST_TEST( 2 == goo() );
859 BOOST_TEST( 3 == goo() );
860 BOOST_TEST( goo() != 5 );
861 BOOST_TEST( copy_counter() == copy_counter() );
862 BOOST_TEST( copy_counter::s_value == 0 );
863 }
864
865 //____________________________________________________________________________//
866
867 BOOST_AUTO_TEST_CASE( test_precision_mutation, * ut::expected_failures( 1 ) )
868 {
869 std::streamsize initial_precition = std::cout.precision();
870 std::cout.precision(initial_precition);
871
872 BOOST_TEST( 1.2 == 2.3, 10.% tt::tolerance() );
873
874 BOOST_TEST( initial_precition == std::cout.precision() );
875 }
876
877 //____________________________________________________________________________//
878
879 // addresses issue #11887
880 #if !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && \
881 !defined(BOOST_NO_CXX11_LAMBDAS) && \
882 !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
883 !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && \
884 !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
885
886 struct rv_erasure_test {
rv_erasure_testrv_erasure_test887 rv_erasure_test() : value( 1 ) {}
~rv_erasure_testrv_erasure_test888 ~rv_erasure_test() { value = 0; }
889
890 int value;
891 };
892
BOOST_AUTO_TEST_CASE(test_rvalue_erasure)893 BOOST_AUTO_TEST_CASE( test_rvalue_erasure )
894 {
895 auto erase_rv = []( rv_erasure_test const& arg ) -> rv_erasure_test const& { return arg; };
896
897 BOOST_TEST( 1 == erase_rv( rv_erasure_test{} ).value );
898 }
899
900 #endif
901
902 // EOF
903