1 // Copyright Louis Dionne 2013-2017 2 // Distributed under the Boost Software License, Version 1.0. 3 // (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) 4 5 #ifndef BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP 6 #define BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP 7 8 #include <boost/hana/all.hpp> 9 #include <boost/hana/all_of.hpp> 10 #include <boost/hana/any.hpp> 11 #include <boost/hana/any_of.hpp> 12 #include <boost/hana/assert.hpp> 13 #include <boost/hana/at_key.hpp> 14 #include <boost/hana/bool.hpp> 15 #include <boost/hana/concat.hpp> 16 #include <boost/hana/concept/comparable.hpp> 17 #include <boost/hana/concept/searchable.hpp> 18 #include <boost/hana/concept/sequence.hpp> 19 #include <boost/hana/contains.hpp> 20 #include <boost/hana/core/is_a.hpp> 21 #include <boost/hana/core/when.hpp> 22 #include <boost/hana/equal.hpp> 23 #include <boost/hana/find.hpp> 24 #include <boost/hana/find_if.hpp> 25 #include <boost/hana/for_each.hpp> 26 #include <boost/hana/functional/always.hpp> 27 #include <boost/hana/functional/capture.hpp> 28 #include <boost/hana/functional/compose.hpp> 29 #include <boost/hana/functional/partial.hpp> 30 #include <boost/hana/is_disjoint.hpp> 31 #include <boost/hana/is_subset.hpp> 32 #include <boost/hana/lazy.hpp> 33 #include <boost/hana/none.hpp> 34 #include <boost/hana/none_of.hpp> 35 #include <boost/hana/not.hpp> 36 #include <boost/hana/optional.hpp> 37 #include <boost/hana/transform.hpp> 38 #include <boost/hana/tuple.hpp> 39 40 #include <laws/base.hpp> 41 #include <support/numeric.hpp> 42 43 44 namespace boost { namespace hana { namespace test { 45 template <typename S, typename = when<true>> 46 struct TestSearchable : TestSearchable<S, laws> { 47 using TestSearchable<S, laws>::TestSearchable; 48 }; 49 50 template <typename S> 51 struct TestSearchable<S, laws> { 52 template <typename Searchables, typename Keys> TestSearchableboost::hana::test::TestSearchable53 TestSearchable(Searchables searchables, Keys keys) { 54 hana::for_each(searchables, [](auto xs) { 55 static_assert(Searchable<decltype(xs)>{}, ""); 56 }); 57 58 auto predicates = hana::concat( 59 hana::to_tuple(hana::transform(keys, equal.to)), 60 hana::make_tuple( 61 hana::always(false_c), 62 hana::always(true_c) 63 ) 64 ); 65 66 hana::for_each(searchables, hana::capture(searchables, keys, predicates)( 67 [](auto searchables, auto keys, auto predicates, auto xs) { 68 hana::for_each(predicates, hana::capture(xs)( 69 [](auto xs, auto p) { 70 // any_of(xs, p) <=> !all_of(xs, negated p) 71 // <=> !none_of(xs, p) 72 BOOST_HANA_CHECK( 73 hana::any_of(xs, p) ^iff^ 74 hana::not_(hana::all_of(xs, hana::compose(not_, p))) 75 ); 76 77 BOOST_HANA_CHECK( 78 hana::any_of(xs, p) ^iff^ 79 hana::not_(hana::none_of(xs, p)) 80 ); 81 })); 82 83 // any(xs) <=> any_of(xs, id) 84 // all(xs) <=> all_of(xs, id) 85 // none(xs) <=> none_of(xs, id) 86 auto all_logicals = hana::all_of(xs, [](auto x) { 87 return hana::bool_c<hana::Logical<decltype(x)>::value>; 88 }); 89 only_when_(all_logicals, hana::make_lazy([](auto xs) { 90 BOOST_HANA_CHECK( 91 hana::any(xs) ^iff^ hana::any_of(xs, id) 92 ); 93 94 BOOST_HANA_CHECK( 95 hana::all(xs) ^iff^ hana::all_of(xs, hana::id) 96 ); 97 98 BOOST_HANA_CHECK( 99 hana::none(xs) ^iff^ hana::none_of(xs, hana::id) 100 ); 101 })(xs)); 102 103 // find_if(xs, always(false_c)) == nothing 104 BOOST_HANA_CONSTANT_CHECK(hana::equal( 105 hana::find_if(xs, hana::always(hana::false_c)), 106 hana::nothing 107 )); 108 109 hana::for_each(searchables, hana::capture(xs)([](auto xs, auto ys) { 110 // is_subset(xs, ys) <=> all_of(xs, [](auto x) { return contains(ys, x); }) 111 BOOST_HANA_CHECK( 112 hana::is_subset(xs, ys) ^iff^ 113 hana::all_of(xs, hana::partial(hana::contains, ys)) 114 ); 115 116 // is_disjoint(xs, ys) <=> none_of(xs, [](auto x) { return contains(ys, x); }) 117 BOOST_HANA_CHECK( 118 hana::is_disjoint(xs, ys) ^iff^ 119 hana::none_of(xs, hana::partial(hana::contains, ys)) 120 ); 121 })); 122 123 hana::for_each(keys, hana::capture(xs)([](auto xs, auto key) { 124 // find(xs, x) == find_if(xs, [](auto y) { return y == x; }) 125 BOOST_HANA_CHECK(hana::equal( 126 hana::find(xs, key), 127 hana::find_if(xs, hana::equal.to(key)) 128 )); 129 130 // contains(xs, x) <=> any_of(xs, [](auto y) { return y == x; }) 131 BOOST_HANA_CHECK( 132 hana::contains(xs, key) ^iff^ 133 hana::any_of(xs, hana::equal.to(key)) 134 ); 135 136 only_when_(hana::contains(xs, key), 137 hana::make_lazy([](auto xs, auto key) { 138 // at_key(xs, key) == find(xs, key).value() 139 BOOST_HANA_CHECK(hana::equal( 140 hana::at_key(xs, key), 141 hana::find(xs, key).value() 142 )); 143 })(xs, key) 144 ); 145 })); 146 })); 147 } 148 }; 149 150 template <typename S> 151 struct TestSearchable<S, when<Sequence<S>::value>> 152 : TestSearchable<S, laws> 153 { 154 template <int i> 155 using x = _constant<i>; 156 157 template <int = 0> 158 struct invalid { }; 159 160 struct undefined { }; 161 162 template <typename Xs, typename Keys> TestSearchableboost::hana::test::TestSearchable163 TestSearchable(Xs xs, Keys keys) 164 : TestSearchable<S, laws>{xs, keys} 165 { 166 constexpr auto list = make<S>; 167 __anon0a71bae90902boost::hana::test::TestSearchable168 BOOST_HANA_CONSTEXPR_LAMBDA auto is_even = [](auto x) { 169 return x % 2 == 0; 170 }; 171 172 auto c = numeric; // a minimal comparable 173 auto logical = numeric; 174 175 ////////////////////////////////////////////////////////////////// 176 // any_of 177 ////////////////////////////////////////////////////////////////// 178 BOOST_HANA_CONSTANT_CHECK( 179 hana::not_(hana::any_of(list(), equal.to(x<9>{}))) 180 ); 181 182 BOOST_HANA_CONSTANT_CHECK( 183 hana::not_(hana::any_of(list(x<0>{}), equal.to(x<9>{}))) 184 ); 185 BOOST_HANA_CONSTANT_CHECK( 186 hana::any_of(list(x<0>{}), equal.to(x<0>{})) 187 ); 188 BOOST_HANA_CONSTANT_CHECK( 189 hana::any_of(list(x<0>{}, invalid<1>{}), equal.to(x<0>{})) 190 ); 191 BOOST_HANA_CONSTANT_CHECK( 192 hana::any_of(list(x<0>{}, invalid<1>{}, invalid<2>{}), equal.to(x<0>{})) 193 ); 194 195 BOOST_HANA_CONSTANT_CHECK( 196 hana::not_(hana::any_of(list(x<0>{}, x<1>{}), equal.to(x<9>{}))) 197 ); 198 BOOST_HANA_CONSTANT_CHECK( 199 hana::any_of(list(x<0>{}, x<1>{}), equal.to(x<1>{})) 200 ); 201 BOOST_HANA_CONSTANT_CHECK( 202 hana::any_of(list(x<0>{}, x<1>{}, invalid<2>{}), equal.to(x<1>{})) 203 ); 204 BOOST_HANA_CONSTANT_CHECK( 205 hana::any_of(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), equal.to(x<1>{})) 206 ); 207 208 BOOST_HANA_CONSTANT_CHECK( 209 hana::not_(hana::any_of(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<9>{}))) 210 ); 211 BOOST_HANA_CONSTANT_CHECK( 212 hana::any_of(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<2>{})) 213 ); 214 BOOST_HANA_CONSTANT_CHECK( 215 hana::any_of(list(x<0>{}, x<1>{}, x<2>{}, nothing), equal.to(x<2>{})) 216 ); 217 BOOST_HANA_CONSTANT_CHECK( 218 hana::any_of(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), equal.to(x<2>{})) 219 ); 220 221 BOOST_HANA_CONSTANT_CHECK( 222 hana::not_(hana::any_of(list(), invalid<>{})) 223 ); 224 225 226 BOOST_HANA_CONSTEXPR_CHECK( 227 hana::any_of(list(c(0)), equal.to(c(0))) 228 ); 229 BOOST_HANA_CONSTEXPR_CHECK( 230 hana::not_(hana::any_of(list(c(0)), equal.to(c(1)))) 231 ); 232 BOOST_HANA_CONSTEXPR_CHECK( 233 hana::not_(hana::any_of(list(1), is_even)) 234 ); 235 BOOST_HANA_CONSTEXPR_CHECK( 236 hana::any_of(list(2), is_even) 237 ); 238 BOOST_HANA_CONSTEXPR_CHECK( 239 hana::any_of(list(1, 2), is_even) 240 ); 241 BOOST_HANA_CONSTEXPR_CHECK( 242 hana::not_(hana::any_of(list(1, 3), is_even)) 243 ); 244 BOOST_HANA_CONSTEXPR_CHECK( 245 hana::any_of(list(1, 3, 4), is_even) 246 ); 247 248 ////////////////////////////////////////////////////////////////// 249 // any 250 ////////////////////////////////////////////////////////////////// 251 BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any(list()))); 252 BOOST_HANA_CONSTEXPR_CHECK(hana::any(list(logical(true)))); 253 BOOST_HANA_CONSTEXPR_CHECK(hana::not_(hana::any(list(logical(false))))); 254 255 256 ////////////////////////////////////////////////////////////////// 257 // all_of 258 ////////////////////////////////////////////////////////////////// 259 BOOST_HANA_CONSTANT_CHECK( 260 all_of(list(), invalid<>{}) 261 ); 262 BOOST_HANA_CONSTEXPR_CHECK( 263 all_of(list(c(0)), equal.to(c(0))) 264 ); 265 BOOST_HANA_CONSTEXPR_CHECK( 266 not_(all_of(list(c(0)), equal.to(c(1)))) 267 ); 268 BOOST_HANA_CONSTEXPR_CHECK(not_( 269 all_of(list(c(0), c(1)), equal.to(c(0))) 270 )); 271 BOOST_HANA_CONSTEXPR_CHECK( 272 all_of(list(c(0), c(0)), equal.to(c(0))) 273 ); 274 275 BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1), is_even))); 276 BOOST_HANA_CONSTEXPR_CHECK(all_of(list(2), is_even)); 277 BOOST_HANA_CONSTEXPR_CHECK(all_of(list(2, 4), is_even)); 278 BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 2), is_even))); 279 BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 3), is_even))); 280 BOOST_HANA_CONSTEXPR_CHECK(not_(all_of(list(1, 3, 4), is_even))); 281 282 283 ////////////////////////////////////////////////////////////////// 284 // all 285 ////////////////////////////////////////////////////////////////// 286 BOOST_HANA_CONSTANT_CHECK(all(list())); 287 BOOST_HANA_CONSTEXPR_CHECK(all(list(logical(true)))); 288 BOOST_HANA_CONSTEXPR_CHECK(not_(all(list(logical(false))))); 289 BOOST_HANA_CONSTEXPR_CHECK(all(list(logical(true), logical(true)))); 290 BOOST_HANA_CONSTEXPR_CHECK(not_(all(list(logical(true), logical(false))))); 291 292 ////////////////////////////////////////////////////////////////// 293 // none_of 294 ////////////////////////////////////////////////////////////////// 295 BOOST_HANA_CONSTANT_CHECK(none_of(list(), invalid<>{})); 296 BOOST_HANA_CONSTEXPR_CHECK(none_of(list(c(0)), equal.to(c(1)))); 297 BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(c(0)), equal.to(c(0))))); 298 299 BOOST_HANA_CONSTEXPR_CHECK(none_of(list(1), is_even)); 300 BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(2), is_even))); 301 BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(1, 2), is_even))); 302 BOOST_HANA_CONSTEXPR_CHECK(none_of(list(1, 3), is_even)); 303 BOOST_HANA_CONSTEXPR_CHECK(not_(none_of(list(1, 3, 4), is_even))); 304 305 306 ////////////////////////////////////////////////////////////////// 307 // none 308 ////////////////////////////////////////////////////////////////// 309 BOOST_HANA_CONSTANT_CHECK(none(list())); 310 BOOST_HANA_CONSTEXPR_CHECK(none(list(logical(false)))); 311 BOOST_HANA_CONSTEXPR_CHECK(not_(none(list(logical(true))))); 312 313 ////////////////////////////////////////////////////////////////// 314 // find_if 315 ////////////////////////////////////////////////////////////////// 316 { 317 BOOST_HANA_CONSTANT_CHECK(equal( 318 find_if(list(), equal.to(x<9>{})), 319 nothing 320 )); 321 322 BOOST_HANA_CONSTANT_CHECK(equal( 323 find_if(list(x<0>{}), equal.to(x<9>{})), 324 nothing 325 )); 326 BOOST_HANA_CONSTANT_CHECK(equal( 327 find_if(list(x<0>{}), equal.to(x<0>{})), 328 just(x<0>{}) 329 )); 330 BOOST_HANA_CONSTANT_CHECK(equal( 331 find_if(list(x<0>{}, invalid<1>{}), equal.to(x<0>{})), 332 just(x<0>{}) 333 )); 334 BOOST_HANA_CONSTANT_CHECK(equal( 335 find_if(list(x<0>{}, invalid<1>{}, invalid<2>{}), equal.to(x<0>{})), 336 just(x<0>{}) 337 )); 338 339 BOOST_HANA_CONSTANT_CHECK(equal( 340 find_if(list(x<0>{}, x<1>{}), equal.to(x<9>{})), 341 nothing 342 )); 343 BOOST_HANA_CONSTANT_CHECK(equal( 344 find_if(list(x<0>{}, x<1>{}), equal.to(x<1>{})), 345 just(x<1>{}) 346 )); 347 BOOST_HANA_CONSTANT_CHECK(equal( 348 find_if(list(x<0>{}, x<1>{}, invalid<2>{}), equal.to(x<1>{})), 349 just(x<1>{}) 350 )); 351 BOOST_HANA_CONSTANT_CHECK(equal( 352 find_if(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), equal.to(x<1>{})), 353 just(x<1>{}) 354 )); 355 356 BOOST_HANA_CONSTANT_CHECK(equal( 357 find_if(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<9>{})), 358 nothing 359 )); 360 BOOST_HANA_CONSTANT_CHECK(equal( 361 find_if(list(x<0>{}, x<1>{}, x<2>{}), equal.to(x<2>{})), 362 just(x<2>{}) 363 )); 364 BOOST_HANA_CONSTANT_CHECK(equal( 365 find_if(list(x<0>{}, x<1>{}, x<2>{}, nothing), equal.to(x<2>{})), 366 just(x<2>{}) 367 )); 368 BOOST_HANA_CONSTANT_CHECK(equal( 369 find_if(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), equal.to(x<2>{})), 370 just(x<2>{}) 371 )); 372 373 // Make sure find_if works with an lvalue sequence. hana::tuple 374 // used to have a bug that broke this. 375 auto const const_lvalue = list(x<0>{}, x<1>{}, x<2>{}); 376 BOOST_HANA_CONSTANT_CHECK(equal( 377 find_if(const_lvalue, equal.to(x<1>{})), 378 just(x<1>{}) 379 )); 380 381 auto lvalue = list(x<0>{}, x<1>{}, x<2>{}); 382 BOOST_HANA_CONSTANT_CHECK(equal( 383 find_if(lvalue, equal.to(x<1>{})), 384 just(x<1>{}) 385 )); 386 } 387 388 ////////////////////////////////////////////////////////////////// 389 // find 390 ////////////////////////////////////////////////////////////////// 391 { 392 BOOST_HANA_CONSTANT_CHECK(equal( 393 find(list(), invalid<>{}), 394 nothing 395 )); 396 397 BOOST_HANA_CONSTANT_CHECK(equal( 398 find(list(x<0>{}), x<9>{}), 399 nothing 400 )); 401 BOOST_HANA_CONSTANT_CHECK(equal( 402 find(list(x<0>{}), x<0>{}), 403 just(x<0>{}) 404 )); 405 BOOST_HANA_CONSTANT_CHECK(equal( 406 find(list(x<0>{}, invalid<1>{}), x<0>{}), 407 just(x<0>{}) 408 )); 409 BOOST_HANA_CONSTANT_CHECK(equal( 410 find(list(x<0>{}, invalid<1>{}, invalid<2>{}), x<0>{}), 411 just(x<0>{}) 412 )); 413 414 BOOST_HANA_CONSTANT_CHECK(equal( 415 find(list(x<0>{}, x<1>{}), x<9>{}), 416 nothing 417 )); 418 BOOST_HANA_CONSTANT_CHECK(equal( 419 find(list(x<0>{}, x<1>{}), x<1>{}), 420 just(x<1>{}) 421 )); 422 BOOST_HANA_CONSTANT_CHECK(equal( 423 find(list(x<0>{}, x<1>{}, invalid<2>{}), x<1>{}), 424 just(x<1>{}) 425 )); 426 BOOST_HANA_CONSTANT_CHECK(equal( 427 find(list(x<0>{}, x<1>{}, invalid<2>{}, invalid<3>{}), x<1>{}), 428 just(x<1>{}) 429 )); 430 431 BOOST_HANA_CONSTANT_CHECK(equal( 432 find(list(x<0>{}, x<1>{}, x<2>{}), x<9>{}), 433 nothing 434 )); 435 BOOST_HANA_CONSTANT_CHECK(equal( 436 find(list(x<0>{}, x<1>{}, x<2>{}), x<2>{}), 437 just(x<2>{}) 438 )); 439 BOOST_HANA_CONSTANT_CHECK(equal( 440 find(list(x<0>{}, x<1>{}, x<2>{}, nothing), x<2>{}), 441 just(x<2>{}) 442 )); 443 BOOST_HANA_CONSTANT_CHECK(equal( 444 find(list(x<0>{}, x<1>{}, x<2>{}, nothing, nothing), x<2>{}), 445 just(x<2>{}) 446 )); 447 } 448 449 ////////////////////////////////////////////////////////////////// 450 // at_key 451 ////////////////////////////////////////////////////////////////// 452 { 453 BOOST_HANA_CONSTANT_CHECK(equal( 454 at_key(list(x<0>{}), x<0>{}), 455 x<0>{} 456 )); 457 458 BOOST_HANA_CONSTANT_CHECK(equal( 459 at_key(list(x<0>{}, x<1>{}), x<0>{}), 460 x<0>{} 461 )); 462 BOOST_HANA_CONSTANT_CHECK(equal( 463 at_key(list(x<0>{}, x<1>{}), x<1>{}), 464 x<1>{} 465 )); 466 467 BOOST_HANA_CONSTANT_CHECK(equal( 468 at_key(list(x<0>{}, x<1>{}, x<2>{}), x<0>{}), 469 x<0>{} 470 )); 471 BOOST_HANA_CONSTANT_CHECK(equal( 472 at_key(list(x<0>{}, x<1>{}, x<2>{}), x<1>{}), 473 x<1>{} 474 )); 475 BOOST_HANA_CONSTANT_CHECK(equal( 476 at_key(list(x<0>{}, x<1>{}, x<2>{}), x<2>{}), 477 x<2>{} 478 )); 479 } 480 481 ////////////////////////////////////////////////////////////////// 482 // contains 483 ////////////////////////////////////////////////////////////////// 484 { 485 BOOST_HANA_CONSTANT_CHECK(not_( 486 contains(list(), undefined{}) 487 )); 488 489 BOOST_HANA_CONSTANT_CHECK(not_( 490 contains(list(x<0>{}), x<999>{}) 491 )); 492 493 BOOST_HANA_CONSTANT_CHECK( 494 contains(list(x<0>{}), x<0>{}) 495 ); 496 497 BOOST_HANA_CONSTANT_CHECK( 498 contains(list(x<0>{}, x<1>{}), x<1>{}) 499 ); 500 501 BOOST_HANA_CONSTANT_CHECK( 502 contains(list(x<0>{}, x<1>{}, x<3>{}), x<3>{}) 503 ); 504 505 BOOST_HANA_CONSTEXPR_CHECK(contains(list(c(0)), c(0))); 506 BOOST_HANA_CONSTEXPR_CHECK(not_(contains(list(c(0)), c(1)))); 507 508 // infix application 509 BOOST_HANA_CONSTANT_CHECK( 510 list(x<0>{}, x<1>{}) ^contains^ x<1>{} 511 ); 512 } 513 514 ////////////////////////////////////////////////////////////////// 515 // in 516 ////////////////////////////////////////////////////////////////// 517 BOOST_HANA_CONSTEXPR_CHECK(c(0) ^in^ list(c(0))); 518 BOOST_HANA_CONSTEXPR_CHECK(not_(c(1) ^in^ list(c(0)))); 519 520 ////////////////////////////////////////////////////////////////// 521 // is_subset 522 ////////////////////////////////////////////////////////////////// 523 { 524 BOOST_HANA_CONSTANT_CHECK(is_subset( 525 list(), list(undefined{}) 526 )); 527 528 BOOST_HANA_CONSTANT_CHECK(not_(is_subset( 529 list(undefined{}), list() 530 ))); 531 532 BOOST_HANA_CONSTEXPR_CHECK(is_subset( 533 list(c(0)), list(c(0)) 534 )); 535 536 BOOST_HANA_CONSTEXPR_CHECK(is_subset( 537 list(c(0)), list(c(0), c(1)) 538 )); 539 540 BOOST_HANA_CONSTEXPR_CHECK(not_(is_subset( 541 list(c(0)), list(c(1)) 542 ))); 543 544 // infix application 545 BOOST_HANA_CONSTANT_CHECK( 546 list(x<0>{}) ^is_subset^ list(x<1>{}, x<0>{}) 547 ); 548 549 BOOST_HANA_CONSTANT_CHECK( 550 list(x<0>{}, x<1>{}) ^is_subset^ list(x<1>{}, x<0>{}) 551 ); 552 } 553 554 ////////////////////////////////////////////////////////////////// 555 // is_disjoint 556 ////////////////////////////////////////////////////////////////// 557 { 558 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 559 list(), 560 list() 561 )); 562 563 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 564 list(), 565 list(undefined{}) 566 )); 567 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 568 list(undefined{}), 569 list() 570 )); 571 572 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 573 list(x<0>{}), 574 list(x<1>{}) 575 )); 576 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 577 list(x<1>{}), 578 list(x<0>{}) 579 )); 580 BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint( 581 list(x<0>{}), 582 list(x<0>{}) 583 ))); 584 585 586 BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint( 587 list(x<0>{}, x<1>{}), 588 list(x<0>{}) 589 ))); 590 BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint( 591 list(x<0>{}), 592 list(x<0>{}, x<1>{}) 593 ))); 594 BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint( 595 list(x<1>{}, x<0>{}), 596 list(x<0>{}, x<1>{}) 597 ))); 598 BOOST_HANA_CONSTANT_CHECK(not_(is_disjoint( 599 list(x<0>{}, x<1>{}), 600 list(x<1>{}, x<2>{}) 601 ))); 602 BOOST_HANA_CONSTANT_CHECK(is_disjoint( 603 list(x<0>{}, x<1>{}), 604 list(x<2>{}, x<3>{}) 605 )); 606 } 607 } 608 }; 609 }}} // end namespace boost::hana::test 610 611 #endif // !BOOST_HANA_TEST_LAWS_SEARCHABLE_HPP 612