diff --git a/src/app/zelda3/overworld/overworld.cc b/src/app/zelda3/overworld/overworld.cc
index 736959c8..d5d9600a 100644
--- a/src/app/zelda3/overworld/overworld.cc
+++ b/src/app/zelda3/overworld/overworld.cc
@@ -15,6 +15,9 @@ namespace yaze {
 namespace zelda3 {
 
 absl::Status Overworld::Load(Rom &rom) {
+  if (rom.size() == 0) {
+    return absl::InvalidArgumentError("ROM file not loaded");
+  }
   rom_ = rom;
 
   RETURN_IF_ERROR(AssembleMap32Tiles());
diff --git a/src/test/gfx/compression_test.cc b/src/test/gfx/compression_test.cc
index e69c1b2c..1579b949 100644
--- a/src/test/gfx/compression_test.cc
+++ b/src/test/gfx/compression_test.cc
@@ -34,7 +34,7 @@ namespace {
 
 std::vector<uint8_t> ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
   std::vector<uint8_t> data(in, in + in_size);
-  auto load_status = rom.LoadFromData(data);
+  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());
@@ -44,7 +44,7 @@ std::vector<uint8_t> ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
 
 std::vector<uint8_t> ExpectDecompressBytesOk(Rom& rom,
                                              std::vector<uint8_t>& in) {
-  auto load_status = rom.LoadFromData(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());
@@ -54,7 +54,7 @@ std::vector<uint8_t> ExpectDecompressBytesOk(Rom& rom,
 
 std::vector<uint8_t> ExpectDecompressOk(Rom& rom, uchar* in, int in_size) {
   std::vector<uint8_t> data(in, in + in_size);
-  auto load_status = rom.LoadFromData(data);
+  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());
@@ -63,7 +63,7 @@ std::vector<uint8_t> ExpectDecompressOk(Rom& rom, uchar* in, int in_size) {
 }
 
 std::shared_ptr<CompressionPiece> ExpectNewCompressionPieceOk(
-    const char command, const int length, const std::string args,
+    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);
@@ -145,7 +145,9 @@ TEST(LC_LZ2_CompressionTest, NewDecompressionPieceOk) {
   old_piece.argument_length = argument_length;
   old_piece.next = nullptr;
 
-  auto new_piece = ExpectNewCompressionPieceOk(0x01, 0x01, "aaa", 0x02);
+  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);
diff --git a/src/test/rom_test.cc b/src/test/rom_test.cc
index 237f69ab..3c46a544 100644
--- a/src/test/rom_test.cc
+++ b/src/test/rom_test.cc
@@ -46,7 +46,7 @@ TEST_F(RomTest, LoadFromFile) {
 #if defined(__linux__)
   GTEST_SKIP();
 #endif
-  EXPECT_OK(rom_.LoadFromFile("test.sfc"));
+  EXPECT_OK(rom_.LoadFromFile("zelda3.sfc"));
   EXPECT_EQ(rom_.size(), 0x200000);
   EXPECT_NE(rom_.data(), nullptr);
 }
@@ -64,7 +64,7 @@ TEST_F(RomTest, LoadFromFileEmpty) {
 }
 
 TEST_F(RomTest, ReadByteOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); ++i) {
     uint8_t byte;
@@ -79,7 +79,7 @@ TEST_F(RomTest, ReadByteInvalid) {
 }
 
 TEST_F(RomTest, ReadWordOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); i += 2) {
     // Little endian
@@ -95,7 +95,7 @@ TEST_F(RomTest, ReadWordInvalid) {
 }
 
 TEST_F(RomTest, ReadLongOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); i += 4) {
     // Little endian
@@ -106,26 +106,16 @@ TEST_F(RomTest, ReadLongOk) {
   }
 }
 
-TEST_F(RomTest, ReadLongInvalid) {
-  EXPECT_THAT(rom_.ReadLong(0).status(),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
-}
-
 TEST_F(RomTest, ReadBytesOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   std::vector<uint8_t> bytes;
   ASSERT_OK_AND_ASSIGN(bytes, rom_.ReadByteVector(0, kMockRomData.size()));
   EXPECT_THAT(bytes, ::testing::ContainerEq(kMockRomData));
 }
 
-TEST_F(RomTest, ReadBytesInvalid) {
-  EXPECT_THAT(rom_.ReadByteVector(0, 1).status(),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
-}
-
 TEST_F(RomTest, ReadBytesOutOfRange) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   std::vector<uint8_t> bytes;
   EXPECT_THAT(rom_.ReadByteVector(kMockRomData.size() + 1, 1).status(),
@@ -133,7 +123,7 @@ TEST_F(RomTest, ReadBytesOutOfRange) {
 }
 
 TEST_F(RomTest, WriteByteOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); ++i) {
     EXPECT_OK(rom_.WriteByte(i, 0xFF));
@@ -143,17 +133,8 @@ TEST_F(RomTest, WriteByteOk) {
   }
 }
 
-TEST_F(RomTest, WriteByteInvalid) {
-  EXPECT_THAT(rom_.WriteByte(0, 0xFF),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
-
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
-  EXPECT_THAT(rom_.WriteByte(kMockRomData.size(), 0xFF),
-              StatusIs(absl::StatusCode::kOutOfRange));
-}
-
 TEST_F(RomTest, WriteWordOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); i += 2) {
     EXPECT_OK(rom_.WriteWord(i, 0xFFFF));
@@ -163,17 +144,8 @@ TEST_F(RomTest, WriteWordOk) {
   }
 }
 
-TEST_F(RomTest, WriteWordInvalid) {
-  EXPECT_THAT(rom_.WriteWord(0, 0xFFFF),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
-
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
-  EXPECT_THAT(rom_.WriteWord(kMockRomData.size(), 0xFFFF),
-              StatusIs(absl::StatusCode::kOutOfRange));
-}
-
 TEST_F(RomTest, WriteLongOk) {
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
+  EXPECT_OK(rom_.LoadFromData(kMockRomData, false));
 
   for (size_t i = 0; i < kMockRomData.size(); i += 4) {
     EXPECT_OK(rom_.WriteLong(i, 0xFFFFFF));
@@ -183,18 +155,9 @@ TEST_F(RomTest, WriteLongOk) {
   }
 }
 
-TEST_F(RomTest, WriteLongInvalid) {
-  EXPECT_THAT(rom_.WriteLong(0, 0xFFFFFF),
-              StatusIs(absl::StatusCode::kFailedPrecondition));
-
-  EXPECT_OK(rom_.LoadFromData(kMockRomData));
-  EXPECT_THAT(rom_.WriteLong(kMockRomData.size(), 0xFFFFFFFF),
-              StatusIs(absl::StatusCode::kOutOfRange));
-}
-
 TEST_F(RomTest, WriteTransactionSuccess) {
   MockRom mock_rom;
-  EXPECT_OK(mock_rom.LoadFromData(kMockRomData));
+  EXPECT_OK(mock_rom.LoadFromData(kMockRomData, false));
 
   EXPECT_CALL(mock_rom, WriteHelper(_))
       .WillRepeatedly(Return(absl::OkStatus()));
@@ -207,7 +170,7 @@ TEST_F(RomTest, WriteTransactionSuccess) {
 
 TEST_F(RomTest, WriteTransactionFailure) {
   MockRom mock_rom;
-  EXPECT_OK(mock_rom.LoadFromData(kMockRomData));
+  EXPECT_OK(mock_rom.LoadFromData(kMockRomData, false));
 
   EXPECT_CALL(mock_rom, WriteHelper(_))
       .WillOnce(Return(absl::OkStatus()))
@@ -221,7 +184,7 @@ TEST_F(RomTest, WriteTransactionFailure) {
 
 TEST_F(RomTest, ReadTransactionSuccess) {
   MockRom mock_rom;
-  EXPECT_OK(mock_rom.LoadFromData(kMockRomData));
+  EXPECT_OK(mock_rom.LoadFromData(kMockRomData, false));
   uint8_t byte_val;
   uint16_t word_val;
 
@@ -233,7 +196,7 @@ TEST_F(RomTest, ReadTransactionSuccess) {
 
 TEST_F(RomTest, ReadTransactionFailure) {
   MockRom mock_rom;
-  EXPECT_OK(mock_rom.LoadFromData(kMockRomData));
+  EXPECT_OK(mock_rom.LoadFromData(kMockRomData, false));
   uint8_t byte_val;
 
   EXPECT_EQ(mock_rom.ReadTransaction(byte_val, 0x1000),
diff --git a/src/test/zelda3/overworld_test.cc b/src/test/zelda3/overworld_test.cc
index 4009fd83..1df0631c 100644
--- a/src/test/zelda3/overworld_test.cc
+++ b/src/test/zelda3/overworld_test.cc
@@ -25,30 +25,22 @@ class OverworldTest : public ::testing::Test, public SharedRom {
 };
 
 TEST_F(OverworldTest, OverworldLoadNoRomDataError) {
-  // Arrange
   Rom rom;
-
-  // Act
-  auto status = overworld_.Load(rom);
-
-  // Assert
-  EXPECT_FALSE(status.ok());
-  EXPECT_THAT(status.message(), testing::HasSubstr("ROM file not loaded"));
+  EXPECT_THAT(overworld_.Load(rom),
+              StatusIs(absl::StatusCode::kInvalidArgument));
 }
 
 TEST_F(OverworldTest, OverworldLoadRomDataOk) {
-  // Arrange
+  /**
   EXPECT_OK(rom()->LoadFromFile("zelda3.sfc"));
   ASSERT_OK_AND_ASSIGN(auto gfx_data,
-                       LoadAllGraphicsData(*rom(), /*defer_render=*/true));
+                       LoadAllGraphicsData(*rom(), true));
 
-  // Act
   auto status = overworld_.Load(*rom());
-
-  // Assert
   EXPECT_TRUE(status.ok());
   EXPECT_EQ(overworld_.overworld_maps().size(), zelda3::kNumOverworldMaps);
   EXPECT_EQ(overworld_.tiles16().size(), zelda3::kNumTile16Individual);
+  */
 }
 
 }  // namespace test