jumbf/parse_test.cc

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include "jumbf/parse.h"

#include <cstdint>
#include <cstring>
#include <string>
#include <utility>

#include "absl/status/status.h"
#include "absl/status/status_matchers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "jumbf/box.h"
#include "jumbf/constants.h"
#include "jumbf/test_utils.h"
#include "riegeli/endian/endian_writing.h"
#include "uuid/uuid.h"

namespace jumbf {
namespace {
using ::absl_testing::IsOkAndHolds;
using ::absl_testing::StatusIs;
using ::credentio::Uuid;
using ::testing::Eq;
using ::testing::IsEmpty;

constexpr absl::string_view kFakeUuid = "DEADBEEF-F00D-BABE-B4DF-00D528013378";

std::string FakeDescriptionBoxContents() {
  // Can't use absl::string_view because the compiler warns against assuming it
  // is null terminated, even when it truly is null terminated.
  constexpr char kFakeLabel[] = "fakelabel";
  const size_t description_content_length = /*uuid*/ 16 + /*toggles*/ 1 +
                                            strlen(kFakeLabel) +
                                            /*label null terminator*/ 1;
  std::string fake_description_contents(description_content_length, '\0');
  char* content_cursor = fake_description_contents.data();

  SerializeUuid(&content_cursor, Uuid::FromStringOrDie(kFakeUuid));
  riegeli::WriteBigEndian<uint8_t>(kDescriptionToggleLabelPresent,
                                   content_cursor);
  content_cursor += sizeof(uint8_t);
  memcpy(content_cursor, kFakeLabel, strlen(kFakeLabel) + 1);
  content_cursor += strlen(kFakeLabel) + 1;

  return fake_description_contents;
}

TEST(ParseTest, InvalidSuperBoxFails) {
  absl::string_view empty;

  EXPECT_THAT(
      ConsumeSuperBox(&empty, /*recursion_limit=*/1),
      StatusIs(
          absl::StatusCode::kOutOfRange,
          R"(cannot unwrap super box: cannot read LBox value: not enough input bytes remaining; have 0 need 4)"));
  EXPECT_THAT(empty, IsEmpty());
}

TEST(ParseTest, InvalidSuperBoxPayloadFails) {
  absl::string_view kContent =
      R"(This content doesn't really matter for this test case.)";
  std::string serialized = WrapBox(kContent, 0xf00dbabe);
  absl::string_view serialized_view = serialized;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       "box is not a super box: got type 0xf00dbabe need "
                       "0x6a756d62 ('jumb')"));
  EXPECT_THAT(serialized_view, Eq(serialized));
}

TEST(ParseTest, InvalidDescriptionBoxFails) {
  constexpr uint32_t kLBox = 5;
  constexpr uint32_t kTBox = 12345;

  std::string inner_box(8, '\0');
  char* cursor = inner_box.data();

  riegeli::WriteBigEndian<uint32_t>(kLBox, cursor);
  cursor += sizeof(uint32_t);
  riegeli::WriteBigEndian<uint32_t>(kTBox, cursor);
  cursor += sizeof(uint32_t);

  const std::string super_box = WrapBox(inner_box, kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       "cannot unwrap description box: LBox is 5; LBox values "
                       "2-7 are reserved by the standard"));
  EXPECT_THAT(serialized_view, Eq(super_box));
}

TEST(ParseTest, InvalidDescriptionBoxPayloadFails) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), /*tbox=*/12345);
  std::string content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              StatusIs(absl::StatusCode::kInvalidArgument,
                       "cannot parse description box: box is not a description "
                       "box; got type 0x3039 need 0x6a756d64 ('jumd')"));
  EXPECT_THAT(serialized_view, Eq(super_box));
}

