ceph/src/boost/libs/test/test/framework-ts/run-by-name-or-label-test.cpp

   1 //  (C) Copyright Gennadiy Rozental 2003-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: 62023 $
  11 //
  12 //  Description : unit test for class properties facility
  13 // ***************************************************************************
  14
  15 // Boost.Test
  16 #define BOOST_TEST_MODULE Boost.Test run by name/label implementation test
  17 #include <boost/test/unit_test.hpp>
  18 #include <boost/test/unit_test_parameters.hpp>
  19 #include <boost/test/tree/test_case_counter.hpp>
  20 #include <boost/test/tree/traverse.hpp>
  21
  22 namespace utf = boost::unit_test;
  23
  24 void A() {}
  25 void B() {}
  26 void C() {}
  27 void D() {}
  28 void E() {}
  29 void F() {}
  30 void longnameA() {}
  31 void Blongname() {}
  32
  33 //____________________________________________________________________________//
  34
  35 void
  36 test_count( utf::test_suite* master_ts, char const** argv, int argc, unsigned expected )
  37 {
  38     argc /= sizeof(char*);
  39
  40     BOOST_TEST_INFO( argv[1] );
  41     if( argc > 2 )
  42         BOOST_TEST_INFO( argv[2] );
  43
  44     utf::runtime_config::init( argc, (char**)argv );
  45     utf::framework::impl::setup_for_execution( *master_ts );
  46
  47     utf::test_case_counter tcc;
  48     utf::traverse_test_tree( master_ts->p_id, tcc );
  49     BOOST_TEST( tcc.p_count == expected );
  50 }
  51
  52 BOOST_AUTO_TEST_CASE( test_run_by_name )
  53 {
  54     utf::test_suite* master_ts = BOOST_TEST_SUITE("local master");
  55
  56     utf::test_suite* ts1 = BOOST_TEST_SUITE("ts1");
  57     ts1->add( BOOST_TEST_CASE( &C ) );
  58     ts1->add( BOOST_TEST_CASE( &D ) );
  59
  60     utf::test_suite* ts2 = BOOST_TEST_SUITE("ts2");
  61     ts2->add( BOOST_TEST_CASE( &A ) );
  62     ts2->add( BOOST_TEST_CASE( &C ) );
  63     ts2->add( BOOST_TEST_CASE( &longnameA ) );
  64     ts2->add( ts1 );
  65
  66     master_ts->add( BOOST_TEST_CASE( &A ) );
  67     master_ts->add( BOOST_TEST_CASE( &B ) );
  68     master_ts->add( BOOST_TEST_CASE( &longnameA ) );
  69     master_ts->add( BOOST_TEST_CASE( &Blongname ) );
  70     master_ts->add( ts2 );
  71
  72     master_ts->p_default_status.value = utf::test_unit::RS_ENABLED;
  73     utf::framework::finalize_setup_phase( master_ts->p_id );
  74     {
  75         utf::framework::impl::setup_for_execution( *master_ts );
  76         utf::test_case_counter tcc;
  77         utf::traverse_test_tree( master_ts->p_id, tcc );
  78         BOOST_TEST( tcc.p_count == 9U );
  79     }
  80
  81     {
  82         char const* argv[] = { "a.exe", "--run_test=*" };
  83         test_count( master_ts, argv, sizeof(argv), 9 );
  84     }
  85
  86     {
  87         char const* argv[] = { "a.exe", "--run_test=!*" };
  88         test_count( master_ts, argv, sizeof(argv), 0 );
  89     }
  90
  91     {
  92         char const* argv[] = { "a.exe", "--run_test=*/*" };
  93         test_count( master_ts, argv, sizeof(argv), 5 );
  94     }
  95
  96     {
  97         char const* argv[] = { "a.exe", "--run_test=!*/*" };
  98         test_count( master_ts, argv, sizeof(argv), 4 );
  99     }
 100
 101     {
 102         char const* argv[] = { "a.exe", "--run_test=*/*/*" };
 103         test_count( master_ts, argv, sizeof(argv), 2 );
 104     }
 105     {
 106         char const* argv[] = { "a.exe", "--run_test=!*/*/*" };
 107         test_count( master_ts, argv, sizeof(argv), 7 );
 108     }
 109
 110     {
 111         char const* argv[] = { "a.exe", "--run_test=klmn" };
 112         test_count( master_ts, argv, sizeof(argv), 0 );
 113     }
 114
 115     {
 116         char const* argv[] = { "a.exe", "--run_test=!klmn" };
 117         test_count( master_ts, argv, sizeof(argv), 9 );
 118     }
 119
 120     {
 121         char const* argv[] = { "a.exe", "--run_test=A" };
 122         test_count( master_ts, argv, sizeof(argv), 1 );
 123     }
 124
 125     {
 126         char const* argv[] = { "a.exe", "--run_test=!A" };
 127         test_count( master_ts, argv, sizeof(argv), 8 );
 128     }
 129
 130     {
 131         char const* argv[] = { "a.exe", "--run_test=*A" };
 132         test_count( master_ts, argv, sizeof(argv), 2 );
 133     }
 134
 135     {
 136         char const* argv[] = { "a.exe", "--run_test=!*A" };
 137         test_count( master_ts, argv, sizeof(argv), 7 );
 138     }
 139
 140     {
 141         char const* argv[] = { "a.exe", "--run_test=B*" };
 142         test_count( master_ts, argv, sizeof(argv), 2 );
 143     }
 144
 145     {
 146         char const* argv[] = { "a.exe", "--run_test=!B*" };
 147         test_count( master_ts, argv, sizeof(argv), 7 );
 148     }
 149
 150     {
 151         char const* argv[] = { "a.exe", "--run_test=*ngn*" };
 152         test_count( master_ts, argv, sizeof(argv), 2 );
 153     }
 154
 155     {
 156         char const* argv[] = { "a.exe", "--run_test=ts2" };
 157         test_count( master_ts, argv, sizeof(argv), 5 );
 158     }
 159
 160     {
 161         char const* argv[] = { "a.exe", "--run_test=!ts2" };
 162         test_count( master_ts, argv, sizeof(argv), 4 );
 163     }
 164
 165     {
 166         char const* argv[] = { "a.exe", "--run_test=ts2/*" };
 167         test_count( master_ts, argv, sizeof(argv), 5 );
 168     }
 169
 170     {
 171         char const* argv[] = { "a.exe", "--run_test=!ts2/*" };
 172         test_count( master_ts, argv, sizeof(argv), 4 );
 173     }
 174
 175     {
 176         char const* argv[] = { "a.exe", "--run_test=ts2/C" };
 177         test_count( master_ts, argv, sizeof(argv), 1 );
 178     }
 179
 180     {
 181         char const* argv[] = { "a.exe", "--run_test=!ts2/C" };
 182         test_count( master_ts, argv, sizeof(argv), 8 );
 183     }
 184
 185     {
 186         char const* argv[] = { "a.exe", "--run_test=ts2/*A" };
 187         test_count( master_ts, argv, sizeof(argv), 2 );
 188     }
 189
 190     {
 191         char const* argv[] = { "a.exe", "--run_test=!ts2/*A" };
 192         test_count( master_ts, argv, sizeof(argv), 7 );
 193     }
 194
 195     {
 196         char const* argv[] = { "a.exe", "--run_test=ts2/ts1" };
 197         test_count( master_ts, argv, sizeof(argv), 2 );
 198     }
 199
 200     {
 201         char const* argv[] = { "a.exe", "--run_test=!ts2/ts1" };
 202         test_count( master_ts, argv, sizeof(argv), 7 );
 203     }
 204
 205     {
 206         char const* argv[] = { "a.exe", "--run_test=ts2/ts1/C" };
 207         test_count( master_ts, argv, sizeof(argv), 1 );
 208     }
 209
 210     {
 211         char const* argv[] = { "a.exe", "--run_test=!ts2/ts1/C" };
 212         test_count( master_ts, argv, sizeof(argv), 8 );
 213     }
 214
 215     {
 216         char const* argv[] = { "a.exe", "--run_test=ts2/ts1/*D*" };
 217         test_count( master_ts, argv, sizeof(argv), 1 );
 218     }
 219
 220     {
 221         char const* argv[] = { "a.exe", "--run_test=!ts2/ts1/*D*" };
 222         test_count( master_ts, argv, sizeof(argv), 8 );
 223     }
 224
 225     {
 226         char const* argv[] = { "a.exe", "--run_test=A,B" };
 227         test_count( master_ts, argv, sizeof(argv), 2 );
 228     }
 229
 230     {
 231         char const* argv[] = { "a.exe", "--run_test=!A,B" };
 232         test_count( master_ts, argv, sizeof(argv), 7 );
 233     }
 234
 235     {
 236         char const* argv[] = { "a.exe", "--run_test=*A,B" };
 237         test_count( master_ts, argv, sizeof(argv), 3 );
 238     }
 239
 240     {
 241         char const* argv[] = { "a.exe", "--run_test=!*A,B" };
 242         test_count( master_ts, argv, sizeof(argv), 6 );
 243     }
 244
 245     {
 246         char const* argv[] = { "a.exe", "--run_test=ts2/C,ts1" };
 247         test_count( master_ts, argv, sizeof(argv), 3 );
 248     }
 249
 250     {
 251         char const* argv[] = { "a.exe", "--run_test=!ts2/C,ts1" };
 252         test_count( master_ts, argv, sizeof(argv), 6 );
 253     }
 254
 255     {
 256         char const* argv[] = { "a.exe", "--run_test=ts2/C,ts1/D" };
 257         test_count( master_ts, argv, sizeof(argv), 1 );
 258     }
 259
 260     {
 261         char const* argv[] = { "a.exe", "--run_test=!ts2/C,ts1/D" };
 262         test_count( master_ts, argv, sizeof(argv), 8 );
 263     }
 264
 265     {
 266         char const* argv[] = { "a.exe", "--run_test=A", "--run_test=B" };
 267         test_count( master_ts, argv, sizeof(argv), 2 );
 268     }
 269
 270     {
 271         char const* argv[] = { "a.exe", "--run_test=!A", "--run_test=!B" };
 272         test_count( master_ts, argv, sizeof(argv), 7 );
 273     }
 274
 275     {
 276         char const* argv[] = { "a.exe", "--run_test=A", "--run_test=ts2/ts1/C" };
 277         test_count( master_ts, argv, sizeof(argv), 2 );
 278     }
 279
 280     {
 281         char const* argv[] = { "a.exe", "--run_test=A", "--run_test=ts2/ts1/C,D" };
 282         test_count( master_ts, argv, sizeof(argv), 3 );
 283     }
 284
 285     {
 286         char const* argv[] = { "a.exe", "--run_test=A", "--run_test=ts2/ts1/C,D:longnameA" };
 287         test_count( master_ts, argv, sizeof(argv), 4 );
 288     }
 289
 290     {
 291         char const* argv[] = { "a.exe", "--run_test=ts2", "--run_test=!ts2/*A" };
 292         test_count( master_ts, argv, sizeof(argv), 3 );
 293     }
 294 }
 295
 296 //____________________________________________________________________________//
 297
 298 BOOST_AUTO_TEST_CASE( test_run_by_label )
 299 {
 300     utf::test_case* tc;
 301
 302     utf::test_suite* master_ts = BOOST_TEST_SUITE("local master");
 303
 304     utf::test_suite* ts1 = BOOST_TEST_SUITE("ts1");
 305     ts1->add_label( "f2" );
 306     ts1->add( tc=BOOST_TEST_CASE( &C ) );
 307     tc->add_label( "L1" );
 308     ts1->add( tc=BOOST_TEST_CASE( &D ) );
 309     tc->add_label( "L1" );
 310     tc->add_label( "l2" );
 311
 312     utf::test_suite* ts2 = BOOST_TEST_SUITE("ts2");
 313     ts2->add_label( "FAST" );
 314     ts2->add( tc=BOOST_TEST_CASE( &A ) );
 315     tc->add_label( "L1" );
 316     ts2->add( BOOST_TEST_CASE( &C ) );
 317     ts2->add( BOOST_TEST_CASE( &longnameA ) );
 318     ts2->add( ts1 );
 319
 320     master_ts->add( BOOST_TEST_CASE( &A ) );
 321     master_ts->add( BOOST_TEST_CASE( &B ) );
 322     master_ts->add( tc=BOOST_TEST_CASE( &longnameA ) );
 323     tc->add_label( "f2" );
 324     master_ts->add( BOOST_TEST_CASE( &Blongname ) );
 325     master_ts->add( ts2 );
 326
 327
 328     master_ts->p_default_status.value = utf::test_unit::RS_ENABLED;
 329     utf::framework::finalize_setup_phase( master_ts->p_id );
 330
 331     {
 332         char const* argv[] = { "a.exe", "--run_test=@L1" };
 333         test_count( master_ts, argv, sizeof(argv), 3 );
 334     }
 335
 336     {
 337         char const* argv[] = { "a.exe", "--run_test=!@INV" };
 338         test_count( master_ts, argv, sizeof(argv), 9 );
 339     }
 340
 341     {
 342         char const* argv[] = { "a.exe", "--run_test=!@L1" };
 343         test_count( master_ts, argv, sizeof(argv), 6 );
 344     }
 345
 346     {
 347         char const* argv[] = { "a.exe", "--run_test=@l2" };
 348         test_count( master_ts, argv, sizeof(argv), 1 );
 349     }
 350
 351     {
 352         char const* argv[] = { "a.exe", "--run_test=@inval" };
 353         test_count( master_ts, argv, sizeof(argv), 0 );
 354     }
 355
 356     {
 357         char const* argv[] = { "a.exe", "--run_test=@FAST" };
 358         test_count( master_ts, argv, sizeof(argv), 5 );
 359     }
 360
 361     {
 362         char const* argv[] = { "a.exe", "--run_test=@f2" };
 363         test_count( master_ts, argv, sizeof(argv), 3 );
 364     }
 365
 366     {
 367         char const* argv[] = { "a.exe", "--run_test=@L1", "--run_test=@l2" };
 368         test_count( master_ts, argv, sizeof(argv), 3 );
 369     }
 370
 371     {
 372         char const* argv[] = { "a.exe", "--run_test=@L1", "--run_test=!@l2" };
 373         test_count( master_ts, argv, sizeof(argv), 2 );
 374     }
 375 }
 376
 377 //____________________________________________________________________________//
 378
 379 BOOST_AUTO_TEST_CASE( test_dependency_handling )
 380 {
 381     utf::test_case* tc;
 382     utf::test_case* tcB;
 383
 384     //            M             |
 385     //         /  |  \          |
 386     //        /   |   \         |
 387     //     TS2   TS4  TS3       |
 388     //     / \    |   / \       |
 389     //    C   D  TS1 E   F      |
 390     //           / \            |
 391     //          A   B           |
 392     //
 393     //  D => TS1
 394     //  B => F
 395
 396     utf::test_suite* master_ts = BOOST_TEST_SUITE("local master");
 397
 398     utf::test_suite* ts1 = BOOST_TEST_SUITE("ts1");
 399     ts1->add( BOOST_TEST_CASE( &A ) );
 400     ts1->add( tcB=BOOST_TEST_CASE( &B ) );
 401
 402     utf::test_suite* ts2 = BOOST_TEST_SUITE("ts2");
 403     ts2->add( BOOST_TEST_CASE( &C ) );
 404     ts2->add( tc=BOOST_TEST_CASE( &D ) );
 405     tc->depends_on( ts1 );
 406
 407     utf::test_suite* ts3 = BOOST_TEST_SUITE("ts3");
 408     ts3->add( BOOST_TEST_CASE( &E ) );
 409     ts3->add( tc=BOOST_TEST_CASE( &F ) );
 410     tcB->depends_on( tc );
 411
 412     utf::test_suite* ts4 = BOOST_TEST_SUITE("ts4");
 413     ts4->add( ts1 );
 414
 415     master_ts->add( ts2 );
 416     master_ts->add( ts3 );
 417     master_ts->add( ts4 );
 418
 419     master_ts->p_default_status.value = utf::test_unit::RS_ENABLED;
 420     utf::framework::finalize_setup_phase( master_ts->p_id );
 421
 422     {
 423         char const* argv[] = { "a.exe", "--run_test=ts2/C" };
 424         test_count( master_ts, argv, sizeof(argv), 1 );
 425     }
 426
 427     {
 428         char const* argv[] = { "a.exe", "--run_test=ts3" };
 429         test_count( master_ts, argv, sizeof(argv), 2 );
 430     }
 431
 432     {
 433         char const* argv[] = { "a.exe", "--run_test=ts2/C" };
 434         test_count( master_ts, argv, sizeof(argv), 1 );
 435     }
 436
 437     {
 438         char const* argv[] = { "a.exe", "--run_test=ts4/ts1/B" };
 439         test_count( master_ts, argv, sizeof(argv), 2 );
 440     }
 441
 442     {
 443         char const* argv[] = { "a.exe", "--run_test=ts4/ts1" };
 444         test_count( master_ts, argv, sizeof(argv), 3 );
 445     }
 446
 447     {
 448         char const* argv[] = { "a.exe", "--run_test=ts2" };
 449         test_count( master_ts, argv, sizeof(argv), 5 );
 450     }
 451
 452     {
 453         char const* argv[] = { "a.exe", "--run_test=!ts3/F" };
 454         test_count( master_ts, argv, sizeof(argv), 5 );
 455     }
 456
 457     {
 458         char const* argv[] = { "a.exe", "--run_test=!*/ts1" };
 459         test_count( master_ts, argv, sizeof(argv), 4 );
 460     }
 461 }
 462
 463 //____________________________________________________________________________//
 464
 465 // EOF
 466