From 884d5bc1cef7fb621650d37bdff8c6c08da7c625 Mon Sep 17 00:00:00 2001 From: Yingfan Guo <115908952+sentomk@users.noreply.github.com> Date: Fri, 31 Jul 2026 05:26:30 +0000 Subject: [PATCH] test: cover PTN_BIND 1/4/5 arity and PTN_WHERE 3/4 arg variants Add Single (1 member), Quad (4 members), and Penta (5 members) test structs with PTN_BIND declarations for the previously untested arity overloads. Each gets type-correctness static_asserts and hit/miss guard expressions. Also add PTN_WHERE 3-arg and 4-arg guard tests, completing the full 1-5 arity matrix (1, 2, and 5 were already tested in tests_guard.cpp). --- tests/tests_named_placeholder.cpp | 180 ++++++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) diff --git a/tests/tests_named_placeholder.cpp b/tests/tests_named_placeholder.cpp index e92394a..e2043d7 100644 --- a/tests/tests_named_placeholder.cpp +++ b/tests/tests_named_placeholder.cpp @@ -29,11 +29,33 @@ namespace { int c; }; + struct Single { + int value; + }; + + struct Quad { + int a; + int b; + int c; + int d; + }; + + struct Penta { + int a; + int b; + int c; + int d; + int e; + }; + // Declare named placeholders for each struct. // These are namespace-scoped inline constexpr arg_t objects. PTN_BIND(Point, x, y); PTN_BIND(Packet, type, len); PTN_BIND(Triple, a, b, c); + PTN_BIND(Single, sv); + PTN_BIND(Quad, qa, qb, qc, qd); + PTN_BIND(Penta, pa, pb, pc, pd, pe); } // namespace @@ -224,3 +246,161 @@ TEST(NamedPlaceholder, MixedArithmeticAndComparison) { ptn::_ >> 0); EXPECT_EQ(result, 1); } + +// ========================================================================= +// PTN_BIND arity coverage: 1, 4, and 5 member structs. +// ========================================================================= + +TEST(NamedPlaceholder, OneMemberTypeCorrect) { + static_assert(std::is_same_v, + ptn::pat::mod::arg_t<0>>); +} + +TEST(NamedPlaceholder, OneMemberGuard) { + Single s{42}; + auto result = ptn::match(s) + | PTN_ON( + ptn::$(ptn::has<&Single::value>)[sv > 5] >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 1); +} + +TEST(NamedPlaceholder, OneMemberGuardFails) { + Single s{3}; + auto result = ptn::match(s) + | PTN_ON( + ptn::$(ptn::has<&Single::value>)[sv > 5] >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 0); +} + +TEST(NamedPlaceholder, FourMemberTypeCorrect) { + static_assert(std::is_same_v, + ptn::pat::mod::arg_t<0>>); + static_assert(std::is_same_v, + ptn::pat::mod::arg_t<3>>); +} + +TEST(NamedPlaceholder, FourMemberGuard) { + // a + b + c == d + Quad q{1, 2, 3, 6}; + auto result = ptn::match(q) + | PTN_ON( + ptn::$(ptn::has<&Quad::a, + &Quad::b, + &Quad::c, + &Quad::d>)[qa + qb + qc == qd] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 1); +} + +TEST(NamedPlaceholder, FourMemberGuardFails) { + Quad q{1, 2, 3, 7}; + auto result = ptn::match(q) + | PTN_ON( + ptn::$(ptn::has<&Quad::a, + &Quad::b, + &Quad::c, + &Quad::d>)[qa + qb + qc == qd] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 0); +} + +TEST(NamedPlaceholder, FiveMemberTypeCorrect) { + static_assert(std::is_same_v, + ptn::pat::mod::arg_t<0>>); + static_assert(std::is_same_v, + ptn::pat::mod::arg_t<4>>); +} + +TEST(NamedPlaceholder, FiveMemberGuard) { + // a * b - c == d + e + Penta p{6, 2, 5, 4, 3}; + auto result = ptn::match(p) + | PTN_ON( + ptn::$( + ptn::has<&Penta::a, + &Penta::b, + &Penta::c, + &Penta::d, + &Penta::e>)[pa * pb - pc == pd + pe] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 1); +} + +TEST(NamedPlaceholder, FiveMemberGuardFails) { + Penta p{6, 2, 5, 4, 4}; + auto result = ptn::match(p) + | PTN_ON( + ptn::$( + ptn::has<&Penta::a, + &Penta::b, + &Penta::c, + &Penta::d, + &Penta::e>)[pa * pb - pc == pd + pe] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 0); +} + +// ========================================================================= +// PTN_WHERE arity coverage: 3 and 4 parameter variants. +// (1, 2, and 5 are already tested in tests_guard.cpp.) +// ========================================================================= + +TEST(NamedPlaceholder, WhereThreeArgGuard) { + // PTN_WHERE((a, b, c), a + b == c) + Triple t{2, 3, 5}; + auto result = ptn::match(t) + | PTN_ON( + ptn::$( + ptn::has<&Triple::a, &Triple::b, &Triple::c>) + [PTN_WHERE((x, y, z), x + y == z)] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 1); +} + +TEST(NamedPlaceholder, WhereThreeArgGuardFails) { + Triple t{2, 3, 6}; + auto result = ptn::match(t) + | PTN_ON( + ptn::$( + ptn::has<&Triple::a, &Triple::b, &Triple::c>) + [PTN_WHERE((x, y, z), x + y == z)] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 0); +} + +TEST(NamedPlaceholder, WhereFourArgGuard) { + // PTN_WHERE((a, b, c, d), a + b + c == d) + Quad q{1, 2, 3, 6}; + auto result = ptn::match(q) + | PTN_ON( + ptn::$(ptn::has<&Quad::a, + &Quad::b, + &Quad::c, + &Quad::d>) + [PTN_WHERE((w, x, y, z), w + x + y == z)] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 1); +} + +TEST(NamedPlaceholder, WhereFourArgGuardFails) { + Quad q{1, 2, 3, 7}; + auto result = ptn::match(q) + | PTN_ON( + ptn::$(ptn::has<&Quad::a, + &Quad::b, + &Quad::c, + &Quad::d>) + [PTN_WHERE((w, x, y, z), w + x + y == z)] + >> 1, + ptn::_ >> 0); + EXPECT_EQ(result, 0); +}