FATAL_TEST(numerics, data_bits) {
FATAL_EXPECT_EQ(1, data_bits<bool>::value);
FATAL_EXPECT_EQ(CHAR_BIT, data_bits<char>::value);
FATAL_EXPECT_EQ(CHAR_BIT, data_bits<int8_t>::value);
FATAL_EXPECT_EQ(2 * CHAR_BIT, data_bits<int16_t>::value);
FATAL_EXPECT_EQ(4 * CHAR_BIT, data_bits<int32_t>::value);
}
void tokenizer_test(T &&data, std::vector<char const *> const &expected) {
auto i = expected.begin();
for (auto const &token: Tokenizer(std::forward<T>(data))) {
FATAL_ASSERT_NE(expected.end(), i);
FATAL_EXPECT_EQ(*i, token);
++i;
}
FATAL_EXPECT_EQ(expected.end(), i);
}
as_integral_constant_test() {
{
using type = std::integral_constant<T, std::numeric_limits<T>::min()>;
FATAL_EXPECT_SAME<T, decltype(as_integral(type()))>();
FATAL_EXPECT_EQ(type::value, as_integral(type()));
}
{
using type = std::integral_constant<T, std::numeric_limits<T>::max()>;
FATAL_EXPECT_SAME<T, decltype(as_integral(type()))>();
FATAL_EXPECT_EQ(type::value, as_integral(type()));
}
}
FATAL_TEST(bytes_hasher, sanity_check) {
auto const hello = "hello";
auto const end = std::next(hello, std::strlen(hello));
auto const h1 = *bytes_hasher<>()('h')('e')('l')('l')('o');
auto const h2 = *bytes_hasher<>()(hello, end);
auto const h3 = *bytes_hasher<>()(hello, std::strlen(hello));
FATAL_EXPECT_EQ(h1, h2);
FATAL_EXPECT_EQ(h1, h3);
FATAL_EXPECT_EQ(h2, h3);
}
FATAL_TEST(traits, safe_overload_nonvariadic) {
overloading_test def;
FATAL_EXPECT_EQ(ctor::def, def.type);
overloading_test copy(def);
FATAL_EXPECT_EQ(ctor::copy, copy.type);
overloading_test move(std::move(def));
FATAL_EXPECT_EQ(ctor::move, move.type);
overloading_test universal(0);
FATAL_EXPECT_EQ(ctor::universal, universal.type);
overloading_test foo{Foo()};
FATAL_EXPECT_EQ(ctor::universal, foo.type);
}
FATAL_TEST(bytes_hasher, sanity_check_2) {
auto const r = *bytes_hasher<>()("hello", 5)(", ", 2)("world", 5)('!')
(" with", 5)(' ')("some", 4)(" extra", 6)(" ", 1)('s')("trings", 6);
auto const u = *bytes_hasher<>()("hello, world! with some extra strings", 37);
FATAL_EXPECT_EQ(r, u);
}
void check_default_ctor(TData &&...) {
static_assert(sizeof...(TTags) == sizeof...(TData), "size mismatch");
std::tuple<TData...> expected;
tuple<type_pair<TTags, typename std::decay<TData>::type>...> actual;
FATAL_EXPECT_EQ(expected, actual.data());
}
void csv_tokenizer_test(
T &&data,
std::vector<std::vector<char const *>> const &expected
) {
auto i = expected.begin();
for (auto const &line: csv_tokenizer(std::forward<T>(data))) {
FATAL_ASSERT_NE(expected.end(), i);
auto j = i->begin();
for (auto const &token: line) {
FATAL_ASSERT_NE(i->end(), j);
FATAL_EXPECT_EQ(*j, token);
++j;
}
FATAL_EXPECT_EQ(i->end(), j);
++i;
}
FATAL_EXPECT_EQ(expected.end(), i);
}
void check_tuple(TData &&...data) {
static_assert(sizeof...(TTags) == sizeof...(TData), "size mismatch");
auto const tuple = std::make_tuple(data...);
fatal::tuple<type_pair<TTags, typename std::decay<TData>::type>...> actual(
std::forward<TData>(data)...
);
FATAL_EXPECT_EQ(tuple, actual.data());
}
void check_is_template() {
bool expected = Expected;
using checker = is_template<TTemplates...>;
bool actual = checker::template type<T>::value;
if (expected != actual) {
FATAL_LOG(ERROR) << "checker: " << type_str<checker>();
FATAL_LOG(ERROR) << "type: " << type_str<T>();
FATAL_EXPECT_EQ(expected, actual);
}
}
void check_forwarding_ctor_tuple(TData &&...data) {
static_assert(sizeof...(TTags) == sizeof...(TData), "size mismatch");
std::tuple<TData...> expected(data...);
tuple<type_pair<TTags, typename std::decay<TData>::type>...> actual(
std::make_tuple(std::forward<TData>(data)...)
);
FATAL_EXPECT_EQ(expected, actual.data());
}
FATAL_TEST(enums, declare_enum) {
FATAL_EXPECT_EQ(test_enum::state0, static_cast<test_enum>(0));
FATAL_EXPECT_EQ(test_enum::state1, static_cast<test_enum>(4));
FATAL_EXPECT_EQ(test_enum::state2, static_cast<test_enum>(97));
FATAL_EXPECT_EQ(test_enum::state3, static_cast<test_enum>(98));
FATAL_EXPECT_EQ(custom_enum::field0, static_cast<custom_enum>(0));
FATAL_EXPECT_EQ(custom_enum::field1, static_cast<custom_enum>(37));
FATAL_EXPECT_EQ(custom_enum::field2, static_cast<custom_enum>(38));
}
static void check(TExpected &&expected, TActual &&actual) {
using tuple = typename std::decay<TExpected>::type;
using size = std::tuple_size<tuple>;
using tail_size = std::integral_constant<std::size_t, sizeof...(Args) + 1>;
static_assert(tail_size::value <= size::value, "out of bounds");
using index = std::integral_constant<
std::size_t, size::value - tail_size::value
>;
FATAL_EXPECT_EQ(std::get<index::value>(expected), actual.template get<T>());
check_get_helper<Args...>::check(
std::forward<TExpected>(expected),
std::forward<TActual>(actual)
);
}
FATAL_TEST(traits, safe_overload_variadic_t) {
variadic_overloading_test_t def;
FATAL_EXPECT_EQ(ctor::def, def.type);
variadic_overloading_test_t copy(def);
FATAL_EXPECT_EQ(ctor::copy, copy.type);
variadic_overloading_test_t move(std::move(def));
FATAL_EXPECT_EQ(ctor::move, move.type);
variadic_overloading_test_t i(0);
FATAL_EXPECT_EQ(ctor::universal, i.type);
variadic_overloading_test_t foo{Foo()};
FATAL_EXPECT_EQ(ctor::universal, foo.type);
variadic_overloading_test_t universal(copy, move);
FATAL_EXPECT_EQ(ctor::universal, universal.type);
}
FATAL_TEST(tuple, ctor) {
auto tuple = make_tuple<W, X, Y, Z>(
std::string("hello"),
10,
std::make_pair(true, 5.6),
std::vector<int>{9, 100}
);
FATAL_EXPECT_EQ("hello", tuple.get<W>());
FATAL_EXPECT_EQ(10, tuple.get<X>());
FATAL_EXPECT_EQ(true, tuple.get<Y>().first);
FATAL_EXPECT_EQ(5.6, tuple.get<Y>().second);
FATAL_EXPECT_EQ(2, tuple.get<Z>().size());
FATAL_EXPECT_EQ(9, tuple.get<Z>()[0]);
FATAL_EXPECT_EQ(100, tuple.get<Z>()[1]);
}
FATAL_TEST(enums, enum_to_string) {
FATAL_EXPECT_EQ(nullptr, enum_to_string(static_cast<test_enum>(-1)));
FATAL_EXPECT_EQ("state0", enum_to_string(test_enum::state0));
FATAL_EXPECT_EQ("state1", enum_to_string(test_enum::state1));
FATAL_EXPECT_EQ("state2", enum_to_string(test_enum::state2));
FATAL_EXPECT_EQ("state3", enum_to_string(test_enum::state3));
FATAL_EXPECT_EQ("", enum_to_string(static_cast<test_enum>(-1), ""));
FATAL_EXPECT_EQ("state0", enum_to_string(test_enum::state0, ""));
FATAL_EXPECT_EQ("state1", enum_to_string(test_enum::state1, ""));
FATAL_EXPECT_EQ("state2", enum_to_string(test_enum::state2, ""));
FATAL_EXPECT_EQ("state3", enum_to_string(test_enum::state3, ""));
FATAL_EXPECT_EQ(nullptr, enum_to_string(static_cast<custom_enum>(-1)));
FATAL_EXPECT_EQ("field0", enum_to_string(custom_enum::field0));
FATAL_EXPECT_EQ("field1", enum_to_string(custom_enum::field1));
FATAL_EXPECT_EQ("field2", enum_to_string(custom_enum::field2));
FATAL_EXPECT_EQ("", enum_to_string(static_cast<custom_enum>(-1), ""));
FATAL_EXPECT_EQ("field0", enum_to_string(custom_enum::field0, ""));
FATAL_EXPECT_EQ("field1", enum_to_string(custom_enum::field1, ""));
FATAL_EXPECT_EQ("field2", enum_to_string(custom_enum::field2, ""));
}
void check_qualifier() {
FATAL_EXPECT_EQ(Expected, (member_function_qualifier<T>::value));
}
void operator ()(indexed<Actual, Index>) const {
FATAL_EXPECT_SAME<Expected, Actual>();
FATAL_EXPECT_EQ(ExpectedIndex, Index);
}
FATAL_TEST(enums, to_string) {
{
using traits = enum_traits<test_enum>;
FATAL_EXPECT_EQ(nullptr, traits::to_string(static_cast<test_enum>(-1)));
FATAL_EXPECT_EQ("state0", traits::to_string(test_enum::state0));
FATAL_EXPECT_EQ("state1", traits::to_string(test_enum::state1));
FATAL_EXPECT_EQ("state2", traits::to_string(test_enum::state2));
FATAL_EXPECT_EQ("state3", traits::to_string(test_enum::state3));
FATAL_EXPECT_EQ("", traits::to_string(static_cast<test_enum>(-1), ""));
FATAL_EXPECT_EQ("state0", traits::to_string(test_enum::state0, ""));
FATAL_EXPECT_EQ("state1", traits::to_string(test_enum::state1, ""));
FATAL_EXPECT_EQ("state2", traits::to_string(test_enum::state2, ""));
FATAL_EXPECT_EQ("state3", traits::to_string(test_enum::state3, ""));
}
{
using traits = enum_traits<custom_enum>;
FATAL_EXPECT_EQ(nullptr, traits::to_string(static_cast<custom_enum>(-1)));
FATAL_EXPECT_EQ("field0", traits::to_string(custom_enum::field0));
FATAL_EXPECT_EQ("field1", traits::to_string(custom_enum::field1));
FATAL_EXPECT_EQ("field2", traits::to_string(custom_enum::field2));
FATAL_EXPECT_EQ("", traits::to_string(static_cast<custom_enum>(-1), ""));
FATAL_EXPECT_EQ("field0", traits::to_string(custom_enum::field0, ""));
FATAL_EXPECT_EQ("field1", traits::to_string(custom_enum::field1, ""));
FATAL_EXPECT_EQ("field2", traits::to_string(custom_enum::field2, ""));
}
}
as_integral_constant_test() {
using type = std::integral_constant<T, Value>;
FATAL_EXPECT_SAME<T, decltype(as_integral(type()))>();
FATAL_EXPECT_EQ(Value, as_integral(type()));
}
