boost/hana
2
0
Fork 0
mirror of https://github.com/boostorg/hana.git synced 2026-02-02 08:52:11 +00:00
Code Issues Projects Releases Wiki Activity
Files
daaba5dfd86e6f2d7dbce8b8b892011e508530ae
hana/test/map.cpp
Louis Dionne daaba5dfd8 [Map] Provide model of Foldable, improve docs and add insert method. 
Fixes #41
2015-04-11 12:09:01 -04:00

444 lines
14 KiB
C++
Raw Blame History

/*
@copyright Louis Dionne 2015
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
*/
#include <boost/hana/map.hpp>
#include <boost/hana/assert.hpp>
#include <boost/hana/maybe.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <laws/base.hpp>
#include <laws/comparable.hpp>
#include <laws/foldable.hpp>
#include <laws/searchable.hpp>
#include <test/minimal_product.hpp>
#include <test/minimal_record.hpp>
#include <test/seq.hpp>
using namespace boost::hana;
template <int i>
auto key = test::ct_eq<i>{};
template <int i>
auto val = test::ct_eq<-i>{};
template <int i, int j>
auto p = test::minimal_product(key<i>, val<j>);
struct undefined { };
int main() {
auto list = test::seq; (void)list;
auto foldable = test::seq; (void)foldable;
auto record = test::minimal_record; (void)record;
using L = test::Seq;
auto eq_maps = make<Tuple>(
make<Map>(),
make<Map>(p<1, 1>),
make<Map>(p<1, 2>),
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
);
(void)eq_maps;
auto eq_keys = make<Tuple>(key<1>, key<4>);
(void)eq_keys;
#if BOOST_HANA_TEST_PART == 1
//////////////////////////////////////////////////////////////////////////
// Make sure we do not instantiate rogue constructors when doing copies
//////////////////////////////////////////////////////////////////////////
{
auto expr = make<Map>(
test::minimal_product(1, test::trap_construct{})
);
auto implicit_copy = expr; (void)implicit_copy;
decltype(expr) explicit_copy(expr); (void)explicit_copy;
}
//////////////////////////////////////////////////////////////////////////
// keys
//////////////////////////////////////////////////////////////////////////
{
BOOST_HANA_CONSTANT_CHECK(equal(
keys(make<Map>()),
list()
));
BOOST_HANA_CONSTANT_CHECK(equal(
keys(make<Map>(p<1, 1>)),
list(key<1>)
));
BOOST_HANA_CONSTANT_CHECK(
keys(make<Map>(p<1, 1>, p<2, 2>))
^in^ permutations(list(key<1>, key<2>))
);
BOOST_HANA_CONSTANT_CHECK(
keys(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>))
^in^ permutations(list(key<1>, key<2>, key<3>))
);
}
//////////////////////////////////////////////////////////////////////////
// values
//////////////////////////////////////////////////////////////////////////
{
BOOST_HANA_CONSTANT_CHECK(equal(
values(make<Map>()),
list()
));
BOOST_HANA_CONSTANT_CHECK(equal(
values(make<Map>(p<1, 1>)),
list(val<1>)
));
BOOST_HANA_CONSTANT_CHECK(
values(make<Map>(p<1, 1>, p<2, 2>))
^in^ permutations(list(val<1>, val<2>))
);
BOOST_HANA_CONSTANT_CHECK(
values(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>))
^in^ permutations(list(val<1>, val<2>, val<3>))
);
}
//////////////////////////////////////////////////////////////////////////
// insert
//////////////////////////////////////////////////////////////////////////
{
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(), p<1, 1>),
make<Map>(p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>), p<1, 99>),
make<Map>(p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>), p<2, 2>),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>), p<1, 99>),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>), p<2, 99>),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>), p<3, 3>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>), p<1, 99>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>), p<2, 99>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>), p<3, 99>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
insert(make<Map>(p<1, 1>, p<2, 2>, p<3, 3>), p<4, 4>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>, p<4, 4>)
));
}
#elif BOOST_HANA_TEST_PART == 2
//////////////////////////////////////////////////////////////////////////
// Conversions
//////////////////////////////////////////////////////////////////////////
{
// Record -> Map
{
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(record(test::ct_eq<1>{}, test::ct_eq<2>{})),
make<Map>(
make<Pair>(test::member1, test::ct_eq<1>{}),
make<Pair>(test::member2, test::ct_eq<2>{})
)
));
}
// Foldable -> Map
{
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable()),
make<Map>()
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>)),
make<Map>(p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<2, 2>)),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<2, 2>, p<3, 3>)),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
// with duplicates
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<1, 99>)),
make<Map>(p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<2, 2>, p<1, 99>)),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<2, 2>, p<1, 99>, p<2, 99>)),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
to<Map>(foldable(p<1, 1>, p<2, 2>, p<1, 99>, p<2, 99>, p<3, 3>)),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>)
));
}
// Map -> Sequence
{
auto check = [=](auto ...xs) {
BOOST_HANA_CONSTANT_CHECK(
to<L>(make<Map>(xs...)) ^in^ permutations(list(xs...))
);
};
check();
check(p<1, 1>);
check(p<1, 1>, p<2, 2>);
check(p<1, 1>, p<2, 2>, p<3, 3>);
check(p<1, 1>, p<2, 2>, p<3, 3>, p<4, 4>);
}
}
#elif BOOST_HANA_TEST_PART == 3
//////////////////////////////////////////////////////////////////////////
// Comparable
//////////////////////////////////////////////////////////////////////////
{
// equal
{
BOOST_HANA_CONSTANT_CHECK(equal(
make<Map>(),
make<Map>()
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>),
make<Map>())
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(),
make<Map>(p<1, 1>)
)));
BOOST_HANA_CONSTANT_CHECK(equal(
make<Map>(p<1, 1>),
make<Map>(p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>),
make<Map>(p<1, 2>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>),
make<Map>(p<2, 1>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>),
make<Map>(p<1, 1>, p<2, 2>))
));
BOOST_HANA_CONSTANT_CHECK(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 1>, p<2, 2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<2, 2>, p<1, 1>)
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<9, 1>, p<2, 2>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 9>, p<2, 2>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 1>, p<9, 2>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 1>, p<2, 9>))
));
BOOST_HANA_CONSTANT_CHECK(not_(equal(
make<Map>(p<1, 1>, p<2, 2>),
make<Map>(p<1, 1>, p<2, 2>, p<3, 3>))
));
}
// laws
test::TestComparable<Map>{eq_maps};
}
#elif BOOST_HANA_TEST_PART == 4
//////////////////////////////////////////////////////////////////////////
// Searchable
//////////////////////////////////////////////////////////////////////////
{
// any_of
{
BOOST_HANA_CONSTANT_CHECK(
not_(any_of(make<Map>(), equal.to(key<1>)))
);
BOOST_HANA_CONSTANT_CHECK(
any_of(make<Map>(p<1, 1>), equal.to(key<1>))
);
BOOST_HANA_CONSTANT_CHECK(
not_(any_of(make<Map>(p<1, 1>), equal.to(key<2>)))
);
BOOST_HANA_CONSTANT_CHECK(
any_of(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<1>))
);
BOOST_HANA_CONSTANT_CHECK(
any_of(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<2>))
);
BOOST_HANA_CONSTANT_CHECK(
not_(any_of(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<3>)))
);
}
// find_if
{
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(), equal.to(key<1>)),
nothing
));
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(p<1, 1>), equal.to(key<1>)),
just(val<1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(p<1, 1>), equal.to(key<2>)),
nothing
));
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<1>)),
just(val<1>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<2>)),
just(val<2>)
));
BOOST_HANA_CONSTANT_CHECK(equal(
find_if(make<Map>(p<1, 1>, p<2, 2>), equal.to(key<3>)),
nothing
));
}
// laws
test::TestSearchable<Map>{eq_maps, eq_keys};
}
#elif BOOST_HANA_TEST_PART == 5
//////////////////////////////////////////////////////////////////////////
// Foldable
//////////////////////////////////////////////////////////////////////////
{
// fold.left
{
test::_injection<0> f{};
test::ct_eq<999> state{};
auto check = [=](auto ...pairs) {
BOOST_HANA_CONSTANT_CHECK(
fold.left(make<Map>(pairs...), state, f)
^in^
transform(permutations(list(pairs...)), [=](auto xs) {
return fold.left(xs, state, f);
})
);
};
BOOST_HANA_CONSTANT_CHECK(equal(
fold.left(make<Map>(), state, undefined{}),
state
));
check(p<1, 1>);
check(p<1, 1>, p<2, 2>);
check(p<1, 1>, p<2, 2>, p<3, 3>);
check(p<1, 1>, p<2, 2>, p<3, 3>, p<4, 4>);
}
// fold.right
{
test::_injection<0> f{};
test::ct_eq<999> state{};
auto check = [=](auto ...pairs) {
BOOST_HANA_CONSTANT_CHECK(
fold.right(make<Map>(pairs...), state, f)
^in^
transform(permutations(list(pairs...)), [=](auto xs) {
return fold.right(xs, state, f);
})
);
};
BOOST_HANA_CONSTANT_CHECK(equal(
fold.right(make<Map>(), state, undefined{}),
state
));
check(p<1, 1>);
check(p<1, 1>, p<2, 2>);
check(p<1, 1>, p<2, 2>, p<3, 3>);
check(p<1, 1>, p<2, 2>, p<3, 3>, p<4, 4>);
}
// unpack
{
test::_injection<0> f{};
auto check = [=](auto ...pairs) {
BOOST_HANA_CONSTANT_CHECK(
unpack(make<Map>(pairs...), f)
^in^
transform(permutations(list(pairs...)), [=](auto xs) {
return unpack(xs, f);
})
);
};
check();
check(p<1, 1>);
check(p<1, 1>, p<2, 2>);
check(p<1, 1>, p<2, 2>, p<3, 3>);
check(p<1, 1>, p<2, 2>, p<3, 3>, p<4, 4>);
}
// laws
test::TestFoldable<Map>{eq_maps};
}
#endif
}
Reference in New Issue View Git Blame Copy Permalink