big cleanup

src/test/CMakeLists.txt

@@ -5,6 +5,7 @@ add_executable(
   test/yaze_test.cc
   # test/libc_test.cc
   test/rom_test.cc
+  test/core/message_test.cc
   test/gfx/compression_test.cc
   test/gfx/snes_palette_test.cc
   test/integration/test_editor.cc

src/test/core/message_test.cc

@@ -0,0 +1,137 @@
+#include "core/message.h"
+
+#include <gtest/gtest.h>
+
+namespace yaze {
+namespace test {
+namespace message_system {
+
+using app::core::IMessageListener;
+using app::core::IMessageProtocol;
+using app::core::Message;
+using app::core::MessageDispatcher;
+using app::core::MessageFilter;
+
+class TestListener : public IMessageListener {
+ public:
+  ~TestListener() = default;
+
+  absl::Status OnMessageReceived(const Message& message) override {
+    last_message_ = message;
+    message_count_++;
+    return absl::OkStatus();
+  }
+
+  const Message& last_message() const { return last_message_; }
+  int message_count() const { return message_count_; }
+
+ private:
+  Message last_message_;
+  int message_count_ = 0;
+};
+
+class TestProtocol : public IMessageProtocol {
+ public:
+  bool CanHandleMessage(const Message& message) const override {
+    return message.type == "TestMessage";
+  }
+};
+
+class TestFilter : public MessageFilter {
+ public:
+  bool ShouldReceiveMessage(const Message& message) const override {
+    return std::any_cast<int>(message.payload) > 10;
+  }
+};
+
+class MessageDispatcherTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    message_count_ = 0;
+    protocol_ = std::make_unique<TestProtocol>();
+    filter_ = std::make_unique<TestFilter>();
+  }
+
+  void TearDown() override {
+    protocol_.reset();
+    filter_.reset();
+  }
+
+  int message_count_ = 0;
+  int message_count1_ = 0;
+  int message_count2_ = 0;
+  TestListener listener1_;
+  TestListener listener2_;
+  std::unique_ptr<TestProtocol> protocol_;
+  std::unique_ptr<TestFilter> filter_;
+};
+TEST_F(MessageDispatcherTest, RegisterAndSendMessage) {
+  MessageDispatcher dispatcher;
+
+  dispatcher.RegisterListener("TestMessage", &listener1_);
+
+  Message message("TestMessage", nullptr, 42);
+  dispatcher.SendMessage(message);
+
+  EXPECT_EQ(listener1_.message_count(), 1);
+  EXPECT_EQ(std::any_cast<int>(listener1_.last_message().payload), 42);
+}
+
+TEST_F(MessageDispatcherTest, UnregisterListener) {
+  MessageDispatcher dispatcher;
+
+  dispatcher.RegisterListener("TestMessage", &listener1_);
+  dispatcher.UnregisterListener("TestMessage", &listener1_);
+
+  Message message("TestMessage", nullptr, 42);
+  dispatcher.SendMessage(message);
+
+  EXPECT_EQ(listener1_.message_count(), 0);
+}
+
+TEST_F(MessageDispatcherTest, MultipleListeners) {
+  MessageDispatcher dispatcher;
+
+  dispatcher.RegisterListener("TestMessage", &listener1_);
+  dispatcher.RegisterListener("TestMessage", &listener2_);
+
+  Message message("TestMessage", nullptr, 42);
+  dispatcher.SendMessage(message);
+
+  EXPECT_EQ(listener1_.message_count(), 1);
+  EXPECT_EQ(listener2_.message_count(), 1);
+  EXPECT_EQ(std::any_cast<int>(listener1_.last_message().payload), 42);
+  EXPECT_EQ(std::any_cast<int>(listener2_.last_message().payload), 42);
+}
+
+TEST_F(MessageDispatcherTest, ProtocolBasedHandling) {
+  MessageDispatcher dispatcher;
+
+  dispatcher.RegisterProtocol(protocol_.get());
+  dispatcher.RegisterListener("TestMessage", &listener1_);
+
+  Message message("TestMessage", nullptr, 42);
+  dispatcher.DispatchMessage(message);
+
+  EXPECT_EQ(listener1_.message_count(), 1);
+  EXPECT_EQ(std::any_cast<int>(listener1_.last_message().payload), 42);
+}
+
+TEST_F(MessageDispatcherTest, FilteredMessageHandling) {
+  MessageDispatcher dispatcher;
+
+  dispatcher.RegisterFilteredListener("TestMessage", &listener1_,
+                                      std::move(filter_));
+
+  Message valid_message("TestMessage", nullptr, 15);
+  dispatcher.DispatchMessage(valid_message);
+  EXPECT_EQ(listener1_.message_count(), 1);
+
+  Message invalid_message("TestMessage", nullptr, 5);
+  dispatcher.DispatchMessage(invalid_message);
+  EXPECT_EQ(listener1_.message_count(), 1);
+}
+
+}  // namespace message_system
+}  // namespace test
+}  // namespace yaze