TEST(ParseTest, NegativeRecursionLimitCausesNoUnderflow) {
  absl::string_view box_from_fuzzer(
      "\000\000\000\000jumb\000\000\000\031jumd\000\000\000\000\000\000\000\000"
      "\000\000\000\000\000\000\000\000\000\000\000\000\000jumb\000\000\000\031"
      "jumd\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
      "\000\000\031\000\000\000\000\000\000\000\000\000",
      78);
  EXPECT_THAT(
      ConsumeSuperBox(&box_from_fuzzer, /*recursion_limit=*/-2147483648),
      StatusIs(absl::StatusCode::kInvalidArgument));
}

TEST(ParseToProtoTest, AllDescriptionBoxTogglesSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  constexpr absl::string_view kFakeSalt = R"(0123456701234567)";
  const std::string private_box = jumbf::WrapBox(kFakeSalt, kC2paSaltBoxType);

  // Can't use absl::string_view because the compiler warns against assuming it
  // is null terminated, even when it truly is null terminated.
  constexpr char kFakeLabel[] = "fakelabel";
  constexpr uint32_t kFakeId = 0xB33FD00D;
  const std::string fake_hash(32, 'X');
  const size_t description_content_length =
      /*uuid*/ 16 + /*toggles*/ 1 + strlen(kFakeLabel) +
      /*label null terminator*/ 1 + /*id*/ 4 + fake_hash.length() +
      private_box.length();
  std::string fake_description_contents(description_content_length, 'A');
  char* content_cursor = fake_description_contents.data();

  SerializeUuid(&content_cursor, Uuid::FromStringOrDie(kFakeUuid));
  uint8_t toggles = jumbf::kDescriptionToggleRequestable |
                    jumbf::kDescriptionToggleLabelPresent |
                    jumbf::kDescriptionToggleIdPresent |
                    jumbf::kDescriptionToggleHashPresent |
                    jumbf::kDescriptionTogglePrivatePresent;
  riegeli::WriteBigEndian<uint8_t>(toggles, content_cursor);
  content_cursor += sizeof(uint8_t);
  memcpy(content_cursor, kFakeLabel, strlen(kFakeLabel) + 1);
  content_cursor += strlen(kFakeLabel) + 1;
  riegeli::WriteBigEndian<uint32_t>(kFakeId, content_cursor);
  content_cursor += sizeof(uint32_t);
  memcpy(content_cursor, fake_hash.data(), 32);
  content_cursor += 32;
  memcpy(content_cursor, private_box.data(), private_box.length());

  std::string content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string super_box = WrapBox(
      absl::StrCat(WrapBox(fake_description_contents, kDescriptionBoxType),
                   content_box),
      kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .requestable = true,
                          .label = "fakelabel",
                          .id = kFakeId,
                          .unvalidated_hash = fake_hash,
                          .private_content{ContentBox{.raw_bytes = private_box,
                                                      .payload =
                                                          C2paSaltBox{
                                                              .salt = kFakeSalt,
                                                          }}}},
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              CborBox{
                                                  .payload = kFakeCborData,
                                              }}},
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseToProtoTest, DescriptionBoxMultiplePrivateContentSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  constexpr absl::string_view kFirstPrivatePayload =
      R"(The format of this data is unimportant for this test case.)";
  constexpr absl::string_view kSecondPrivatePayload =
      R"(The format of this data is also unimportant for this test case.)";
  const std::string private_box_payload[] = {WrapBox(kFirstPrivatePayload, 1),
                                             WrapBox(kSecondPrivatePayload, 2)};
  const std::string private_box =
      WrapBox(absl::StrJoin(private_box_payload, ""), kPrivateContentBoxType);

  // Can't use absl::string_view because the compiler warns against assuming it
  // is null terminated, even when it truly is null terminated.
  constexpr char kFakeLabel[] = "fakelabel";
  constexpr uint32_t kFakeId = 0xB33FD00D;
  const std::string fake_hash(32, 'X');
  const size_t description_content_length =
      /*uuid*/ 16 + /*toggles*/ 1 + strlen(kFakeLabel) +
      /*label null terminator*/ 1 + /*id*/ 4 + fake_hash.length() +
      private_box.length();
  std::string fake_description_contents(description_content_length, 'A');
  char* content_cursor = fake_description_contents.data();

  SerializeUuid(&content_cursor, Uuid::FromStringOrDie(kFakeUuid));
  uint8_t toggles =
      kDescriptionToggleRequestable | kDescriptionToggleLabelPresent |
      kDescriptionToggleIdPresent | kDescriptionToggleHashPresent |
      kDescriptionTogglePrivatePresent;
  riegeli::WriteBigEndian<uint8_t>(toggles, content_cursor);
  content_cursor += sizeof(uint8_t);
  memcpy(content_cursor, kFakeLabel, strlen(kFakeLabel) + 1);
  content_cursor += strlen(kFakeLabel) + 1;
  riegeli::WriteBigEndian<uint32_t>(kFakeId, content_cursor);
  content_cursor += sizeof(uint32_t);
  memcpy(content_cursor, fake_hash.data(), 32);
  content_cursor += 32;
  memcpy(content_cursor, private_box.data(), private_box.length());

  std::string content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string super_box = WrapBox(
      absl::StrCat(WrapBox(fake_description_contents, kDescriptionBoxType),
                   content_box),
      kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(
      ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
      IsOkAndHolds(SuperBox{
          .description =
              DescriptionBox{
                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                  .requestable = true,
                  .label = "fakelabel",
                  .id = kFakeId,
                  .unvalidated_hash = fake_hash,
                  .private_content{
                      ContentBox{
                          .raw_bytes = WrapBox(kFirstPrivatePayload, 1),
                          .payload =
                              UnknownBox{
                                  .type = 1,
                                  .payload = kFirstPrivatePayload,
                              },
                      },
                      ContentBox{
                          .raw_bytes = WrapBox(kSecondPrivatePayload, 2),
                          .payload =
                              UnknownBox{
                                  .type = 2,
                                  .payload = kSecondPrivatePayload,
                              },
                      },
                  }},
          .contents = {ContentBox{.raw_bytes = content_box,
                                  .payload =
                                      CborBox{
                                          .payload = kFakeCborData,
                                      }}},
          .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, SingleCborContentBoxSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              CborBox{
                                                  .payload = kFakeCborData,
                                              }}},
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, MultipleCborContentBoxSucceeds) {
  constexpr absl::string_view kFakeFirstCborData =
      R"(first content: the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";
  constexpr absl::string_view kFakeSecondCborData =
      R"(second content: the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string super_box = WrapBox(
      absl::StrCat(description_box, WrapBox(kFakeFirstCborData, kCborBoxType),
                   WrapBox(kFakeSecondCborData, kCborBoxType)),
      kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents =
                      {
                          ContentBox{.raw_bytes = WrapBox(kFakeFirstCborData,
                                                          kCborBoxType),
                                     .payload =
                                         CborBox{
                                             .payload = kFakeFirstCborData,
                                         }},
                          ContentBox{.raw_bytes = WrapBox(kFakeSecondCborData,
                                                          kCborBoxType),
                                     .payload =
                                         CborBox{
                                             .payload = kFakeSecondCborData,
                                         }},
                      },
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, SingleEmbeddedFileDescriptionBoxSucceeds) {
  constexpr uint8_t kToggles = 0;
  constexpr const char kFakeMediatype[] = "media/MyFormat";

  const size_t payload_length = 1 /*toggles*/ + sizeof(kFakeMediatype);
  std::string payload(payload_length, 'A');
  char* cursor = payload.data();
  riegeli::WriteBigEndian<uint8_t>(kToggles, cursor);
  cursor += sizeof(uint8_t);
  memcpy(cursor, kFakeMediatype, sizeof(kFakeMediatype));
  cursor += sizeof(kFakeMediatype);

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(payload, kEmbeddedFileDescriptionBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              EmbeddedFileDescriptionBox{
                                                  .media_type = kFakeMediatype,
                                              }}},
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, SingleBinaryDataBoxSucceeds) {
  constexpr absl::string_view kPayload =
      R"(blah blah blah blah this is just some data in no particular format)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(kPayload, kBinaryDataBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              BinaryDataBox{
                                                  .payload = kPayload,
                                              }}},
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, RecursiveSuperBoxUnderRecursionLimitSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string inner_content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string inner_super_box =
      WrapBox(absl::StrCat(description_box, inner_content_box), kSuperBoxType);

  std::string outer_super_box =
      WrapBox(absl::StrCat(description_box, inner_super_box), kSuperBoxType);

  absl::string_view serialized_view = outer_super_box;

  EXPECT_THAT(
      ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
      IsOkAndHolds(SuperBox{
          .description =
              DescriptionBox{
                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                  .label = "fakelabel",
              },
          .contents = {ContentBox{
              .raw_bytes = inner_super_box,
              .payload =
                  SuperBox{
                      .description =
                          DescriptionBox{
                              .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                              .label = "fakelabel",
                          },
                      .contents = {ContentBox{.raw_bytes = inner_content_box,
                                              .payload =
                                                  CborBox{
                                                      .payload = kFakeCborData,
                                                  }}},
                      .raw_bytes = inner_super_box}}},
          .raw_bytes = outer_super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, RecursiveSuperBoxNoRecursionLimitSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string inner_content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string inner_super_box =
      WrapBox(absl::StrCat(description_box, inner_content_box), kSuperBoxType);

  std::string outer_super_box =
      WrapBox(absl::StrCat(description_box, inner_super_box), kSuperBoxType);

  absl::string_view serialized_view = outer_super_box;

  EXPECT_THAT(
      ConsumeSuperBox(&serialized_view, /*recursion_limit=*/-1),
      IsOkAndHolds(SuperBox{
          .description =
              DescriptionBox{
                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                  .label = "fakelabel",
              },
          .contents = {ContentBox{
              .raw_bytes = inner_super_box,
              .payload =
                  SuperBox{
                      .description =
                          DescriptionBox{
                              .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                              .label = "fakelabel",
                          },
                      .contents = {ContentBox{.raw_bytes = inner_content_box,
                                              .payload =
                                                  CborBox{
                                                      .payload = kFakeCborData,
                                                  }}},
                      .raw_bytes = inner_super_box}}},
          .raw_bytes = outer_super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, RecursiveSuperBoxExceedsZeroRecursionLimitSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string inner_content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string inner_super_box =
      WrapBox(absl::StrCat(description_box, inner_content_box), kSuperBoxType);

  std::string outer_super_box =
      WrapBox(absl::StrCat(description_box, inner_super_box), kSuperBoxType);

  absl::string_view serialized_view = outer_super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/0),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = inner_super_box,
                                          .payload =
                                              SerializedSuperbox{
                                                  .serialized = inner_super_box,
                                              }}},
                  .raw_bytes = outer_super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, RecursiveSuperBoxExceedsNonzeroRecursionLimitSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string inner_content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string inner_super_box =
      WrapBox(absl::StrCat(description_box, inner_content_box), kSuperBoxType);

  std::string middle_super_box =
      WrapBox(absl::StrCat(description_box, inner_super_box), kSuperBoxType);

  std::string outer_super_box =
      WrapBox(absl::StrCat(description_box, middle_super_box), kSuperBoxType);

  absl::string_view serialized_view = outer_super_box;

  EXPECT_THAT(
      ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
      IsOkAndHolds(SuperBox{
          .description =
              DescriptionBox{
                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                  .label = "fakelabel",
              },
          .contents = {ContentBox{
              .raw_bytes = middle_super_box,
              .payload = SuperBox{.description =
                                      DescriptionBox{
                                          .type_uuid =
                                              Uuid::FromStringOrDie(kFakeUuid),
                                          .label = "fakelabel",
                                      },
                                  .contents = {ContentBox{
                                      .raw_bytes = inner_super_box,
                                      .payload =
                                          SerializedSuperbox{
                                              .serialized = inner_super_box,
                                          }}},
                                  .raw_bytes = middle_super_box}}},
          .raw_bytes = outer_super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, SingleUnknownContentBoxSucceeds) {
  constexpr absl::string_view kUnknownContent =
      R"(this is some data in a format this parser does not understand)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(kUnknownContent, 12345678);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              UnknownBox{
                                                  .type = 12345678,
                                                  .payload = kUnknownContent,
                                              }}},
                  .raw_bytes = super_box}));

  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, ExcessContentSucceeds) {
  constexpr absl::string_view kFakeCborData =
      R"(the function under test does not actually parse CBOR data so we'll just use a totally fake string here)";

  constexpr absl::string_view kExtraData =
      R"(this is some extra data in the input, the parser should not look at this)";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(kFakeCborData, kCborBoxType);
  std::string super_box = absl::StrCat(
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType),
      kExtraData);

  absl::string_view serialized_view = super_box;

  EXPECT_THAT(ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1),
              IsOkAndHolds(SuperBox{
                  .description =
                      DescriptionBox{
                          .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                          .label = "fakelabel",
                      },
                  .contents = {ContentBox{.raw_bytes = content_box,
                                          .payload =
                                              CborBox{
                                                  .payload = kFakeCborData,
                                              }}},
                  .raw_bytes = super_box.substr(
                      0, super_box.size() - kExtraData.size())}));

  EXPECT_THAT(serialized_view, Eq(kExtraData));
}

