formats/riff/chunk_header_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 "formats/riff/chunk_header.h"

#include <string>

#include "absl/status/status.h"
#include "absl/status/status_matchers.h"
#include "absl/strings/string_view.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "riegeli/bytes/string_reader.h"
#include "riegeli/bytes/string_writer.h"

namespace credentio {
namespace {

using ::absl_testing::IsOk;
using ::absl_testing::StatusIs;
using ::testing::Eq;

TEST(ChunkHeaderTest, HeaderSize) {
  EXPECT_THAT(ChunkHeader::header_size(), Eq(8));
}

TEST(ChunkHeaderTest, PadSize) {
  ChunkHeader header;
  header.data_size = 0;
  EXPECT_THAT(header.pad_size(), Eq(0));
  header.data_size = 1;
  EXPECT_THAT(header.pad_size(), Eq(1));
  header.data_size = 2;
  EXPECT_THAT(header.pad_size(), Eq(0));
  header.data_size = 1023;
  EXPECT_THAT(header.pad_size(), Eq(1));
  header.data_size = 1024;
  EXPECT_THAT(header.pad_size(), Eq(0));
}

TEST(ChunkHeaderTest, ChunkSize) {
  ChunkHeader header;
  header.data_size = 0;
  EXPECT_THAT(header.chunk_size(), Eq(8));  // header only
  header.data_size = 1;
  EXPECT_THAT(header.chunk_size(), Eq(10));  // header + data + pad
  header.data_size = 2;
  EXPECT_THAT(header.chunk_size(), Eq(10));  // header + data
  header.data_size = 1023;
  EXPECT_THAT(header.chunk_size(), Eq(1032));  // 8 + 1023 + 1
  header.data_size = 1024;
  EXPECT_THAT(header.chunk_size(), Eq(1032));  // 8 + 1024
}

TEST(ChunkHeaderTest, ChunkSizeOverflow) {
  ChunkHeader header;
  header.data_size = 0xFFFFFFF8;
  EXPECT_THAT(header.chunk_size(), Eq(0xFFFFFFF8ULL + 8));
}

TEST(ChunkHeaderTest, ReadSuccess) {
  // "TEST" ID, size 12 (0x0000000C in little-endian)
  const unsigned char data[] = {'T', 'E', 'S', 'T', 0x0C, 0x00, 0x00, 0x00};
  std::string data_str(reinterpret_cast<const char*>(data), sizeof(data));
  riegeli::StringReader input(data_str);

  ChunkHeader header;
  EXPECT_THAT(header.Read(input), IsOk());
  EXPECT_THAT(header.id, Eq("TEST"));
  EXPECT_THAT(header.data_size, Eq(12));
}

TEST(ChunkHeaderTest, ReadSuccessOddSize) {
  // "ODDT" ID, size 13 (0x0000000D in little-endian)
  const unsigned char data[] = {'O', 'D', 'D', 'T', 0x0D, 0x00, 0x00, 0x00};
  std::string data_str(reinterpret_cast<const char*>(data), sizeof(data));
  riegeli::StringReader input(data_str);

  ChunkHeader header;
  EXPECT_THAT(header.Read(input), IsOk());
  EXPECT_THAT(header.id, Eq("ODDT"));
  EXPECT_THAT(header.data_size, Eq(13));
}

TEST(ChunkHeaderTest, ReadInputTooShortForId) {
  const unsigned char data[] = {'T', 'E', 'S'};
  std::string data_str(reinterpret_cast<const char*>(data), sizeof(data));
  riegeli::StringReader input(data_str);

  ChunkHeader header;
  EXPECT_THAT(header.Read(input), StatusIs(absl::StatusCode::kDataLoss));
}

TEST(ChunkHeaderTest, ReadInputTooShortForSize) {
  const unsigned char data[] = {'T', 'E', 'S', 'T', 0x0C, 0x00, 0x00};
  std::string data_str(reinterpret_cast<const char*>(data), sizeof(data));
  riegeli::StringReader input(data_str);

  ChunkHeader header;
  EXPECT_THAT(header.Read(input), StatusIs(absl::StatusCode::kDataLoss));
}

TEST(ChunkHeaderTest, WriteSuccess) {
  ChunkHeader header;
  header.id = "WAVE";
  header.data_size = 42;  // 0x2A

  std::string output_str;
  riegeli::StringWriter output(&output_str);
  EXPECT_THAT(header.Write(output), IsOk());
  EXPECT_TRUE(output.Close());

  const unsigned char expected_data[] = {'W',  'A',  'V',  'E',
                                         0x2A, 0x00, 0x00, 0x00};
  EXPECT_THAT(output_str,
              Eq(std::string(reinterpret_cast<const char*>(expected_data),
                             sizeof(expected_data))));
}

TEST(ChunkHeaderTest, WriteSuccessOddSize) {
  ChunkHeader header;
  header.id = "FMT ";
  header.data_size = 17;  // 0x11

  std::string output_str;
  riegeli::StringWriter output(&output_str);
  EXPECT_THAT(header.Write(output), IsOk());
  EXPECT_TRUE(output.Close());

  const unsigned char expected_data[] = {'F',  'M',  'T',  ' ',
                                         0x11, 0x00, 0x00, 0x00};
  EXPECT_THAT(output_str,
              Eq(std::string(reinterpret_cast<const char*>(expected_data),
                             sizeof(expected_data))));
}

TEST(ChunkHeaderTest, WriteInvalidIdLength) {
  ChunkHeader header;
  header.id = "TOO_LONG";
  header.data_size = 10;

  std::string output_str;
  riegeli::StringWriter output(&output_str);
  EXPECT_THAT(header.Write(output),
              StatusIs(absl::StatusCode::kInvalidArgument));
  EXPECT_TRUE(output.Close());
  EXPECT_TRUE(output_str.empty());
}

}  // namespace
}  // namespace credentio