1 // Copyright 2011 The Kyua Authors. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above copyright 11 // notice, this list of conditions and the following disclaimer in the 12 // documentation and/or other materials provided with the distribution. 13 // * Neither the name of Google Inc. nor the names of its contributors 14 // may be used to endorse or promote products derived from this software 15 // without specific prior written permission. 16 // 17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 29 #include "engine/filters.hpp" 30 31 #include <stdexcept> 32 33 #include <atf-c++.hpp> 34 35 namespace fs = utils::fs; 36 37 38 namespace { 39 40 41 /// Syntactic sugar to instantiate engine::test_filter objects. 42 /// 43 /// \param test_program Test program. 44 /// \param test_case Test case. 45 /// 46 /// \return A \p test_filter object, based on \p test_program and \p test_case. 47 inline engine::test_filter 48 mkfilter(const char* test_program, const char* test_case) 49 { 50 return engine::test_filter(fs::path(test_program), test_case); 51 } 52 53 54 } // anonymous namespace 55 56 57 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__public_fields); 58 ATF_TEST_CASE_BODY(test_filter__public_fields) 59 { 60 const engine::test_filter filter(fs::path("foo/bar"), "baz"); 61 ATF_REQUIRE_EQ(fs::path("foo/bar"), filter.test_program); 62 ATF_REQUIRE_EQ("baz", filter.test_case); 63 } 64 65 66 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__ok); 67 ATF_TEST_CASE_BODY(test_filter__parse__ok) 68 { 69 const engine::test_filter filter(engine::test_filter::parse("foo")); 70 ATF_REQUIRE_EQ(fs::path("foo"), filter.test_program); 71 ATF_REQUIRE(filter.test_case.empty()); 72 } 73 74 75 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__empty); 76 ATF_TEST_CASE_BODY(test_filter__parse__empty) 77 { 78 ATF_REQUIRE_THROW_RE(std::runtime_error, "empty", 79 engine::test_filter::parse("")); 80 } 81 82 83 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__absolute); 84 ATF_TEST_CASE_BODY(test_filter__parse__absolute) 85 { 86 ATF_REQUIRE_THROW_RE(std::runtime_error, "'/foo/bar'.*relative", 87 engine::test_filter::parse("/foo//bar")); 88 } 89 90 91 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__bad_program_name); 92 ATF_TEST_CASE_BODY(test_filter__parse__bad_program_name) 93 { 94 ATF_REQUIRE_THROW_RE(std::runtime_error, "Program name.*':foo'", 95 engine::test_filter::parse(":foo")); 96 } 97 98 99 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__bad_test_case); 100 ATF_TEST_CASE_BODY(test_filter__parse__bad_test_case) 101 { 102 ATF_REQUIRE_THROW_RE(std::runtime_error, "Test case.*'bar/baz:'", 103 engine::test_filter::parse("bar/baz:")); 104 } 105 106 107 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__parse__bad_path); 108 ATF_TEST_CASE_BODY(test_filter__parse__bad_path) 109 { 110 // TODO(jmmv): Not implemented. At the moment, the only reason for a path 111 // to be invalid is if it is empty... but we are checking this exact 112 // condition ourselves as part of the input validation. So we can't mock in 113 // an argument with an invalid non-empty path... 114 } 115 116 117 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__str); 118 ATF_TEST_CASE_BODY(test_filter__str) 119 { 120 const engine::test_filter filter(fs::path("foo/bar"), "baz"); 121 ATF_REQUIRE_EQ("foo/bar:baz", filter.str()); 122 } 123 124 125 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__contains__same); 126 ATF_TEST_CASE_BODY(test_filter__contains__same) 127 { 128 { 129 const engine::test_filter f(fs::path("foo/bar"), "baz"); 130 ATF_REQUIRE(f.contains(f)); 131 } 132 { 133 const engine::test_filter f(fs::path("foo/bar"), ""); 134 ATF_REQUIRE(f.contains(f)); 135 } 136 { 137 const engine::test_filter f(fs::path("foo"), ""); 138 ATF_REQUIRE(f.contains(f)); 139 } 140 } 141 142 143 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__contains__different); 144 ATF_TEST_CASE_BODY(test_filter__contains__different) 145 { 146 { 147 const engine::test_filter f1(fs::path("foo"), ""); 148 const engine::test_filter f2(fs::path("foo"), "bar"); 149 ATF_REQUIRE( f1.contains(f2)); 150 ATF_REQUIRE(!f2.contains(f1)); 151 } 152 { 153 const engine::test_filter f1(fs::path("foo/bar"), ""); 154 const engine::test_filter f2(fs::path("foo/bar"), "baz"); 155 ATF_REQUIRE( f1.contains(f2)); 156 ATF_REQUIRE(!f2.contains(f1)); 157 } 158 { 159 const engine::test_filter f1(fs::path("foo/bar"), ""); 160 const engine::test_filter f2(fs::path("foo/baz"), ""); 161 ATF_REQUIRE(!f1.contains(f2)); 162 ATF_REQUIRE(!f2.contains(f1)); 163 } 164 { 165 const engine::test_filter f1(fs::path("foo"), ""); 166 const engine::test_filter f2(fs::path("foo/bar"), ""); 167 ATF_REQUIRE( f1.contains(f2)); 168 ATF_REQUIRE(!f2.contains(f1)); 169 } 170 { 171 const engine::test_filter f1(fs::path("foo"), "bar"); 172 const engine::test_filter f2(fs::path("foo/bar"), ""); 173 ATF_REQUIRE(!f1.contains(f2)); 174 ATF_REQUIRE(!f2.contains(f1)); 175 } 176 } 177 178 179 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__matches_test_program) 180 ATF_TEST_CASE_BODY(test_filter__matches_test_program) 181 { 182 { 183 const engine::test_filter f(fs::path("top"), "unused"); 184 ATF_REQUIRE( f.matches_test_program(fs::path("top"))); 185 ATF_REQUIRE(!f.matches_test_program(fs::path("top2"))); 186 } 187 188 { 189 const engine::test_filter f(fs::path("dir1/dir2"), ""); 190 ATF_REQUIRE( f.matches_test_program(fs::path("dir1/dir2/foo"))); 191 ATF_REQUIRE( f.matches_test_program(fs::path("dir1/dir2/bar"))); 192 ATF_REQUIRE( f.matches_test_program(fs::path("dir1/dir2/bar/baz"))); 193 ATF_REQUIRE( f.matches_test_program(fs::path("dir1/dir2/bar/baz"))); 194 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1"))); 195 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/bar/baz"))); 196 ATF_REQUIRE(!f.matches_test_program(fs::path("dir2/bar/baz"))); 197 } 198 199 { 200 const engine::test_filter f(fs::path("dir1/dir2"), "unused"); 201 ATF_REQUIRE( f.matches_test_program(fs::path("dir1/dir2"))); 202 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/dir2/foo"))); 203 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/dir2/bar"))); 204 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/dir2/bar/baz"))); 205 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/dir2/bar/baz"))); 206 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1"))); 207 ATF_REQUIRE(!f.matches_test_program(fs::path("dir1/bar/baz"))); 208 ATF_REQUIRE(!f.matches_test_program(fs::path("dir2/bar/baz"))); 209 } 210 } 211 212 213 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__matches_test_case) 214 ATF_TEST_CASE_BODY(test_filter__matches_test_case) 215 { 216 { 217 const engine::test_filter f(fs::path("top"), "foo"); 218 ATF_REQUIRE( f.matches_test_case(fs::path("top"), "foo")); 219 ATF_REQUIRE(!f.matches_test_case(fs::path("top"), "bar")); 220 } 221 222 { 223 const engine::test_filter f(fs::path("top"), ""); 224 ATF_REQUIRE( f.matches_test_case(fs::path("top"), "foo")); 225 ATF_REQUIRE( f.matches_test_case(fs::path("top"), "bar")); 226 ATF_REQUIRE(!f.matches_test_case(fs::path("top2"), "foo")); 227 } 228 229 { 230 const engine::test_filter f(fs::path("d1/d2/prog"), "t1"); 231 ATF_REQUIRE( f.matches_test_case(fs::path("d1/d2/prog"), "t1")); 232 ATF_REQUIRE(!f.matches_test_case(fs::path("d1/d2/prog"), "t2")); 233 } 234 235 { 236 const engine::test_filter f(fs::path("d1/d2"), ""); 237 ATF_REQUIRE( f.matches_test_case(fs::path("d1/d2/prog"), "t1")); 238 ATF_REQUIRE( f.matches_test_case(fs::path("d1/d2/prog"), "t2")); 239 ATF_REQUIRE( f.matches_test_case(fs::path("d1/d2/prog2"), "t2")); 240 ATF_REQUIRE(!f.matches_test_case(fs::path("d1/d3"), "foo")); 241 ATF_REQUIRE(!f.matches_test_case(fs::path("d2"), "foo")); 242 } 243 } 244 245 246 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__operator_lt) 247 ATF_TEST_CASE_BODY(test_filter__operator_lt) 248 { 249 { 250 const engine::test_filter f1(fs::path("d1/d2"), ""); 251 ATF_REQUIRE(!(f1 < f1)); 252 } 253 { 254 const engine::test_filter f1(fs::path("d1/d2"), ""); 255 const engine::test_filter f2(fs::path("d1/d3"), ""); 256 ATF_REQUIRE( (f1 < f2)); 257 ATF_REQUIRE(!(f2 < f1)); 258 } 259 { 260 const engine::test_filter f1(fs::path("d1/d2"), ""); 261 const engine::test_filter f2(fs::path("d1/d2"), "foo"); 262 ATF_REQUIRE( (f1 < f2)); 263 ATF_REQUIRE(!(f2 < f1)); 264 } 265 { 266 const engine::test_filter f1(fs::path("d1/d2"), "bar"); 267 const engine::test_filter f2(fs::path("d1/d2"), "foo"); 268 ATF_REQUIRE( (f1 < f2)); 269 ATF_REQUIRE(!(f2 < f1)); 270 } 271 { 272 const engine::test_filter f1(fs::path("d1/d2"), "bar"); 273 const engine::test_filter f2(fs::path("d1/d3"), ""); 274 ATF_REQUIRE( (f1 < f2)); 275 ATF_REQUIRE(!(f2 < f1)); 276 } 277 } 278 279 280 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__operator_eq) 281 ATF_TEST_CASE_BODY(test_filter__operator_eq) 282 { 283 const engine::test_filter f1(fs::path("d1/d2"), ""); 284 const engine::test_filter f2(fs::path("d1/d2"), "bar"); 285 ATF_REQUIRE( (f1 == f1)); 286 ATF_REQUIRE(!(f1 == f2)); 287 ATF_REQUIRE(!(f2 == f1)); 288 ATF_REQUIRE( (f2 == f2)); 289 } 290 291 292 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__operator_ne) 293 ATF_TEST_CASE_BODY(test_filter__operator_ne) 294 { 295 const engine::test_filter f1(fs::path("d1/d2"), ""); 296 const engine::test_filter f2(fs::path("d1/d2"), "bar"); 297 ATF_REQUIRE(!(f1 != f1)); 298 ATF_REQUIRE( (f1 != f2)); 299 ATF_REQUIRE( (f2 != f1)); 300 ATF_REQUIRE(!(f2 != f2)); 301 } 302 303 304 ATF_TEST_CASE_WITHOUT_HEAD(test_filter__output); 305 ATF_TEST_CASE_BODY(test_filter__output) 306 { 307 { 308 std::ostringstream str; 309 str << engine::test_filter(fs::path("d1/d2"), ""); 310 ATF_REQUIRE_EQ( 311 "test_filter{test_program=d1/d2}", 312 str.str()); 313 } 314 { 315 std::ostringstream str; 316 str << engine::test_filter(fs::path("d1/d2"), "bar"); 317 ATF_REQUIRE_EQ( 318 "test_filter{test_program=d1/d2, test_case=bar}", 319 str.str()); 320 } 321 } 322 323 324 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__match_test_case__no_filters) 325 ATF_TEST_CASE_BODY(test_filters__match_test_case__no_filters) 326 { 327 const std::set< engine::test_filter > raw_filters; 328 329 const engine::test_filters filters(raw_filters); 330 engine::test_filters::match match; 331 332 match = filters.match_test_case(fs::path("foo"), "baz"); 333 ATF_REQUIRE(match.first); 334 ATF_REQUIRE(!match.second); 335 336 match = filters.match_test_case(fs::path("foo/bar"), "baz"); 337 ATF_REQUIRE(match.first); 338 ATF_REQUIRE(!match.second); 339 } 340 341 342 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__match_test_case__some_filters) 343 ATF_TEST_CASE_BODY(test_filters__match_test_case__some_filters) 344 { 345 std::set< engine::test_filter > raw_filters; 346 raw_filters.insert(mkfilter("top_test", "")); 347 raw_filters.insert(mkfilter("subdir_1", "")); 348 raw_filters.insert(mkfilter("subdir_2/a_test", "")); 349 raw_filters.insert(mkfilter("subdir_2/b_test", "foo")); 350 351 const engine::test_filters filters(raw_filters); 352 engine::test_filters::match match; 353 354 match = filters.match_test_case(fs::path("top_test"), "a"); 355 ATF_REQUIRE(match.first); 356 ATF_REQUIRE_EQ("top_test", match.second.get().str()); 357 358 match = filters.match_test_case(fs::path("subdir_1/foo"), "a"); 359 ATF_REQUIRE(match.first); 360 ATF_REQUIRE_EQ("subdir_1", match.second.get().str()); 361 362 match = filters.match_test_case(fs::path("subdir_1/bar"), "z"); 363 ATF_REQUIRE(match.first); 364 ATF_REQUIRE_EQ("subdir_1", match.second.get().str()); 365 366 match = filters.match_test_case(fs::path("subdir_2/a_test"), "bar"); 367 ATF_REQUIRE(match.first); 368 ATF_REQUIRE_EQ("subdir_2/a_test", match.second.get().str()); 369 370 match = filters.match_test_case(fs::path("subdir_2/b_test"), "foo"); 371 ATF_REQUIRE(match.first); 372 ATF_REQUIRE_EQ("subdir_2/b_test:foo", match.second.get().str()); 373 374 match = filters.match_test_case(fs::path("subdir_2/b_test"), "bar"); 375 ATF_REQUIRE(!match.first); 376 377 match = filters.match_test_case(fs::path("subdir_2/c_test"), "foo"); 378 ATF_REQUIRE(!match.first); 379 380 match = filters.match_test_case(fs::path("subdir_3"), "hello"); 381 ATF_REQUIRE(!match.first); 382 } 383 384 385 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__match_test_program__no_filters) 386 ATF_TEST_CASE_BODY(test_filters__match_test_program__no_filters) 387 { 388 const std::set< engine::test_filter > raw_filters; 389 390 const engine::test_filters filters(raw_filters); 391 ATF_REQUIRE(filters.match_test_program(fs::path("foo"))); 392 ATF_REQUIRE(filters.match_test_program(fs::path("foo/bar"))); 393 } 394 395 396 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__match_test_program__some_filters) 397 ATF_TEST_CASE_BODY(test_filters__match_test_program__some_filters) 398 { 399 std::set< engine::test_filter > raw_filters; 400 raw_filters.insert(mkfilter("top_test", "")); 401 raw_filters.insert(mkfilter("subdir_1", "")); 402 raw_filters.insert(mkfilter("subdir_2/a_test", "")); 403 raw_filters.insert(mkfilter("subdir_2/b_test", "foo")); 404 405 const engine::test_filters filters(raw_filters); 406 ATF_REQUIRE( filters.match_test_program(fs::path("top_test"))); 407 ATF_REQUIRE( filters.match_test_program(fs::path("subdir_1/foo"))); 408 ATF_REQUIRE( filters.match_test_program(fs::path("subdir_1/bar"))); 409 ATF_REQUIRE( filters.match_test_program(fs::path("subdir_2/a_test"))); 410 ATF_REQUIRE( filters.match_test_program(fs::path("subdir_2/b_test"))); 411 ATF_REQUIRE(!filters.match_test_program(fs::path("subdir_2/c_test"))); 412 ATF_REQUIRE(!filters.match_test_program(fs::path("subdir_3"))); 413 } 414 415 416 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__difference__no_filters); 417 ATF_TEST_CASE_BODY(test_filters__difference__no_filters) 418 { 419 const std::set< engine::test_filter > in_filters; 420 const std::set< engine::test_filter > used; 421 const std::set< engine::test_filter > diff = engine::test_filters( 422 in_filters).difference(used); 423 ATF_REQUIRE(diff.empty()); 424 } 425 426 427 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__difference__some_filters__all_used); 428 ATF_TEST_CASE_BODY(test_filters__difference__some_filters__all_used) 429 { 430 std::set< engine::test_filter > in_filters; 431 in_filters.insert(mkfilter("a", "")); 432 in_filters.insert(mkfilter("b", "c")); 433 434 const std::set< engine::test_filter > used = in_filters; 435 436 const std::set< engine::test_filter > diff = engine::test_filters( 437 in_filters).difference(used); 438 ATF_REQUIRE(diff.empty()); 439 } 440 441 442 ATF_TEST_CASE_WITHOUT_HEAD(test_filters__difference__some_filters__some_unused); 443 ATF_TEST_CASE_BODY(test_filters__difference__some_filters__some_unused) 444 { 445 std::set< engine::test_filter > in_filters; 446 in_filters.insert(mkfilter("a", "")); 447 in_filters.insert(mkfilter("b", "c")); 448 in_filters.insert(mkfilter("d", "")); 449 in_filters.insert(mkfilter("e", "f")); 450 451 std::set< engine::test_filter > used; 452 used.insert(mkfilter("b", "c")); 453 used.insert(mkfilter("d", "")); 454 455 const std::set< engine::test_filter > diff = engine::test_filters( 456 in_filters).difference(used); 457 ATF_REQUIRE_EQ(2, diff.size()); 458 ATF_REQUIRE(diff.find(mkfilter("a", "")) != diff.end()); 459 ATF_REQUIRE(diff.find(mkfilter("e", "f")) != diff.end()); 460 } 461 462 463 ATF_TEST_CASE_WITHOUT_HEAD(check_disjoint_filters__ok); 464 ATF_TEST_CASE_BODY(check_disjoint_filters__ok) 465 { 466 std::set< engine::test_filter > filters; 467 filters.insert(mkfilter("a", "")); 468 filters.insert(mkfilter("b", "")); 469 filters.insert(mkfilter("c", "a")); 470 filters.insert(mkfilter("c", "b")); 471 472 engine::check_disjoint_filters(filters); 473 } 474 475 476 ATF_TEST_CASE_WITHOUT_HEAD(check_disjoint_filters__fail); 477 ATF_TEST_CASE_BODY(check_disjoint_filters__fail) 478 { 479 std::set< engine::test_filter > filters; 480 filters.insert(mkfilter("a", "")); 481 filters.insert(mkfilter("b", "")); 482 filters.insert(mkfilter("c", "a")); 483 filters.insert(mkfilter("d", "b")); 484 filters.insert(mkfilter("c", "")); 485 486 ATF_REQUIRE_THROW_RE(std::runtime_error, "'c'.*'c:a'.*not disjoint", 487 engine::check_disjoint_filters(filters)); 488 } 489 490 491 ATF_TEST_CASE_WITHOUT_HEAD(filters_state__match_test_program); 492 ATF_TEST_CASE_BODY(filters_state__match_test_program) 493 { 494 std::set< engine::test_filter > filters; 495 filters.insert(mkfilter("foo/bar", "")); 496 filters.insert(mkfilter("baz", "tc")); 497 engine::filters_state state(filters); 498 499 ATF_REQUIRE(state.match_test_program(fs::path("foo/bar/something"))); 500 ATF_REQUIRE(state.match_test_program(fs::path("baz"))); 501 502 ATF_REQUIRE(!state.match_test_program(fs::path("foo/baz"))); 503 ATF_REQUIRE(!state.match_test_program(fs::path("hello"))); 504 } 505 506 507 ATF_TEST_CASE_WITHOUT_HEAD(filters_state__match_test_case); 508 ATF_TEST_CASE_BODY(filters_state__match_test_case) 509 { 510 std::set< engine::test_filter > filters; 511 filters.insert(mkfilter("foo/bar", "")); 512 filters.insert(mkfilter("baz", "tc")); 513 engine::filters_state state(filters); 514 515 ATF_REQUIRE(state.match_test_case(fs::path("foo/bar/something"), "any")); 516 ATF_REQUIRE(state.match_test_case(fs::path("baz"), "tc")); 517 518 ATF_REQUIRE(!state.match_test_case(fs::path("foo/baz/something"), "tc")); 519 ATF_REQUIRE(!state.match_test_case(fs::path("baz"), "tc2")); 520 } 521 522 523 ATF_TEST_CASE_WITHOUT_HEAD(filters_state__unused__none); 524 ATF_TEST_CASE_BODY(filters_state__unused__none) 525 { 526 std::set< engine::test_filter > filters; 527 filters.insert(mkfilter("a/b", "")); 528 filters.insert(mkfilter("baz", "tc")); 529 filters.insert(mkfilter("hey/d", "yes")); 530 engine::filters_state state(filters); 531 532 state.match_test_case(fs::path("a/b/c"), "any"); 533 state.match_test_case(fs::path("baz"), "tc"); 534 state.match_test_case(fs::path("hey/d"), "yes"); 535 536 ATF_REQUIRE(state.unused().empty()); 537 } 538 539 540 ATF_TEST_CASE_WITHOUT_HEAD(filters_state__unused__some); 541 ATF_TEST_CASE_BODY(filters_state__unused__some) 542 { 543 std::set< engine::test_filter > filters; 544 filters.insert(mkfilter("a/b", "")); 545 filters.insert(mkfilter("baz", "tc")); 546 filters.insert(mkfilter("hey/d", "yes")); 547 engine::filters_state state(filters); 548 549 state.match_test_program(fs::path("a/b/c")); 550 state.match_test_case(fs::path("baz"), "tc"); 551 552 std::set< engine::test_filter > exp_unused; 553 exp_unused.insert(mkfilter("a/b", "")); 554 exp_unused.insert(mkfilter("hey/d", "yes")); 555 556 ATF_REQUIRE(exp_unused == state.unused()); 557 } 558 559 560 ATF_INIT_TEST_CASES(tcs) 561 { 562 ATF_ADD_TEST_CASE(tcs, test_filter__public_fields); 563 ATF_ADD_TEST_CASE(tcs, test_filter__parse__ok); 564 ATF_ADD_TEST_CASE(tcs, test_filter__parse__empty); 565 ATF_ADD_TEST_CASE(tcs, test_filter__parse__absolute); 566 ATF_ADD_TEST_CASE(tcs, test_filter__parse__bad_program_name); 567 ATF_ADD_TEST_CASE(tcs, test_filter__parse__bad_test_case); 568 ATF_ADD_TEST_CASE(tcs, test_filter__parse__bad_path); 569 ATF_ADD_TEST_CASE(tcs, test_filter__str); 570 ATF_ADD_TEST_CASE(tcs, test_filter__contains__same); 571 ATF_ADD_TEST_CASE(tcs, test_filter__contains__different); 572 ATF_ADD_TEST_CASE(tcs, test_filter__matches_test_program); 573 ATF_ADD_TEST_CASE(tcs, test_filter__matches_test_case); 574 ATF_ADD_TEST_CASE(tcs, test_filter__operator_lt); 575 ATF_ADD_TEST_CASE(tcs, test_filter__operator_eq); 576 ATF_ADD_TEST_CASE(tcs, test_filter__operator_ne); 577 ATF_ADD_TEST_CASE(tcs, test_filter__output); 578 579 ATF_ADD_TEST_CASE(tcs, test_filters__match_test_case__no_filters); 580 ATF_ADD_TEST_CASE(tcs, test_filters__match_test_case__some_filters); 581 ATF_ADD_TEST_CASE(tcs, test_filters__match_test_program__no_filters); 582 ATF_ADD_TEST_CASE(tcs, test_filters__match_test_program__some_filters); 583 ATF_ADD_TEST_CASE(tcs, test_filters__difference__no_filters); 584 ATF_ADD_TEST_CASE(tcs, test_filters__difference__some_filters__all_used); 585 ATF_ADD_TEST_CASE(tcs, test_filters__difference__some_filters__some_unused); 586 587 ATF_ADD_TEST_CASE(tcs, check_disjoint_filters__ok); 588 ATF_ADD_TEST_CASE(tcs, check_disjoint_filters__fail); 589 590 ATF_ADD_TEST_CASE(tcs, filters_state__match_test_program); 591 ATF_ADD_TEST_CASE(tcs, filters_state__match_test_case); 592 ATF_ADD_TEST_CASE(tcs, filters_state__unused__none); 593 ATF_ADD_TEST_CASE(tcs, filters_state__unused__some); 594 } 595