tmp/tests/pack.cpp

#include "catch_tmp.h"
#include <pack.h>

using namespace tmp;

template<typename...> struct MyPack {};

TEST_CASE("PackHead") {
	using P = Pack<void>;
	REQUIRE_SAME(void, PackHead<P>);
}

TEST_CASE("PackTrail") {
	SECTION("empty trail") {
		using P = Pack<void>;
		REQUIRE_SAME(Pack<>, PackTrail<P>);
	}

	SECTION("general case") {
		using P = Pack<void, bool, char, int>;
		using Expected = Pack<bool, char, int>;
		REQUIRE_SAME(Expected, PackTrail<P>);
	}
}

TEST_CASE("PackGet") {
	using P = Pack<void, bool, char, int>;

	using P0 = PackGet<P, 0>;
	using P1 = PackGet<P, 1>;
	using P2 = PackGet<P, 2>;
	using P3 = PackGet<P, 3>;

	REQUIRE_SAME(void, P0);
	REQUIRE_SAME(bool, P1);
	REQUIRE_SAME(char, P2);
	REQUIRE_SAME(int, P3);
}

TEST_CASE("PackPushFront") {
	SECTION("empty pack") {
		using Result = PackPushFront<Pack<>, void>;
		REQUIRE_SAME(Pack<void>, Result);
	}

	SECTION("general case") {
		using Input     = Pack<bool, char>;
		using Result    = PackPushFront<Input, void>;
		using Expected  = Pack<void, bool, char>;

		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("PackPushBack") {
	SECTION("empty pack") {
		using Result = PackPushBack<Pack<>, void>;
		REQUIRE_SAME(Pack<void>, Result);
	}

	SECTION("general case") {
		using Input     = Pack<bool, char>;
		using Result    = PackPushBack<Input, void>;
		using Expected  = Pack<bool, char, void>;

		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("PackCat") {
	SECTION("empty input") {
		using Result = PackCat<Pack<>, Pack<>>;
		REQUIRE_SAME(Pack<>, Result);
	}

	SECTION("empty lhs") {
		using Result = PackCat<Pack<>, Pack<void>>;
		REQUIRE_SAME(Pack<void>, Result);
	}

	SECTION("empty rhs") {
		using Result = PackCat<Pack<void>, Pack<>>;
		REQUIRE_SAME(Pack<void>, Result);
	}

	SECTION("general case") {
		using Result = PackCat<Pack<void, char>, Pack<int, int, int>>;
		using Expected = Pack<void, char, int, int, int>;
		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("PackReverse") {
	SECTION("empty input") {
		using Result = PackReverse<Pack<>>;
		REQUIRE_SAME(Pack<>, Result);
	}

	SECTION("one element") {
		using Result = PackReverse<Pack<void>>;
		REQUIRE_SAME(Pack<void>, Result);
	}

	SECTION("general case") {
		using Result = PackReverse<Pack<void, char, int, int, int>>;
		using Expected = Pack<int, int, int, char, void>;
		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("PackReplace") {
	SECTION("empty pack") {
		using Result = PackReplace<Pack<>, void, bool>;
		REQUIRE_SAME(Pack<>, Result);
	}

	SECTION("general case") {
		using Input     = Pack<void, bool, char, void, char, void>;
		using Result    = PackReplace<Input, void, bool>;
		using Expected  = Pack<bool, bool, char, bool, char, bool>;

		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("Repack") {
	SECTION("empty pack") {
		using Result = Repack<MyPack, Pack<>>;
		REQUIRE_SAME(MyPack<>, Result);
	}

	SECTION("general case") {
		using Input     = Pack<void, void, void>;
		using Result    = Repack<MyPack, Input>;
		using Expected  = MyPack<void, void, void>;

		REQUIRE_SAME(Expected, Result);
	}
}

TEST_CASE("AsPack") {
	SECTION("empty pack") {
		using Result = Repack<Pack, MyPack<>>;
		REQUIRE_SAME(Pack<>, Result);
	}

	SECTION("general case") {
		using Input     = MyPack<void, void, void>;
		using Result    = Repack<Pack, Input>;
		using Expected  = Pack<void, void, void>;

		REQUIRE_SAME(Expected, Result);
	}
}