TEST(ParseTest, SingleJsonDataBoxSucceeds) {
  constexpr absl::string_view kPayload = R"({"abc": "xyz"})";

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(kPayload, kJsonBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  auto superbox_or = ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1);
  ASSERT_TRUE(superbox_or.ok());
  auto superbox = std::move(*superbox_or);
  EXPECT_THAT(superbox,
              Eq(SuperBox{.description =
                              DescriptionBox{
                                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                                  .label = "fakelabel",
                              },
                          .contents = {ContentBox{.raw_bytes = content_box,
                                                  .payload =
                                                      JsonBox{
                                                          .payload = kPayload,
                                                      }}},
                          .raw_bytes = super_box}));
  EXPECT_THAT(serialized_view, IsEmpty());
}

TEST(ParseTest, UuidBoxSucceeds) {
  std::string uuid_box_payload = jumbf::kC2PARedactionUuid.ToProtoBytes();
  absl::string_view payload = uuid_box_payload;

  std::string description_box =
      WrapBox(FakeDescriptionBoxContents(), kDescriptionBoxType);
  std::string content_box = WrapBox(payload, kUuidBoxType);
  std::string super_box =
      WrapBox(absl::StrCat(description_box, content_box), kSuperBoxType);

  absl::string_view serialized_view = super_box;

  auto superbox_or = ConsumeSuperBox(&serialized_view, /*recursion_limit=*/1);
  ASSERT_TRUE(superbox_or.ok());
  auto superbox = std::move(*superbox_or);
  EXPECT_THAT(superbox,
              Eq(SuperBox{.description =
                              DescriptionBox{
                                  .type_uuid = Uuid::FromStringOrDie(kFakeUuid),
                                  .label = "fakelabel",
                              },
                          .contents = {ContentBox{.raw_bytes = content_box,
                                                  .payload =
                                                      UuidBox{
                                                          .payload = payload,
                                                      }}},
                          .raw_bytes = super_box}));
  EXPECT_THAT(serialized_view, IsEmpty());
}

}  // namespace
}  // namespace jumbf