libs/hana/test/_include/auto/cartesian_product.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_CARTESIAN_PRODUCT_HPP
   6 #define BOOST_HANA_TEST_AUTO_CARTESIAN_PRODUCT_HPP
   7
   8 #include <boost/hana/assert.hpp>
   9 #include <boost/hana/cartesian_product.hpp>
  10 #include <boost/hana/equal.hpp>
  11
  12 #include <laws/base.hpp>
  13 #include "test_case.hpp"
  14
  15
  16 TestCase test_cartesian_product{[]{
  17     namespace hana = boost::hana;
  18     using hana::test::ct_eq;
  19
  20     // 0 lists
  21     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  22         hana::cartesian_product(MAKE_TUPLE()),
  23         MAKE_TUPLE()
  24     ));
  25
  26     // 1 list
  27     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  28         hana::cartesian_product(MAKE_TUPLE(
  29             MAKE_TUPLE()
  30         )),
  31         MAKE_TUPLE()
  32     ));
  33
  34     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  35         hana::cartesian_product(MAKE_TUPLE(
  36             MAKE_TUPLE(ct_eq<0>{})
  37         )),
  38         MAKE_TUPLE(
  39             MAKE_TUPLE(ct_eq<0>{})
  40         )
  41     ));
  42
  43     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  44         hana::cartesian_product(MAKE_TUPLE(
  45             MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{})
  46         )),
  47         MAKE_TUPLE(
  48             MAKE_TUPLE(ct_eq<0>{}),
  49             MAKE_TUPLE(ct_eq<1>{})
  50         )
  51     ));
  52
  53     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  54         hana::cartesian_product(MAKE_TUPLE(
  55             MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
  56         )),
  57         MAKE_TUPLE(
  58             MAKE_TUPLE(ct_eq<0>{}),
  59             MAKE_TUPLE(ct_eq<1>{}),
  60             MAKE_TUPLE(ct_eq<2>{})
  61         )
  62     ));
  63
  64     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  65         hana::cartesian_product(MAKE_TUPLE(
  66             MAKE_TUPLE(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{})
  67         )),
  68         MAKE_TUPLE(
  69             MAKE_TUPLE(ct_eq<0>{}),
  70             MAKE_TUPLE(ct_eq<1>{}),
  71             MAKE_TUPLE(ct_eq<2>{}),
  72             MAKE_TUPLE(ct_eq<3>{})
  73         )
  74     ));
  75
  76     // 2 lists
  77     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  78         hana::cartesian_product(MAKE_TUPLE(
  79             MAKE_TUPLE(),
  80             MAKE_TUPLE()
  81         )),
  82         MAKE_TUPLE()
  83     ));
  84
  85     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  86         hana::cartesian_product(MAKE_TUPLE(
  87             MAKE_TUPLE(ct_eq<00>{}),
  88             MAKE_TUPLE()
  89         )),
  90         MAKE_TUPLE()
  91     ));
  92
  93     BOOST_HANA_CONSTANT_CHECK(hana::equal(
  94         hana::cartesian_product(MAKE_TUPLE(
  95             MAKE_TUPLE(ct_eq<00>{}),
  96             MAKE_TUPLE(ct_eq<10>{})
  97         )),
  98         MAKE_TUPLE(
  99             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{})
 100         )
 101     ));
 102
 103     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 104         hana::cartesian_product(MAKE_TUPLE(
 105             MAKE_TUPLE(ct_eq<00>{}, ct_eq<01>{}),
 106             MAKE_TUPLE(ct_eq<10>{})
 107         )),
 108         MAKE_TUPLE(
 109             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}),
 110             MAKE_TUPLE(ct_eq<01>{}, ct_eq<10>{})
 111         )
 112     ));
 113
 114     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 115         hana::cartesian_product(MAKE_TUPLE(
 116             MAKE_TUPLE(ct_eq<00>{}),
 117             MAKE_TUPLE(ct_eq<10>{}, ct_eq<11>{})
 118         )),
 119         MAKE_TUPLE(
 120             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}),
 121             MAKE_TUPLE(ct_eq<00>{}, ct_eq<11>{})
 122         )
 123     ));
 124
 125     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 126         hana::cartesian_product(MAKE_TUPLE(
 127             MAKE_TUPLE(ct_eq<00>{}, ct_eq<01>{}),
 128             MAKE_TUPLE(ct_eq<10>{}, ct_eq<11>{})
 129         )),
 130         MAKE_TUPLE(
 131             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}),
 132             MAKE_TUPLE(ct_eq<00>{}, ct_eq<11>{}),
 133             MAKE_TUPLE(ct_eq<01>{}, ct_eq<10>{}),
 134             MAKE_TUPLE(ct_eq<01>{}, ct_eq<11>{})
 135         )
 136     ));
 137
 138     // misc
 139     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 140         hana::cartesian_product(MAKE_TUPLE(
 141             MAKE_TUPLE(ct_eq<00>{}),
 142             MAKE_TUPLE(ct_eq<10>{}),
 143             MAKE_TUPLE(ct_eq<20>{}),
 144             MAKE_TUPLE(ct_eq<30>{}, ct_eq<31>{})
 145         )),
 146         MAKE_TUPLE(
 147             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<20>{}, ct_eq<30>{}),
 148             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<20>{}, ct_eq<31>{})
 149         )
 150     ));
 151
 152     BOOST_HANA_CONSTANT_CHECK(hana::equal(
 153         hana::cartesian_product(MAKE_TUPLE(
 154             MAKE_TUPLE(ct_eq<00>{}),
 155             MAKE_TUPLE(ct_eq<10>{}),
 156             MAKE_TUPLE(ct_eq<20>{}, ct_eq<21>{}),
 157             MAKE_TUPLE(ct_eq<30>{}, ct_eq<31>{})
 158         )),
 159         MAKE_TUPLE(
 160             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<20>{}, ct_eq<30>{}),
 161             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<20>{}, ct_eq<31>{}),
 162             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<21>{}, ct_eq<30>{}),
 163             MAKE_TUPLE(ct_eq<00>{}, ct_eq<10>{}, ct_eq<21>{}, ct_eq<31>{})
 164         )
 165     ));
 166
 167
 168     // cartesian_product in a constexpr context
 169 #ifndef MAKE_TUPLE_NO_CONSTEXPR
 170     static_assert(hana::equal(
 171         hana::cartesian_product(MAKE_TUPLE(
 172             MAKE_TUPLE(1),
 173             MAKE_TUPLE('a', 'b')
 174         )),
 175         MAKE_TUPLE(
 176             MAKE_TUPLE(1, 'a'),
 177             MAKE_TUPLE(1, 'b')
 178         )
 179     ), "");
 180
 181     static_assert(hana::equal(
 182         hana::cartesian_product(MAKE_TUPLE(
 183             MAKE_TUPLE(1, 2),
 184             MAKE_TUPLE('a')
 185         )),
 186         MAKE_TUPLE(
 187             MAKE_TUPLE(1, 'a'),
 188             MAKE_TUPLE(2, 'a')
 189         )
 190     ), "");
 191
 192     static_assert(hana::equal(
 193         hana::cartesian_product(MAKE_TUPLE(
 194             MAKE_TUPLE(1, 2),
 195             MAKE_TUPLE('a', 'b')
 196         )),
 197         MAKE_TUPLE(
 198             MAKE_TUPLE(1, 'a'),
 199             MAKE_TUPLE(1, 'b'),
 200             MAKE_TUPLE(2, 'a'),
 201             MAKE_TUPLE(2, 'b')
 202         )
 203     ), "");
 204
 205     static_assert(hana::equal(
 206         hana::cartesian_product(MAKE_TUPLE(
 207             MAKE_TUPLE(1),
 208             MAKE_TUPLE('a'),
 209             MAKE_TUPLE(1.f),
 210             MAKE_TUPLE(1l, 2l)
 211         )),
 212         MAKE_TUPLE(
 213             MAKE_TUPLE(1, 'a', 1.f, 1l),
 214             MAKE_TUPLE(1, 'a', 1.f, 2l)
 215         )
 216     ), "");
 217
 218     static_assert(hana::equal(
 219         hana::cartesian_product(MAKE_TUPLE(
 220             MAKE_TUPLE(1),
 221             MAKE_TUPLE('a'),
 222             MAKE_TUPLE(1.f),
 223             MAKE_TUPLE(1l, 2l),
 224             MAKE_TUPLE(nullptr)
 225         )),
 226         MAKE_TUPLE(
 227             MAKE_TUPLE(1, 'a', 1.f, 1l, nullptr),
 228             MAKE_TUPLE(1, 'a', 1.f, 2l, nullptr)
 229         )
 230     ), "");
 231 #endif
 232 }};
 233
 234 #endif // !BOOST_HANA_TEST_AUTO_CARTESIAN_PRODUCT_HPP