326 lines
15 KiB
C++
326 lines
15 KiB
C++
#include <catch.hpp>
|
|
#include "common.h"
|
|
|
|
#include <pfor/clusters.h>
|
|
#include <pfor/expression/operand.h>
|
|
#include <pfor/expression/operators.h>
|
|
|
|
#define N 10
|
|
|
|
TEST_CASE("Cluster") {
|
|
int a_[N], b_[N], c_[N], d_[N], e_[N], f_[N], g_[N];
|
|
|
|
auto a = pfor::Operand<int*, class IDa>(a_);
|
|
auto b = pfor::Operand<int*, class IDb>(b_);
|
|
auto c = pfor::Operand<int*, class IDc>(c_);
|
|
auto d = pfor::Operand<int*, class IDd>(d_);
|
|
auto e = pfor::Operand<int*, class IDe>(e_);
|
|
auto f = pfor::Operand<int*, class IDf>(f_);
|
|
auto g = pfor::Operand<int*, class IDg>(g_);
|
|
|
|
using UE0 = decltype(a+b);
|
|
using UE1 = decltype(d = b+c);
|
|
using UE2 = decltype(e = g);
|
|
using UE3 = decltype(b = a);
|
|
using UE4 = decltype(f = f+f);
|
|
using UE5 = decltype(g = f);
|
|
using UE6 = decltype(c = d);
|
|
using UE7 = decltype(g = b);
|
|
|
|
using E0 = std::decay_t<decltype(V(UE0))>;
|
|
using E1 = std::decay_t<decltype(V(UE1))>;
|
|
using E2 = std::decay_t<decltype(V(UE1), V(UE2))>;
|
|
using E3 = std::decay_t<decltype(V(UE1), V(UE2), V(UE3))>;
|
|
using E4 = std::decay_t<decltype(V(UE4), V(UE5), V(UE6))>;
|
|
using E5 = std::decay_t<decltype(V(UE1), V(UE2), V(UE4), V(UE6))>;
|
|
using E6 = std::decay_t<decltype(V(UE2), V(UE3), V(UE4), V(UE7), V(UE6))>;
|
|
|
|
using S0 = pfor::Pack<UE0>;
|
|
using S1 = pfor::Pack<UE1>;
|
|
using S2 = pfor::Pack<UE1, UE2>;
|
|
using S3 = pfor::Pack<UE1, UE2, UE3>;
|
|
using S4 = pfor::Pack<UE4, UE5, UE6>;
|
|
using S5 = pfor::Pack<UE1, UE2, UE4, UE6>;
|
|
|
|
SECTION("SplitComma") {
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E0>, S0>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E1>, S1>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E2>, S2>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E3>, S3>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E4>, S4>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::SplitComma<E5>, S5>);
|
|
}
|
|
|
|
SECTION("ReadList") {
|
|
using R0 = pfor::Pack<class IDa, class IDb>;
|
|
using R1 = pfor::Pack<class IDb, class IDc>;
|
|
using R2 = pfor::Pack<class IDb, class IDc, class IDg>;
|
|
using R3 = pfor::Pack<class IDb, class IDc, class IDg, class IDa>;
|
|
using R4 = pfor::Pack<class IDf, class IDf, class IDf, class IDd>;
|
|
using R5 = pfor::Pack<class IDb, class IDc, class IDg, class IDf, class IDf, class IDd>;
|
|
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E0>>, R0>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E1>>, R1>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E2>>, R2>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E3>>, R3>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E4>>, R4>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ReadList<pfor::expr::ExpressionTagger<E5>>, R5>);
|
|
}
|
|
|
|
SECTION("WriteList") {
|
|
using W0 = pfor::Pack<>;
|
|
using W1 = pfor::Pack<class IDd>;
|
|
using W2 = pfor::Pack<class IDd, class IDe>;
|
|
using W3 = pfor::Pack<class IDd, class IDe, class IDb>;
|
|
using W4 = pfor::Pack<class IDf, class IDg, class IDc>;
|
|
using W5 = pfor::Pack<class IDd, class IDe, class IDf, class IDc>;
|
|
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E0>>, W0>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E1>>, W1>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E2>>, W2>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E3>>, W3>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E4>>, W4>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::WriteList<pfor::expr::ExpressionTagger<E5>>, W5>);
|
|
}
|
|
|
|
SECTION("ComparatorUIntToType") {
|
|
TEST(REQUIRE, pfor::ComparatorUIntToType<pfor::UIntToType<0>, pfor::UIntToType<1>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntToType<pfor::UIntToType<0>, pfor::UIntToType<0>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntToType<pfor::UIntToType<1>, pfor::UIntToType<0>>::value);
|
|
}
|
|
|
|
SECTION("ComparatorUIntPack") {
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<>, UIntsToPack<>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<0>, UIntsToPack<>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<0, 1>, UIntsToPack<>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<1>, UIntsToPack<0>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<1>, UIntsToPack<0, 1, 2>>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorUIntPack<UIntsToPack<2>, UIntsToPack<0, 1, 2>>::value);
|
|
|
|
TEST(REQUIRE, pfor::ComparatorUIntPack<UIntsToPack<>, UIntsToPack<1>>::value);
|
|
TEST(REQUIRE, pfor::ComparatorUIntPack<UIntsToPack<0>, UIntsToPack<1>>::value);
|
|
TEST(REQUIRE, pfor::ComparatorUIntPack<UIntsToPack<0, 1, 2>, UIntsToPack<1>>::value);
|
|
TEST(REQUIRE, pfor::ComparatorUIntPack<UIntsToPack<0, 1, 2>, UIntsToPack<1, 3>>::value);
|
|
|
|
TEST(REQUIRE, pfor::ComparatorUIntPack<UIntsToPack<1, 2>, UIntsToPack<1, 3>>::value);
|
|
}
|
|
|
|
SECTION("ComparatorExpressionInfo") {
|
|
using C0 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<>, UIntsToPack<>>;
|
|
using C1 = pfor::Pack<pfor::UIntToType<1>, UIntsToPack<>, UIntsToPack<>>;
|
|
using C2 = pfor::Pack<pfor::UIntToType<2>, UIntsToPack<>, UIntsToPack<>>;
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C0, C0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C1, C0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C1, C1>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C1>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorExpressionInfo<C2, C2>::value);
|
|
|
|
TEST(REQUIRE, pfor::ComparatorExpressionInfo<C0, C1>::value);
|
|
TEST(REQUIRE, pfor::ComparatorExpressionInfo<C0, C2>::value);
|
|
TEST(REQUIRE, pfor::ComparatorExpressionInfo<C1, C2>::value);
|
|
}
|
|
|
|
SECTION("ComparatorWritePack") {
|
|
using WP0 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<>, UIntsToPack<>>;
|
|
using WP1 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0>, UIntsToPack<>>;
|
|
using WP2 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<1>, UIntsToPack<>>;
|
|
using WP3 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0, 1, 2>, UIntsToPack<>>;
|
|
using WP4 = pfor::Pack<pfor::UIntToType<0>, UIntsToPack<0, 2>, UIntsToPack<>>;
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP0, WP0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP1, WP0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP2, WP0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP3, WP1>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP4, WP1>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ComparatorWritePack<WP4, WP3>::value);
|
|
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP0, WP1>::value);
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP0, WP2>::value);
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP1, WP2>::value);
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP3, WP2>::value);
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP4, WP2>::value);
|
|
TEST(REQUIRE, pfor::ComparatorWritePack<WP3, WP4>::value);
|
|
}
|
|
|
|
SECTION("ExpressionInfo") {
|
|
using EI0 = pfor::Pack<pfor::Pack<pfor::UIntToType<0>, pfor::Pack<>, pfor::Pack<class IDa, class IDb>>>;
|
|
using EI1 = pfor::Pack<pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>>;
|
|
using EI2 = pfor::Pack<
|
|
pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>,
|
|
pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDe>, pfor::Pack<class IDg>>
|
|
>;
|
|
using EI3 = pfor::Pack<
|
|
pfor::Pack<pfor::UIntToType<0>, pfor::Pack<class IDd>, pfor::Pack<class IDb, class IDc>>,
|
|
pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDe>, pfor::Pack<class IDg>>,
|
|
pfor::Pack<pfor::UIntToType<2>, pfor::Pack<class IDb>, pfor::Pack<class IDa>>
|
|
>;
|
|
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S0>, EI0>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S1>, EI1>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S2>, EI2>);
|
|
TEST(REQUIRE, is_same_v<pfor::expr::ExpressionInfo<S3>, EI3>);
|
|
}
|
|
|
|
SECTION("Clusters") {
|
|
using C0 = pfor::Pack<>;
|
|
using C1 = pfor::expr::ExpressionInfo<S1>;
|
|
using C2 = pfor::expr::ExpressionInfo<S2>;
|
|
using C3 = pfor::expr::ExpressionInfo<S3>;
|
|
using C4 = pfor::expr::ExpressionInfo<S4>;
|
|
using C5 = pfor::expr::ExpressionInfo<S5>;
|
|
|
|
using CC0 = pfor::Pack<>;
|
|
using CC1 = pfor::Pack<C1>;
|
|
using CC2 = pfor::Pack<C2>;
|
|
using CC3 = pfor::Pack<C3>;
|
|
using CC4 = pfor::Pack<C4>;
|
|
using CC5 = pfor::Pack<C5>;
|
|
|
|
using I0 = pfor::Pack<pfor::UIntToType<0>, pfor::Pack<>, pfor::Pack<>>;
|
|
using I1 = pfor::Pack<pfor::UIntToType<1>, pfor::Pack<class IDg, class IDh>, pfor::Pack<class IDh, class IDi>>;
|
|
using I2 = pfor::Pack<pfor::UIntToType<2>, pfor::Pack<class IDd, class IDh>, pfor::Pack<class IDb, class IDh, class IDi>>;
|
|
using I3 = pfor::Pack<pfor::UIntToType<3>, pfor::Pack<class IDi>, pfor::Pack<class IDa, class IDf, class IDg, class IDh, class IDi>>;
|
|
|
|
using CC0I1 = pfor::Pack<pfor::Pack<I1>>;
|
|
using CC0I2 = pfor::Pack<pfor::Pack<I2>>;
|
|
using CC1I1 = pfor::Pack<C1, pfor::Pack<I1>>;
|
|
using CC1I2 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C1, I2>>;
|
|
using CC2I1 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C2, I1>>;
|
|
using CC2I2 = pfor::Pack<pfor::PackSortInsert<pfor::ComparatorExpressionInfo, C2, I2>>;
|
|
|
|
using F0 = UIntsToPack<>;
|
|
using F1 = UIntsToPack<0>;
|
|
using F2 = UIntsToPack<0, 1>;
|
|
using F3 = UIntsToPack<0, 1, 2>;
|
|
using F4 = UIntsToPack<0, 1, 2>;
|
|
using F5 = UIntsToPack<0, 1, 2, 3>;
|
|
|
|
using CF0 = pfor::Pack<>;
|
|
using CF1 = pfor::Pack<F1>;
|
|
using CF2 = pfor::Pack<F2>;
|
|
using CF3 = pfor::Pack<F3>;
|
|
using CF4 = pfor::Pack<F4>;
|
|
using CF5 = pfor::Pack<F5>;
|
|
|
|
using CF1I1 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;
|
|
|
|
// using CE0 = pfor::Pack<>;
|
|
// using CE1 = UIntsToPack<0>;
|
|
// using CE2 = UIntsToPack<0, 1>;
|
|
// using CE3 = UIntsToPack<0, 1, 2>;
|
|
// using CE4 = UIntsToPack<0, 1, 2>;
|
|
// using CE5 = UIntsToPack<0, 1, 2, 3>;
|
|
|
|
// using CCE0 = pfor::Pack<>;
|
|
// using CCE1 = pfor::Pack<CE1>;
|
|
// using CCE2 = pfor::Pack<CE2>;
|
|
// using CCE3 = pfor::Pack<CE3>;
|
|
// using CCE4 = pfor::Pack<CE4>;
|
|
// using CCE5 = pfor::Pack<CE5>;
|
|
|
|
SECTION("ClusterDepends") {
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I1>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I2>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C0, I3>::value);
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I0>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I1>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C1, I2>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C1, I3>::value);
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C2, I0>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C2, I1>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C2, I2>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C2, I3>::value);
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C3, I0>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C3, I1>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C3, I2>::value);
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C3, I3>::value);
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C4, I0>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C4, I1>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C4, I2>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C4, I3>::value);
|
|
|
|
TEST(REQUIRE_FALSE, pfor::ClusterDepends<C5, I0>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C5, I1>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C5, I2>::value);
|
|
TEST(REQUIRE, pfor::ClusterDepends<C5, I3>::value);
|
|
}
|
|
|
|
SECTION("ClustersInsert") {
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC0, I1>, CC0I1>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC0, I2>, CC0I2>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC1, I1>, CC1I1>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC1, I2>, CC1I2>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC2, I1>, CC2I1>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersInsert<CC2, I2>, CC2I2>);
|
|
}
|
|
|
|
SECTION("ClusterExpressionIds") {
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C0>, F0>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C1>, F1>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C2>, F2>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C3>, F3>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C4>, F4>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClusterExpressionIds<C5>, F5>);
|
|
}
|
|
|
|
SECTION("ClustersExpressionIds") {
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC0>, CF0>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC1>, CF1>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC2>, CF2>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC3>, CF3>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC4>, CF4>);
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC5>, CF5>);
|
|
|
|
TEST(REQUIRE, is_same_v<pfor::ClustersExpressionIds<CC1I1>, CF1I1>);
|
|
}
|
|
|
|
// SECTION("ClusterExpression") {
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S0, F0>, CE0>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S1, F1>, CE1>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S2, F2>, CE2>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S3, F3>, CE3>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S4, F4>, CE4>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClusterExpression<S5, F5>, CE5>);
|
|
// }
|
|
//
|
|
// SECTION("ClustersExpression") {
|
|
// using CCE1I1 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;
|
|
//
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S0, CF0>, CCE0>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S1, CF1>, CCE1>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S2, CF2>, CCE2>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S3, CF3>, CCE3>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S4, CF4>, CCE4>);
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S5, CF5>, CCE5>);
|
|
//
|
|
// TEST(REQUIRE, is_same_v<pfor::ClustersExpression<S5, CF1I1>, CCE1I1>);
|
|
// }
|
|
|
|
SECTION("ClustersGen") {
|
|
using CG0 = pfor::Pack<UIntsToPack<0>>;
|
|
using CG1 = pfor::Pack<UIntsToPack<0>>;
|
|
using CG2 = pfor::Pack<UIntsToPack<0>, UIntsToPack<1>>;
|
|
using CG3 = pfor::Pack<UIntsToPack<0, 2>, UIntsToPack<1>>;
|
|
using CG4 = pfor::Pack<UIntsToPack<0, 1>, UIntsToPack<2>>;
|
|
using CG5 = pfor::Pack<UIntsToPack<0, 3>, UIntsToPack<1>, UIntsToPack<2>>;
|
|
using CG6 = pfor::Pack<UIntsToPack<0, 1, 3>, UIntsToPack<2>, UIntsToPack<4>>;
|
|
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E0>::type, CG0>);
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E1>::type, CG1>);
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E2>::type, CG2>);
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E3>::type, CG3>);
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E4>::type, CG4>);
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E5>::type, CG5>);
|
|
|
|
TEST(REQUIRE, is_same_v<typename pfor::ClustersGen<E6>::type, CG6>);
|
|
}
|
|
}
|
|
}
|