src/test/gfx/compression_test.cc

@@ -33,7 +33,7 @@ using ::testing::TypedEq;
 
 namespace {
 
-Bytes ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
+std::vector<uint8_t> ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
   auto load_status = rom.LoadFromPointer(in, in_size, false);
   EXPECT_TRUE(load_status.ok());
   auto compression_status = CompressV3(rom.vector(), 0, in_size);
@@ -42,7 +42,8 @@ Bytes ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
   return compressed_bytes;
 }
 
-Bytes ExpectDecompressBytesOk(Rom& rom, Bytes& in) {
+std::vector<uint8_t> ExpectDecompressBytesOk(Rom& rom,
+                                             std::vector<uint8_t>& in) {
   auto load_status = rom.LoadFromBytes(in);
   EXPECT_TRUE(load_status.ok());
   auto decompression_status = DecompressV2(rom.data(), 0, in.size());
@@ -51,7 +52,7 @@ Bytes ExpectDecompressBytesOk(Rom& rom, Bytes& in) {
   return decompressed_bytes;
 }
 
-Bytes ExpectDecompressOk(Rom& rom, uchar* in, int in_size) {
+std::vector<uint8_t> ExpectDecompressOk(Rom& rom, uchar* in, int in_size) {
   auto load_status = rom.LoadFromPointer(in, in_size, false);
   EXPECT_TRUE(load_status.ok());
   auto decompression_status = DecompressV2(rom.data(), 0, in_size);
@@ -73,16 +74,16 @@ std::shared_ptr<CompressionPiece> ExpectNewCompressionPieceOk(
 void AssertCompressionQuality(
     const std::vector<uint8_t>& uncompressed_data,
     const std::vector<uint8_t>& expected_compressed_data) {
-  absl::StatusOr<Bytes> result =
+  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));
 }
 
-Bytes ExpectCompressV3Ok(const std::vector<uint8_t>& uncompressed_data,
+std::vector<uint8_t> ExpectCompressV3Ok(const std::vector<uint8_t>& uncompressed_data,
                          const std::vector<uint8_t>& expected_compressed_data) {
-  absl::StatusOr<Bytes> result =
+  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);
@@ -396,7 +397,7 @@ TEST(CheckIncByteV3Test, NotAnIncreasingSequence) {
 
 TEST(LC_LZ2_CompressionTest, DecompressionValidCommand) {
   Rom rom;
-  Bytes simple_copy_input = {BUILD_HEADER(0x00, 0x02), 0x2A, 0x45, 0xFF};
+  std::vector<uint8_t> simple_copy_input = {BUILD_HEADER(0x00, 0x02), 0x2A, 0x45, 0xFF};
   uchar simple_copy_output[2] = {0x2A, 0x45};
   auto decomp_result = ExpectDecompressBytesOk(rom, simple_copy_input);
   EXPECT_THAT(simple_copy_output, ElementsAreArray(decomp_result.data(), 2));