compression_test.cc

Go to the documentation of this file.

#include "app/gfx/compression.h"
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <cstdint>
#include <array>
 
#include "absl/status/statusor.h"
#include "app/rom.h"
 
#define BUILD_HEADER(command, length) (command << 5) + (length - 1)
 
namespace yaze {
namespace test {
 
using yaze::Rom;
using yaze::gfx::lc_lz2::CompressionContext;
using yaze::gfx::lc_lz2::CompressionPiece;
using yaze::gfx::lc_lz2::CompressV2;
using yaze::gfx::lc_lz2::CompressV3;
using yaze::gfx::lc_lz2::DecompressV2;
using yaze::gfx::lc_lz2::kCommandByteFill;
using yaze::gfx::lc_lz2::kCommandDirectCopy;
using yaze::gfx::lc_lz2::kCommandIncreasingFill;
using yaze::gfx::lc_lz2::kCommandLongLength;
using yaze::gfx::lc_lz2::kCommandRepeatingBytes;
using yaze::gfx::lc_lz2::kCommandWordFill;
 
using ::testing::ElementsAre;
using ::testing::ElementsAreArray;
using ::testing::TypedEq;
 
namespace {
 
std::vector<uint8_t> ExpectCompressOk(Rom& rom, uint8_t* in, int in_size) {
  std::vector<uint8_t> data(in, in + in_size);
  auto load_status = rom.LoadFromData(data, false);
  EXPECT_TRUE(load_status.ok());
  auto compression_status = CompressV3(rom.vector(), 0, in_size);
  EXPECT_TRUE(compression_status.ok());
  auto compressed_bytes = std::move(*compression_status);
  return compressed_bytes;
}
 
std::vector<uint8_t> ExpectDecompressBytesOk(Rom& rom,
                                             std::vector<uint8_t>& in) {
  auto load_status = rom.LoadFromData(in, false);
  EXPECT_TRUE(load_status.ok());
  auto decompression_status = DecompressV2(rom.data(), 0, in.size());
  EXPECT_TRUE(decompression_status.ok());
  auto decompressed_bytes = std::move(*decompression_status);
  return decompressed_bytes;
}
 
std::vector<uint8_t> ExpectDecompressOk(Rom& rom, uint8_t* in, int in_size) {
  std::vector<uint8_t> data(in, in + in_size);
  auto load_status = rom.LoadFromData(data, false);
  EXPECT_TRUE(load_status.ok());
  auto decompression_status = DecompressV2(rom.data(), 0, in_size);
  EXPECT_TRUE(decompression_status.ok());
  auto decompressed_bytes = std::move(*decompression_status);
  return decompressed_bytes;
}
 
std::shared_ptr<CompressionPiece> ExpectNewCompressionPieceOk(
    const char command, const int length, std::string& args,
    const int argument_length) {
  auto new_piece = std::make_shared<CompressionPiece>(command, length, args,
                                                      argument_length);
  EXPECT_TRUE(new_piece != nullptr);
  return new_piece;
}
 
// Helper function to assert compression quality.
void AssertCompressionQuality(
    const std::vector<uint8_t>& uncompressed_data,
    const std::vector<uint8_t>& expected_compressed_data) {
  absl::StatusOr<std::vector<uint8_t>> result =
      CompressV3(uncompressed_data, 0, uncompressed_data.size(), 0, false);
  ASSERT_TRUE(result.ok());
  auto compressed_data = std::move(*result);
  EXPECT_THAT(compressed_data, ElementsAreArray(expected_compressed_data));
}
 
std::vector<uint8_t> ExpectCompressV3Ok(
    const std::vector<uint8_t>& uncompressed_data,
    const std::vector<uint8_t>& expected_compressed_data) {
  absl::StatusOr<std::vector<uint8_t>> result =
      CompressV3(uncompressed_data, 0, uncompressed_data.size(), 0, false);
  EXPECT_TRUE(result.ok());
  auto compressed_data = std::move(*result);
  return compressed_data;
}
 
std::vector<uint8_t> CreateRepeatedBetweenUncompressable(
    int leftUncompressedSize, int repeatedByteSize, int rightUncompressedSize) {
  std::vector<uint8_t> result(
      leftUncompressedSize + repeatedByteSize + rightUncompressedSize, 0);
  std::fill_n(result.begin() + leftUncompressedSize, repeatedByteSize, 0x00);
  return result;
}
 
}  // namespace
 
TEST(LC_LZ2_CompressionTest, TrivialRepeatedBytes) {
  AssertCompressionQuality({0x00, 0x00, 0x00}, {0x22, 0x00, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, RepeatedBytesBetweenUncompressable) {
  AssertCompressionQuality({0x01, 0x00, 0x00, 0x00, 0x10},
                           {0x04, 0x01, 0x00, 0x00, 0x00, 0x10, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, RepeatedBytesBeforeUncompressable) {
  AssertCompressionQuality({0x00, 0x00, 0x00, 0x10},
                           {0x22, 0x00, 0x00, 0x10, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, RepeatedBytesAfterUncompressable) {
  AssertCompressionQuality({0x01, 0x00, 0x00, 0x00},
                           {0x00, 0x01, 0x22, 0x00, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, RepeatedBytesAfterUncompressableRepeated) {
  AssertCompressionQuality(
      {0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02},
      {0x22, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x02, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, RepeatedBytesBeforeUncompressableRepeated) {
  AssertCompressionQuality(
      {0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00},
      {0x04, 0x01, 0x00, 0x00, 0x00, 0x02, 0x22, 0x00, 0xFF});
}
 
TEST(LC_LZ2_CompressionTest, NewDecompressionPieceOk) {
  char command = 1;
  int length = 1;
  char args[] = "aaa";
  int argument_length = 0x02;
  CompressionPiece old_piece;
  old_piece.command = command;
  old_piece.length = length;
  old_piece.argument = args;
  old_piece.argument_length = argument_length;
  old_piece.next = nullptr;
 
  std::string new_args = "aaa";
 
  auto new_piece = ExpectNewCompressionPieceOk(0x01, 0x01, new_args, 0x02);
 
  EXPECT_EQ(old_piece.command, new_piece->command);
  EXPECT_EQ(old_piece.length, new_piece->length);
  ASSERT_EQ(old_piece.argument_length, new_piece->argument_length);
  for (int i = 0; i < old_piece.argument_length; ++i) {
    EXPECT_EQ(old_piece.argument[i], new_piece->argument[i]);
  }
}
 
// TODO: Check why header built is off by one
// 0x25 instead of 0x24
TEST(LC_LZ2_CompressionTest, CompressionSingleSet) {
  Rom rom;
  uint8_t single_set[5] = {0x2A, 0x2A, 0x2A, 0x2A, 0x2A};
  uint8_t single_set_expected[3] = {BUILD_HEADER(1, 5), 0x2A, 0xFF};
 
  auto comp_result = ExpectCompressOk(rom, single_set, 5);
  EXPECT_THAT(single_set_expected, ElementsAreArray(comp_result.data(), 3));
}
 
TEST(LC_LZ2_CompressionTest, CompressionSingleWord) {
  Rom rom;
  uint8_t single_word[6] = {0x2A, 0x01, 0x2A, 0x01, 0x2A, 0x01};
  uint8_t single_word_expected[4] = {BUILD_HEADER(0x02, 0x06), 0x2A, 0x01, 0xFF};
 
  auto comp_result = ExpectCompressOk(rom, single_word, 6);
  EXPECT_THAT(single_word_expected, ElementsAreArray(comp_result.data(), 4));
}
 
TEST(LC_LZ2_CompressionTest, CompressionSingleIncrement) {
  Rom rom;
  uint8_t single_inc[3] = {0x01, 0x02, 0x03};
  uint8_t single_inc_expected[3] = {BUILD_HEADER(0x03, 0x03), 0x01, 0xFF};
  auto comp_result = ExpectCompressOk(rom, single_inc, 3);
  EXPECT_THAT(single_inc_expected, ElementsAreArray(comp_result.data(), 3));
}
 
TEST(LC_LZ2_CompressionTest, CompressionSingleCopy) {
  Rom rom;
  uint8_t single_copy[4] = {0x03, 0x0A, 0x07, 0x14};
  uint8_t single_copy_expected[6] = {
      BUILD_HEADER(0x00, 0x04), 0x03, 0x0A, 0x07, 0x14, 0xFF};
  auto comp_result = ExpectCompressOk(rom, single_copy, 4);
  EXPECT_THAT(single_copy_expected, ElementsAreArray(comp_result.data(), 6));
}
 
TEST(LC_LZ2_CompressionTest, CompressionSingleOverflowIncrement) {
  AssertCompressionQuality({0xFE, 0xFF, 0x00, 0x01},
                           {BUILD_HEADER(0x03, 0x04), 0xFE, 0xFF});
}

// Tests for HandleDirectCopy
 
TEST(HandleDirectCopyTest, NotDirectCopyWithAccumulatedBytes) {
  CompressionContext context({0x01, 0x02, 0x03}, 0, 3);
  context.cmd_with_max = kCommandByteFill;
  context.comp_accumulator = 2;
  HandleDirectCopy(context);
  EXPECT_EQ(context.compressed_data.size(), 3);
}
 
TEST(HandleDirectCopyTest, NotDirectCopyWithoutAccumulatedBytes) {
  CompressionContext context({0x01, 0x02, 0x03}, 0, 3);
  context.cmd_with_max = kCommandByteFill;
  HandleDirectCopy(context);
  EXPECT_EQ(context.compressed_data.size(), 2);  // Header + 1 byte
}
 
TEST(HandleDirectCopyTest, AccumulateBytesWithoutMax) {
  CompressionContext context({0x01, 0x02, 0x03}, 0, 3);
  context.cmd_with_max = kCommandDirectCopy;
  HandleDirectCopy(context);
  EXPECT_EQ(context.comp_accumulator, 1);
  EXPECT_EQ(context.compressed_data.size(), 0);  // No data added yet
}
 
// Tests for CheckIncByteV3
 
TEST(CheckIncByteV3Test, IncreasingSequence) {
  CompressionContext context({0x01, 0x02, 0x03}, 0, 3);
  CheckIncByteV3(context);
  EXPECT_EQ(context.current_cmd.data_size[kCommandIncreasingFill], 3);
}
 
TEST(CheckIncByteV3Test, IncreasingSequenceSurroundedByIdenticalBytes) {
  CompressionContext context({0x01, 0x02, 0x03, 0x04, 0x01}, 1,
                             3);  // Start from index 1
  CheckIncByteV3(context);
  EXPECT_EQ(context.current_cmd.data_size[kCommandIncreasingFill],
            0);  // Reset to prioritize direct copy
}
 
TEST(CheckIncByteV3Test, NotAnIncreasingSequence) {
  CompressionContext context({0x01, 0x01, 0x03}, 0, 3);
  CheckIncByteV3(context);
  EXPECT_EQ(context.current_cmd.data_size[kCommandIncreasingFill],
            1);  // Only one byte is detected
}
 
TEST(LC_LZ2_CompressionTest, DecompressionValidCommand) {
  Rom rom;
  std::vector<uint8_t> simple_copy_input = {BUILD_HEADER(0x00, 0x02), 0x2A,
                                            0x45, 0xFF};
  uint8_t simple_copy_output[2] = {0x2A, 0x45};
  auto decomp_result = ExpectDecompressBytesOk(rom, simple_copy_input);
  EXPECT_THAT(simple_copy_output, ElementsAreArray(decomp_result.data(), 2));
}
 
TEST(LC_LZ2_CompressionTest, DecompressionMixingCommand) {
  Rom rom;
  uint8_t random1_i[11] = {BUILD_HEADER(0x01, 0x03),
                         0x2A,
                         BUILD_HEADER(0x00, 0x04),
                         0x01,
                         0x02,
                         0x03,
                         0x04,
                         BUILD_HEADER(0x02, 0x02),
                         0x0B,
                         0x16,
                         0xFF};
  uint8_t random1_o[9] = {42, 42, 42, 1, 2, 3, 4, 11, 22};
  auto decomp_result = ExpectDecompressOk(rom, random1_i, 11);
  EXPECT_THAT(random1_o, ElementsAreArray(decomp_result.data(), 9));
}
 
}  // namespace test
}  // namespace yaze