[#31]:svarga:backend, PB fixture tests with .proto golden baselines

Author: steven-varga

tests/CMakeLists.txt

@@ -32,6 +32,11 @@ endfunction()
 
 function(add_h5cpp_backend_fixture_test name backend)
   set(golden "${GOLDEN_DIR}/${name}.${backend}.expected")
+  set(proto_golden "${GOLDEN_DIR}/${name}.proto.expected")
+  set(proto_arg "")
+  if(EXISTS "${proto_golden}")
+    set(proto_arg "-DPROTO_GOLDEN=${proto_golden}")
+  endif()
   add_test(
     NAME h5cpp.${name}
     COMMAND
@@ -42,6 +47,7 @@ function(add_h5cpp_backend_fixture_test name backend)
         "-DGOLDEN=${golden}"
         "-DBACKEND_FORMAT=${backend}"
         "-DOUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR}"
+        ${proto_arg}
         -P "${RUN_FIXTURE}"
   )
 endfunction()
@@ -57,6 +63,14 @@ set(PB_FIXTURES
   pb_variant
   pb_wire_specs
   pb_chrono
+  pb_enum_tag
+  pb_ignore
+  pb_universals
+  pb_tier2
+  pb_enum_decl
+  pb_tier3a
+  pb_service
+  pb_clean_form
 )
 
 foreach(fixture IN LISTS PB_FIXTURES)

tests/fixtures/pb_chrono.cpp

@@ -6,20 +6,18 @@
 // Tier-4 fixture (stage 6): chrono adapter annotation. A user struct with
 // std::chrono::system_clock::time_point + std::chrono::nanoseconds members
 // gets pb::adapter_field<N, Ptr, pb::Timestamp_adapter> / Duration_adapter
-// entries in the emitted descriptor. The library bridges the C++ types
-// to proto3 google.protobuf.Timestamp / Duration wire messages.
+// entries in the emitted descriptor. The library bridges the C++ types to
+// proto3 google.protobuf.Timestamp / Duration wire messages.
 namespace sn::pb_test {
 
 struct event_t {
-    [[clang::annotate("pb::field=1")]]
+    [[pb::field(1)]]
         std::int64_t id;
 
-    [[clang::annotate("pb::field=2")]]
-    [[clang::annotate("pb::adapter=Timestamp")]]
+    [[pb::field(2), pb::adapter("Timestamp")]]
         std::chrono::system_clock::time_point when;
 
-    [[clang::annotate("pb::field=3")]]
-    [[clang::annotate("pb::adapter=Duration")]]
+    [[pb::field(3), pb::adapter("Duration")]]
         std::chrono::nanoseconds ttl;
 };
 

tests/fixtures/pb_clean_form.cpp

@@ -0,0 +1,66 @@
+#include "pb_stub.hpp"
+
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <string>
+#include <variant>
+
+// Issue #31 Phase 1b — clean `[[pb::field(N)]]` syntax delivered by the
+// source-level rewriter (src/pb_attr_translator.hpp).
+//
+// No `clang::annotate(...)` envelope; users write attributes directly in
+// the pb:: namespace. Tag arguments may be integer literals OR enum
+// values OR any mix — the rewriter lowers everything to clang::annotate
+// before Clang's AST walker sees it, and Expr::EvaluateAsInt resolves
+// both kinds in one code path.
+
+namespace acme::telemetry {
+
+enum class telemetry_tag : std::uint32_t {
+    captured_at = 1,
+    elapsed     = 2,
+    device_id   = 3,
+    samples     = 4,
+    payload     = 5,         // base for oneof: 5/6/7
+};
+
+struct telemetry_event_t {
+    [[pb::field(telemetry_tag::captured_at), pb::adapter("Timestamp")]]
+        std::chrono::system_clock::time_point captured_at;
+
+    [[pb::field(telemetry_tag::elapsed), pb::adapter("Duration")]]
+        std::chrono::nanoseconds elapsed;
+
+    [[pb::field(telemetry_tag::device_id)]]
+        std::string device_id;
+
+    [[pb::field(telemetry_tag::samples)]]
+        std::map<std::string, double> samples;
+
+    [[pb::field(telemetry_tag::payload,
+                static_cast<std::uint32_t>(telemetry_tag::payload) + 1u,
+                static_cast<std::uint32_t>(telemetry_tag::payload) + 2u)]]
+        std::variant<std::monostate,
+                      std::string,       // text alert  (tag 5)
+                      std::int64_t,      // event code  (tag 6)
+                      double>            // metric      (tag 7)
+        payload;
+
+    [[pb::field(10), pb::wire("sint32")]]
+        std::int32_t delta;              // zigzag, often negative
+
+    [[pb::field(11)]]
+        std::int32_t legacy_count;       // raw int next to enum-tagged fields
+
+    [[pb::ignore]]
+        void* runtime_handle;            // cache; never persisted to wire
+};
+
+} // namespace acme::telemetry
+
+void use() {
+    acme::telemetry::telemetry_event_t e{};
+    auto buf = pb::encode(e);
+    (void)buf;
+}

tests/fixtures/pb_composites.cpp

@@ -15,11 +15,11 @@
 namespace sn::pb_test {
 
 struct profile_t {
-    [[clang::annotate("pb::field=1")]] std::string                  name;
-    [[clang::annotate("pb::field=2")]] std::vector<std::int32_t>    scores;
-    [[clang::annotate("pb::field=3")]] std::optional<std::string>   nickname;
-    [[clang::annotate("pb::field=4")]] std::vector<std::string>     aliases;
-    [[clang::annotate("pb::field=5")]] std::optional<std::int64_t>  user_id;
+    [[pb::field(1)]] std::string                  name;
+    [[pb::field(2)]] std::vector<std::int32_t>    scores;
+    [[pb::field(3)]] std::optional<std::string>   nickname;
+    [[pb::field(4)]] std::vector<std::string>     aliases;
+    [[pb::field(5)]] std::optional<std::int64_t>  user_id;
 };
 
 } // namespace sn::pb_test

tests/fixtures/pb_enum_decl.cpp

@@ -0,0 +1,54 @@
+#include "pb_stub.hpp"
+
+#include <cstdint>
+
+// Commit 1: proto3 `enum Foo { VAL = N; ... }` declaration emission.
+//
+// Three scenarios in one fixture:
+//   1. `color_e` — has an UNSPECIFIED = 0 entry already. Clean emission;
+//                  no diagnostic.
+//   2. `priority_e` — no zero-valued enumerator BUT carries
+//                     [[pb::enum_zero("UNSPECIFIED")]]. h5cpp synthesizes
+//                     `UNSPECIFIED = 0;` as the first line of the proto3
+//                     enum block. The C++ enum is unchanged.
+//   3. `direction_e` — uses [[pb::name(...)]] to override the proto3
+//                      message name. Already has a zero entry.
+
+namespace sn::pb_test {
+
+enum class color_e : std::int32_t {
+    UNSPECIFIED = 0,
+    RED         = 1,
+    GREEN       = 2,
+    BLUE        = 3,
+};
+
+// Proto3 requires the first entry to be 0-valued; this C++ enum has no
+// zero. The pb::enum_zero override synthesizes one in the .proto output.
+enum class [[pb::enum_zero("PRIORITY_UNSPECIFIED")]] priority_e : std::int32_t {
+    LOW    = 1,
+    NORMAL = 2,
+    HIGH   = 3,
+};
+
+enum class [[pb::name("Heading"), pb::doc("compass headings")]] direction_e : std::int32_t {
+    HEADING_UNSPECIFIED = 0,
+    NORTH               = 1,
+    EAST                = 2,
+    SOUTH               = 3,
+    WEST                = 4,
+};
+
+struct event_t {
+    [[pb::field(1)]] color_e     color;
+    [[pb::field(2)]] priority_e  priority;
+    [[pb::field(3)]] direction_e heading;
+};
+
+} // namespace sn::pb_test
+
+void use() {
+    sn::pb_test::event_t e{};
+    auto buf = pb::encode(e);
+    (void)buf;
+}

tests/fixtures/pb_enum_tag.cpp

@@ -0,0 +1,57 @@
+#include "pb_stub.hpp"
+
+#include <cstdint>
+#include <map>
+#include <string>
+#include <variant>
+
+// Issue #31 headline feature: enum-typed tag arguments.
+//
+// Tag numbers come from a named enum rather than scattered integer literals.
+// The compiler evaluates each enum reference via Expr::EvaluateAsInt(ctx)
+// and emits the same pb::field<N, Ptr>{} descriptor as if the user had
+// written the raw number. Mixed enum + int args allowed (see `legacy_count`
+// which uses a raw integer right alongside the enum-tagged fields).
+//
+// Permissive default per the attribute taxonomy doc §6 — no class-level
+// "must use this enum" binding required; the library doesn't choose the route.
+
+namespace sn::pb_test {
+
+enum class user_profile_tag : std::uint32_t {
+    name      = 1,
+    scores    = 2,
+    flags     = 3,
+    payload   = 5,                   // base for oneof — alts at 5, 6, 7
+};
+
+struct user_profile_t {
+    [[pb::field(user_profile_tag::name)]]
+        std::string                                          name;
+
+    [[pb::field(user_profile_tag::scores)]]
+        std::map<std::string, std::int32_t>                  scores;
+
+    [[pb::field(user_profile_tag::flags)]]
+        std::map<bool, std::string>                          flags;
+
+    // Variadic enum-tagged oneof. Three alternatives mapped to a contiguous
+    // tag range. Compiler reads each Expr* via EvaluateAsInt → integer 5/6/7.
+    [[pb::field(user_profile_tag::payload,
+                static_cast<std::uint32_t>(user_profile_tag::payload) + 1u,
+                static_cast<std::uint32_t>(user_profile_tag::payload) + 2u)]]
+        std::variant<std::monostate, std::string, std::int64_t, double> payload;
+
+    // Mixed-form: raw integer alongside enum-tagged fields. Permissive default
+    // accepts the mix without diagnostic.
+    [[pb::field(10)]]
+        std::int32_t legacy_count;
+};
+
+} // namespace sn::pb_test
+
+void use() {
+    sn::pb_test::user_profile_t u{};
+    auto buf = pb::encode(u);
+    (void)buf;
+}

tests/fixtures/pb_ignore.cpp

@@ -0,0 +1,28 @@
+#include "pb_stub.hpp"
+
+#include <cstdint>
+#include <string>
+
+// FR12: [[pb::ignore]] marks a non-static data member as deliberately
+// excluded from wire encoding (caches, derived state, locks, runtime
+// handles, etc.). The compiler emits pb::ignore<&T::m>{} in the
+// descriptor — required so CCC#7 descriptor-completeness recognizes the
+// member as deliberately omitted rather than accidentally forgotten.
+
+namespace sn::pb_test {
+
+struct record_with_ignore_t {
+    [[pb::field(1)]]                std::string  name;
+    [[pb::ignore]]                  void*        runtime_handle;   // cache; never wire
+    [[pb::field(2)]]                std::int32_t score;
+    [[pb::ignore]]                  std::int64_t derived_counter;  // computed at runtime
+    [[pb::field(3)]]                std::string  description;
+};
+
+} // namespace sn::pb_test
+
+void use() {
+    sn::pb_test::record_with_ignore_t r{};
+    auto buf = pb::encode(r);
+    (void)buf;
+}

tests/fixtures/pb_primitives.cpp

@@ -2,19 +2,18 @@
 
 #include <cstdint>
 
-// Tier-1 fixture: numeric scalars only. Every member carries
-// [[clang::annotate("pb::field=N")]]; the compiler emits a
-// pb::meta::descriptor_t<T> specialization with one pb::field<N,&T::m>{}
-// entry per member, in source-declaration order.
+// Tier-1 fixture: numeric scalars only. Every member carries [[pb::field(N)]];
+// the compiler emits a pb::meta::descriptor_t<T> specialization with one
+// pb::field<N, &T::m>{} entry per member, in source-declaration order.
 namespace sn::pb_test {
 struct primitives_t {
-    [[clang::annotate("pb::field=1")]] bool         _bool;
-    [[clang::annotate("pb::field=2")]] std::int32_t _i32;
-    [[clang::annotate("pb::field=3")]] std::int64_t _i64;
-    [[clang::annotate("pb::field=4")]] std::uint32_t _u32;
-    [[clang::annotate("pb::field=5")]] std::uint64_t _u64;
-    [[clang::annotate("pb::field=6")]] float        _f;
-    [[clang::annotate("pb::field=7")]] double       _d;
+    [[pb::field(1)]] bool          _bool;
+    [[pb::field(2)]] std::int32_t  _i32;
+    [[pb::field(3)]] std::int64_t  _i64;
+    [[pb::field(4)]] std::uint32_t _u32;
+    [[pb::field(5)]] std::uint64_t _u64;
+    [[pb::field(6)]] float         _f;
+    [[pb::field(7)]] double        _d;
 };
 } // namespace sn::pb_test
 

tests/fixtures/pb_service.cpp

@@ -0,0 +1,60 @@
+#include "pb_stub.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <string>
+
+// Commit 4: [[pb::service("Name")]] — a record marked this way emits as
+// a proto3 `service Name { ... }` block. Each std::function<Resp(Req)>
+// member becomes one `rpc <member-name>(Req) returns (Resp);` line.
+// Non-function fields would be skipped with a diagnostic; this fixture
+// keeps the struct RPC-handler-only.
+//
+// The Request / Response struct types are walked as dependencies so
+// they emit as proto3 `message` blocks BEFORE the service block.
+
+namespace acme::users {
+
+// Request / response messages. Plain pb::field-only structs.
+struct [[pb::doc("user-id lookup request")]] get_user_req_t {
+    [[pb::field(1)]] std::int64_t user_id;
+};
+struct [[pb::doc("user-id lookup response")]] get_user_resp_t {
+    [[pb::field(1)]] std::string display_name;
+    [[pb::field(2)]] std::int64_t created_ns;
+};
+
+struct list_users_req_t {
+    [[pb::field(1)]] std::int32_t page;
+    [[pb::field(2)]] std::int32_t page_size;
+};
+struct list_users_resp_t {
+    [[pb::field(1)]] std::int32_t total;
+};
+
+struct auth_req_t  { [[pb::field(1)]] std::string token; };
+struct auth_resp_t { [[pb::field(1)]] bool ok; };
+
+// The service definition. No data fields — only RPC handlers.
+struct [[pb::service("UserService"),
+        pb::doc("user-account RPC surface")]]
+user_service_t {
+    std::function<get_user_resp_t(get_user_req_t)>     get_user;
+    std::function<list_users_resp_t(list_users_req_t)> list_users;
+    std::function<auth_resp_t(auth_req_t)>             authenticate;
+};
+
+} // namespace acme::users
+
+void use() {
+    // Touching the messages teaches h5cpp-compiler the requests/responses
+    // exist as user records — they emit as `message` blocks before the
+    // service that references them.
+    acme::users::get_user_req_t  q1{}; (void)pb::encode(q1);
+    acme::users::get_user_resp_t r1{}; (void)pb::encode(r1);
+    acme::users::list_users_req_t  q2{}; (void)pb::encode(q2);
+    acme::users::list_users_resp_t r2{}; (void)pb::encode(r2);
+    acme::users::auth_req_t  q3{}; (void)pb::encode(q3);
+    acme::users::auth_resp_t r3{}; (void)pb::encode(r3);
+    acme::users::user_service_t svc{}; (void)pb::encode(svc);
+}

tests/fixtures/pb_strings_enums.cpp

@@ -17,10 +17,10 @@ enum class severity_e : std::int32_t {
 };
 
 struct log_entry_t {
-    [[clang::annotate("pb::field=1")]] std::int64_t timestamp_ns;
-    [[clang::annotate("pb::field=2")]] std::string  message;
-    [[clang::annotate("pb::field=3")]] severity_e   level;
-    [[clang::annotate("pb::field=4")]] double       elapsed_ms;
+    [[pb::field(1)]] std::int64_t timestamp_ns;
+    [[pb::field(2)]] std::string  message;
+    [[pb::field(3)]] severity_e   level;
+    [[pb::field(4)]] double       elapsed_ms;
 };
 
 } // namespace sn::pb_test