quic: update token cctest

Author: jasnell

test/cctest/test_quic_tokens.cc

@@ -56,7 +56,7 @@ TEST(StatelessResetToken, Basic) {
 
   CHECK_EQ(token, token2);
 
-  // Let's pretend out secret is also a token just for the sake
+  // Let's pretend our secret is also a token just for the sake
   // of the test. That's ok because they're the same length.
   StatelessResetToken token3(secret);
 
@@ -85,6 +85,83 @@ TEST(StatelessResetToken, Basic) {
   CHECK_EQ(found->second, token);
 }
 
+TEST(StatelessResetToken, Ngtcp2StructIntegration) {
+  uint8_t secret[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6};
+  uint8_t cid_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
+  ngtcp2_cid cid_;
+  ngtcp2_cid_init(&cid_, cid_data, 10);
+  TokenSecret fixed_secret(secret);
+  CID cid(cid_);
+
+  // Owning token — generated into the inherited ngtcp2_stateless_reset_token
+  StatelessResetToken owning(fixed_secret, cid);
+  CHECK(owning);
+
+  // The ngtcp2_stateless_reset_token* conversion operator should return
+  // a valid pointer to the token data.
+  const ngtcp2_stateless_reset_token* as_struct = owning;
+  CHECK_NE(as_struct, nullptr);
+  // The struct's data should match the uint8_t* conversion.
+  const uint8_t* as_bytes = owning;
+  CHECK_EQ(
+      memcmp(
+          as_struct->data, as_bytes, StatelessResetToken::kStatelessTokenLen),
+      0);
+
+  // Non-owning from const ngtcp2_stateless_reset_token* — wraps an
+  // existing struct without copying.
+  StatelessResetToken from_struct(as_struct);
+  CHECK(from_struct);
+  CHECK_EQ(from_struct, owning);
+  // The pointer should be the same (non-owning wraps, doesn't copy).
+  const ngtcp2_stateless_reset_token* from_struct_ptr = from_struct;
+  CHECK_EQ(from_struct_ptr, as_struct);
+
+  // Owning into external ngtcp2_stateless_reset_token — generates the
+  // token into a caller-provided struct.
+  ngtcp2_stateless_reset_token external_struct{};
+  StatelessResetToken into_struct(&external_struct, fixed_secret, cid);
+  CHECK(into_struct);
+  CHECK_EQ(into_struct, owning);
+  // The external struct should now contain the generated token.
+  CHECK_EQ(memcmp(external_struct.data,
+                  as_bytes,
+                  StatelessResetToken::kStatelessTokenLen),
+           0);
+  // The conversion operator should return a pointer to the external struct.
+  const ngtcp2_stateless_reset_token* into_struct_ptr = into_struct;
+  CHECK_EQ(into_struct_ptr, &external_struct);
+
+  // Copy of an owning token should itself be owning (independent copy).
+  StatelessResetToken copy_of_owning = owning;
+  CHECK_EQ(copy_of_owning, owning);
+  const ngtcp2_stateless_reset_token* copy_ptr = copy_of_owning;
+  // Should NOT point to the same memory as the original.
+  CHECK_NE(copy_ptr, as_struct);
+  // But data should match.
+  CHECK_EQ(
+      memcmp(copy_ptr->data, as_bytes, StatelessResetToken::kStatelessTokenLen),
+      0);
+
+  // Copy of a non-owning token should become owning (copies data).
+  StatelessResetToken copy_of_non_owning = from_struct;
+  CHECK_EQ(copy_of_non_owning, from_struct);
+  const ngtcp2_stateless_reset_token* copy_no_ptr = copy_of_non_owning;
+  // Should NOT point to the original non-owning source.
+  CHECK_NE(copy_no_ptr, from_struct_ptr);
+
+  // kInvalid conversions.
+  const ngtcp2_stateless_reset_token* invalid_ptr =
+      StatelessResetToken::kInvalid;
+  CHECK_EQ(invalid_ptr, nullptr);
+  const uint8_t* invalid_bytes = StatelessResetToken::kInvalid;
+  // When ptr_ is null, falls back to inherited data (zeroed).
+  uint8_t zeroed[StatelessResetToken::kStatelessTokenLen]{};
+  CHECK_EQ(
+      memcmp(invalid_bytes, zeroed, StatelessResetToken::kStatelessTokenLen),
+      0);
+}
+
 TEST(RetryToken, Basic) {
   auto& random = CID::Factory::random();
   TokenSecret secret;