ceph/src/boost/libs/hana/test/_include/auto/any_of.hpp

   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_AUTO_ANY_OF_HPP
   6 #define BOOST_HANA_TEST_AUTO_ANY_OF_HPP
   7
   8 #include <boost/hana/any_of.hpp>
   9 #include <boost/hana/assert.hpp>
  10 #include <boost/hana/bool.hpp>
  11 #include <boost/hana/equal.hpp>
  12 #include <boost/hana/not.hpp>
  13
  14 #include "test_case.hpp"
  15 #include <laws/base.hpp>
  16
  17
  18 TestCase test_any_of{[]{
  19     namespace hana = boost::hana;
  20     using hana::test::ct_eq;
  21
  22     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  23         MAKE_TUPLE(),
  24         [](auto) { return hana::true_c; }
  25     )));
  26
  27     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  28         MAKE_TUPLE(ct_eq<0>{}),
  29         [](auto) { return hana::true_c; }
  30     ));
  31     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  32         MAKE_TUPLE(ct_eq<0>{}),
  33         [](auto) { return hana::false_c; }
  34     )));
  35     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  36         MAKE_TUPLE(ct_eq<0>{}),
  37         hana::equal.to(ct_eq<0>{})
  38     ));
  39     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  40         MAKE_TUPLE(ct_eq<0>{}),
  41         hana::equal.to(ct_eq<999>{})
  42     )));
  43
  44     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  45         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  46         [](auto) { return hana::false_c; }
  47     )));
  48     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  49         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  50         [](auto) { return hana::true_c; }
  51     ));
  52     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  53         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  54         hana::equal.to(ct_eq<0>{})
  55     ));
  56     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  57         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  58         hana::equal.to(ct_eq<1>{})
  59     ));
  60     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  61         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}),
  62         hana::equal.to(ct_eq<999>{})
  63     )));
  64
  65     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  66         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  67         [](auto) { return hana::false_c; }
  68     )));
  69     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  70         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  71         [](auto) { return hana::true_c; }
  72     ));
  73     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  74         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  75         hana::equal.to(ct_eq<0>{})
  76     ));
  77     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  78         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  79         hana::equal.to(ct_eq<1>{})
  80     ));
  81     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  82         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  83         hana::equal.to(ct_eq<2>{})
  84     ));
  85     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  86         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
  87         hana::equal.to(ct_eq<999>{})
  88     )));
  89
  90     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
  91         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
  92         [](auto) { return hana::false_c; }
  93     )));
  94     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  95         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
  96         [](auto) { return hana::true_c; }
  97     ));
  98     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
  99         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 100         hana::equal.to(ct_eq<0>{})
 101     ));
 102     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 103         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 104         hana::equal.to(ct_eq<1>{})
 105     ));
 106     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 107         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 108         hana::equal.to(ct_eq<2>{})
 109     ));
 110     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 111         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 112         hana::equal.to(ct_eq<3>{})
 113     ));
 114     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
 115         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
 116         hana::equal.to(ct_eq<999>{})
 117     )));
 118
 119     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
 120         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 121         [](auto) { return hana::false_c; }
 122     )));
 123     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 124         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 125         [](auto) { return hana::true_c; }
 126     ));
 127     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 128         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 129         hana::equal.to(ct_eq<0>{})
 130     ));
 131     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 132         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 133         hana::equal.to(ct_eq<1>{})
 134     ));
 135     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 136         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 137         hana::equal.to(ct_eq<2>{})
 138     ));
 139     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 140         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 141         hana::equal.to(ct_eq<3>{})
 142     ));
 143     BOOST_HANA_CONSTANT_CHECK(hana::any_of(
 144         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 145         hana::equal.to(ct_eq<4>{})
 146     ));
 147     BOOST_HANA_CONSTANT_CHECK(hana::not_(hana::any_of(
 148         MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}, ct_eq<4>{}),
 149         hana::equal.to(ct_eq<999>{})
 150     )));
 151
 152     // Make sure `any_of` short-circuits with runtime predicates
 153     // See http://stackoverflow.com/q/42012512/627587
 154     {
 155         {
 156             int counter = 0;
 157             auto tuple = MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{});
 158             hana::any_of(tuple, [&](auto) { ++counter; return true; });
 159             BOOST_HANA_RUNTIME_CHECK(counter == 1);
 160         }
 161         {
 162             int counter = 0;
 163             auto tuple = MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{});
 164             hana::any_of(tuple, [&](auto x) -> bool {
 165                 ++counter;
 166                 return hana::equal(x, ct_eq<1>{});
 167             });
 168             BOOST_HANA_RUNTIME_CHECK(counter == 2);
 169         }
 170     }
 171 }};
 172
 173 #endif // !BOOST_HANA_TEST_AUTO_ANY_OF_HPP