diff --git a/src/app/editor/graphics/graphics_editor.cc b/src/app/editor/graphics/graphics_editor.cc index 1f6485cf..57b3f6fd 100644 --- a/src/app/editor/graphics/graphics_editor.cc +++ b/src/app/editor/graphics/graphics_editor.cc @@ -702,7 +702,7 @@ absl::Status GraphicsEditor::DrawClipboardImport() { const auto clipboard_data = std::vector(text, text + strlen(text)); ImGui::MemFree((void*)text); - status_ = temp_rom_.LoadFromBytes(clipboard_data); + status_ = temp_rom_.LoadFromData(clipboard_data); is_open_ = true; open_memory_editor_ = true; } diff --git a/src/app/gfx/compression.cc b/src/app/gfx/compression.cc index 20d5a05e..c696dd38 100644 --- a/src/app/gfx/compression.cc +++ b/src/app/gfx/compression.cc @@ -756,7 +756,7 @@ absl::Status ValidateCompressionResult(CompressionPiecePointer& chain_head, if (chain_head->next != nullptr) { Rom temp_rom; RETURN_IF_ERROR( - temp_rom.LoadFromBytes(CreateCompressionString(chain_head->next, mode))) + temp_rom.LoadFromData(CreateCompressionString(chain_head->next, mode))) ASSIGN_OR_RETURN(auto decomp_data, DecompressV2(temp_rom.data(), 0, temp_rom.size())) if (!std::equal(decomp_data.begin() + start, decomp_data.end(), @@ -1176,7 +1176,7 @@ void AddCompressionToChain(CompressionContext& context) { absl::Status ValidateCompressionResultV3(const CompressionContext& context) { if (!context.compressed_data.empty()) { Rom temp_rom; - RETURN_IF_ERROR(temp_rom.LoadFromBytes(context.compressed_data)); + RETURN_IF_ERROR(temp_rom.LoadFromData(context.compressed_data)); ASSIGN_OR_RETURN(auto decomp_data, DecompressV2(temp_rom.data(), 0, temp_rom.size())) diff --git a/src/app/rom.cc b/src/app/rom.cc index 745d49e9..6e6bd5c5 100644 --- a/src/app/rom.cc +++ b/src/app/rom.cc @@ -214,16 +214,15 @@ absl::Status Rom::LoadFromFile(const std::string &filename, bool z3_load) { return absl::OkStatus(); } -absl::Status Rom::LoadFromPointer(uchar *data, size_t length, bool z3_load) { - if (!data || length == 0) +absl::Status Rom::LoadFromData(const std::vector &data, bool z3_load) { + if (data.empty()) { return absl::InvalidArgumentError( "Could not load ROM: parameter `data` is empty."); - + } if (!palette_groups_.empty()) palette_groups_.clear(); - if (rom_data_.size() < length) rom_data_.resize(length); - std::copy(data, data + length, rom_data_.begin()); - size_ = length; + rom_data_ = data; + size_ = data.size(); is_loaded_ = true; if (z3_load) { @@ -232,17 +231,143 @@ absl::Status Rom::LoadFromPointer(uchar *data, size_t length, bool z3_load) { return absl::OkStatus(); } -absl::Status Rom::LoadFromBytes(const std::vector &data) { - if (data.empty()) { - return absl::InvalidArgumentError( - "Could not load ROM: parameter `data` is empty."); +absl::StatusOr Rom::ReadByte(int offset) { + if (offset >= static_cast(rom_data_.size())) { + return absl::FailedPreconditionError("Offset out of range"); } - rom_data_ = data; - size_ = data.size(); - is_loaded_ = true; + return rom_data_[offset]; +} + +absl::StatusOr Rom::ReadWord(int offset) { + if (offset + 1 >= static_cast(rom_data_.size())) { + return absl::FailedPreconditionError("Offset out of range"); + } + auto result = (uint16_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8)); + return result; +} + +absl::StatusOr Rom::ReadLong(int offset) { + if (offset + 2 >= static_cast(rom_data_.size())) { + return absl::OutOfRangeError("Offset out of range"); + } + auto result = (uint32_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8) | + (rom_data_[offset + 2] << 16)); + return result; +} + +absl::StatusOr> Rom::ReadByteVector( + uint32_t offset, uint32_t length) const { + if (offset + length > static_cast(rom_data_.size())) { + return absl::OutOfRangeError("Offset and length out of range"); + } + std::vector result; + for (uint32_t i = offset; i < offset + length; i++) { + result.push_back(rom_data_[i]); + } + return result; +} + +absl::StatusOr Rom::ReadTile16(uint32_t tile16_id) { + // Skip 8 bytes per tile. + auto tpos = kTile16Ptr + (tile16_id * 0x08); + gfx::Tile16 tile16 = {}; + ASSIGN_OR_RETURN(auto new_tile0, ReadWord(tpos)) + tile16.tile0_ = gfx::WordToTileInfo(new_tile0); + tpos += 2; + ASSIGN_OR_RETURN(auto new_tile1, ReadWord(tpos)) + tile16.tile1_ = gfx::WordToTileInfo(new_tile1); + tpos += 2; + ASSIGN_OR_RETURN(auto new_tile2, ReadWord(tpos)) + tile16.tile2_ = gfx::WordToTileInfo(new_tile2); + tpos += 2; + ASSIGN_OR_RETURN(auto new_tile3, ReadWord(tpos)) + tile16.tile3_ = gfx::WordToTileInfo(new_tile3); + return tile16; +} + +absl::Status Rom::WriteTile16(int tile16_id, const gfx::Tile16 &tile) { + // Skip 8 bytes per tile. + auto tpos = kTile16Ptr + (tile16_id * 0x08); + RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile0_))); + tpos += 2; + RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile1_))); + tpos += 2; + RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile2_))); + tpos += 2; + RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile3_))); return absl::OkStatus(); } +absl::Status Rom::WriteByte(int addr, uint8_t value) { + if (addr >= static_cast(rom_data_.size())) { + return absl::OutOfRangeError(absl::StrFormat( + "Attempt to write byte %#02x value failed, address %d out of range", + value, addr)); + } + rom_data_[addr] = value; + core::logf("WriteByte: %#06X: %s", addr, core::HexByte(value).data()); + return absl::OkStatus(); +} + +absl::Status Rom::WriteWord(int addr, uint16_t value) { + if (addr + 1 >= static_cast(rom_data_.size())) { + return absl::OutOfRangeError(absl::StrFormat( + "Attempt to write word %#04x value failed, address %d out of range", + value, addr)); + } + rom_data_[addr] = (uint8_t)(value & 0xFF); + rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); + core::logf("WriteWord: %#06X: %s", addr, core::HexWord(value).data()); + return absl::OkStatus(); +} + +absl::Status Rom::WriteShort(int addr, uint16_t value) { + if (addr + 1 >= static_cast(rom_data_.size())) { + return absl::OutOfRangeError(absl::StrFormat( + "Attempt to write short %#04x value failed, address %d out of range", + value, addr)); + } + rom_data_[addr] = (uint8_t)(value & 0xFF); + rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); + core::logf("WriteShort: %#06X: %s", addr, core::HexWord(value).data()); + return absl::OkStatus(); +} + +absl::Status Rom::WriteLong(uint32_t addr, uint32_t value) { + if (addr + 2 >= static_cast(rom_data_.size())) { + return absl::OutOfRangeError(absl::StrFormat( + "Attempt to write long %#06x value failed, address %d out of range", + value, addr)); + } + rom_data_[addr] = (uint8_t)(value & 0xFF); + rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); + rom_data_[addr + 2] = (uint8_t)((value >> 16) & 0xFF); + core::logf("WriteLong: %#06X: %s", addr, core::HexLong(value).data()); + return absl::OkStatus(); +} + +absl::Status Rom::WriteVector(int addr, std::vector data) { + if (addr + static_cast(data.size()) > + static_cast(rom_data_.size())) { + return absl::InvalidArgumentError(absl::StrFormat( + "Attempt to write vector value failed, address %d out of range", addr)); + } + for (int i = 0; i < static_cast(data.size()); i++) { + rom_data_[addr + i] = data[i]; + } + core::logf("WriteVector: %#06X: %s", addr, core::HexByte(data[0]).data()); + return absl::OkStatus(); +} + +absl::Status Rom::WriteColor(uint32_t address, const gfx::SnesColor &color) { + uint16_t bgr = ((color.snes() >> 10) & 0x1F) | ((color.snes() & 0x1F) << 10) | + (color.snes() & 0x7C00); + + // Write the 16-bit color value to the ROM at the specified address + core::logf("WriteColor: %#06X: %s", address, core::HexWord(bgr).data()); + return WriteShort(address, bgr); +} + absl::Status Rom::LoadZelda3() { // Check if the ROM has a header constexpr size_t kBaseRomSize = 1048576; // 1MB diff --git a/src/app/rom.h b/src/app/rom.h index 359a610c..078adedb 100644 --- a/src/app/rom.h +++ b/src/app/rom.h @@ -41,9 +41,7 @@ constexpr uint32_t kNumRoomBlocksets = 82; constexpr uint32_t kNumSpritesets = 144; constexpr uint32_t kNumPalettesets = 72; constexpr uint32_t kEntranceGfxGroup = 0x5D97; - -// TODO: Verify what this was used for in ZS -constexpr uint32_t kMaxGraphics = 0xC3FB5; +constexpr uint32_t kMaxGraphics = 0x0C3FFF; // 0xC3FB5 /** * @brief A map of version constants for each version of the game. @@ -69,8 +67,8 @@ class Rom { * */ absl::Status LoadFromFile(const std::string& filename, bool z3_load = true); - absl::Status LoadFromPointer(uchar* data, size_t length, bool z3_load = true); - absl::Status LoadFromBytes(const std::vector& data); + absl::Status LoadFromData(const std::vector& data, + bool z3_load = true); /** * @brief Saves the Rom data to a file @@ -102,17 +100,11 @@ class Rom { */ absl::Status SaveAllPalettes(); - /** - * @brief Expand the Rom data to a specified size. - */ void Expand(int size) { rom_data_.resize(size); size_ = size; } - /** - * @brief Close the Rom file. - */ absl::Status Close() { rom_data_.clear(); size_ = 0; @@ -120,165 +112,20 @@ class Rom { return absl::OkStatus(); } - /** - * @brief Precondition check for reading and writing to the Rom. - */ - absl::Status ReadWritePreconditions() const { - if (!is_loaded_) { - return absl::FailedPreconditionError("ROM file not loaded"); - } - if (rom_data_.empty() || size_ == 0) { - return absl::FailedPreconditionError( - "File was loaded, but ROM data was empty."); - } - return absl::OkStatus(); - } - - absl::StatusOr ReadByte(int offset) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (offset >= static_cast(rom_data_.size())) { - return absl::FailedPreconditionError("Offset out of range"); - } - return rom_data_[offset]; - } - - absl::StatusOr ReadWord(int offset) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (offset + 1 >= static_cast(rom_data_.size())) { - return absl::FailedPreconditionError("Offset out of range"); - } - auto result = (uint16_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8)); - return result; - } - - absl::StatusOr ReadLong(int offset) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (offset + 2 >= static_cast(rom_data_.size())) { - return absl::OutOfRangeError("Offset out of range"); - } - auto result = (uint32_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8) | - (rom_data_[offset + 2] << 16)); - return result; - } - + absl::StatusOr ReadByte(int offset); + absl::StatusOr ReadWord(int offset); + absl::StatusOr ReadLong(int offset); absl::StatusOr> ReadByteVector(uint32_t offset, - uint32_t length) const { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (offset + length > static_cast(rom_data_.size())) { - return absl::OutOfRangeError("Offset and length out of range"); - } - std::vector result; - for (uint32_t i = offset; i < offset + length; i++) { - result.push_back(rom_data_[i]); - } - return result; - } + uint32_t length) const; + absl::StatusOr ReadTile16(uint32_t tile16_id); - absl::StatusOr ReadTile16(uint32_t tile16_id) { - // Skip 8 bytes per tile. - auto tpos = kTile16Ptr + (tile16_id * 0x08); - gfx::Tile16 tile16 = {}; - ASSIGN_OR_RETURN(auto new_tile0, ReadWord(tpos)) - tile16.tile0_ = gfx::WordToTileInfo(new_tile0); - tpos += 2; - ASSIGN_OR_RETURN(auto new_tile1, ReadWord(tpos)) - tile16.tile1_ = gfx::WordToTileInfo(new_tile1); - tpos += 2; - ASSIGN_OR_RETURN(auto new_tile2, ReadWord(tpos)) - tile16.tile2_ = gfx::WordToTileInfo(new_tile2); - tpos += 2; - ASSIGN_OR_RETURN(auto new_tile3, ReadWord(tpos)) - tile16.tile3_ = gfx::WordToTileInfo(new_tile3); - return tile16; - } - - absl::Status WriteTile16(int tile16_id, const gfx::Tile16& tile) { - // Skip 8 bytes per tile. - auto tpos = kTile16Ptr + (tile16_id * 0x08); - RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile0_))); - tpos += 2; - RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile1_))); - tpos += 2; - RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile2_))); - tpos += 2; - RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile3_))); - return absl::OkStatus(); - } - - absl::Status WriteByte(int addr, uint8_t value) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (addr >= static_cast(rom_data_.size())) { - return absl::OutOfRangeError(absl::StrFormat( - "Attempt to write byte %#02x value failed, address %d out of range", - value, addr)); - } - rom_data_[addr] = value; - core::logf("WriteByte: %#06X: %s", addr, core::HexByte(value).data()); - return absl::OkStatus(); - } - - absl::Status WriteWord(int addr, uint16_t value) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (addr + 1 >= static_cast(rom_data_.size())) { - return absl::OutOfRangeError(absl::StrFormat( - "Attempt to write word %#04x value failed, address %d out of range", - value, addr)); - } - rom_data_[addr] = (uint8_t)(value & 0xFF); - rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); - core::logf("WriteWord: %#06X: %s", addr, core::HexWord(value).data()); - return absl::OkStatus(); - } - - absl::Status WriteShort(int addr, uint16_t value) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (addr + 1 >= static_cast(rom_data_.size())) { - return absl::OutOfRangeError(absl::StrFormat( - "Attempt to write short %#04x value failed, address %d out of range", - value, addr)); - } - rom_data_[addr] = (uint8_t)(value & 0xFF); - rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); - core::logf("WriteShort: %#06X: %s", addr, core::HexWord(value).data()); - return absl::OkStatus(); - } - - absl::Status WriteLong(uint32_t addr, uint32_t value) { - RETURN_IF_ERROR(ReadWritePreconditions()); - if (addr + 2 >= static_cast(rom_data_.size())) { - return absl::OutOfRangeError(absl::StrFormat( - "Attempt to write long %#06x value failed, address %d out of range", - value, addr)); - } - rom_data_[addr] = (uint8_t)(value & 0xFF); - rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF); - rom_data_[addr + 2] = (uint8_t)((value >> 16) & 0xFF); - core::logf("WriteLong: %#06X: %s", addr, core::HexLong(value).data()); - return absl::OkStatus(); - } - - absl::Status WriteVector(int addr, std::vector data) { - if (addr + static_cast(data.size()) > - static_cast(rom_data_.size())) { - return absl::InvalidArgumentError(absl::StrFormat( - "Attempt to write vector value failed, address %d out of range", - addr)); - } - for (int i = 0; i < static_cast(data.size()); i++) { - rom_data_[addr + i] = data[i]; - } - core::logf("WriteVector: %#06X: %s", addr, core::HexByte(data[0]).data()); - return absl::OkStatus(); - } - - absl::Status WriteColor(uint32_t address, const gfx::SnesColor& color) { - uint16_t bgr = ((color.snes() >> 10) & 0x1F) | - ((color.snes() & 0x1F) << 10) | (color.snes() & 0x7C00); - - // Write the 16-bit color value to the ROM at the specified address - core::logf("WriteColor: %#06X: %s", address, core::HexWord(bgr).data()); - return WriteShort(address, bgr); - } + absl::Status WriteTile16(int tile16_id, const gfx::Tile16& tile); + absl::Status WriteByte(int addr, uint8_t value); + absl::Status WriteWord(int addr, uint16_t value); + absl::Status WriteShort(int addr, uint16_t value); + absl::Status WriteLong(uint32_t addr, uint32_t value); + absl::Status WriteVector(int addr, std::vector data); + absl::Status WriteColor(uint32_t address, const gfx::SnesColor& color); template absl::Status WriteTransaction(Args... args) { @@ -294,18 +141,14 @@ class Rom { if (!status.ok()) { return status; } - if constexpr (sizeof...(args) > 0) { status = ReadTransaction(std::forward(args)...); } - return status; } uint8_t& operator[](unsigned long i) { - if (i > size_) { - throw std::out_of_range("Rom index out of range"); - } + if (i >= size_) throw std::out_of_range("Rom index out of range"); return rom_data_[i]; } diff --git a/src/cli/handlers/tile16_transfer.cc b/src/cli/handlers/tile16_transfer.cc index 991b6ee8..4d88863c 100644 --- a/src/cli/handlers/tile16_transfer.cc +++ b/src/cli/handlers/tile16_transfer.cc @@ -2,7 +2,6 @@ #include #include "absl/status/status.h" -#include "app/core/common.h" #include "app/core/constants.h" #include "app/rom.h" #include "cli/z3ed.h" @@ -82,4 +81,4 @@ absl::Status Tile16Transfer::handle(const std::vector& arg_vec) { } } // namespace cli -} // namespace yaze \ No newline at end of file +} // namespace yaze diff --git a/src/ios/main.mm b/src/ios/main.mm index 46d39aa0..c0e46283 100644 --- a/src/ios/main.mm +++ b/src/ios/main.mm @@ -352,7 +352,11 @@ // Size of the data size_t size = [data length]; - PRINT_IF_ERROR(yaze::SharedRom::shared_rom_->LoadFromPointer(bytes, size)); + std::vector rom_data; + rom_data.resize(size); + std::copy(bytes, bytes + size, rom_data.begin()); + + PRINT_IF_ERROR(yaze::SharedRom::shared_rom_->LoadFromBytes(rom_data)); std::string filename = std::string([selectedFileURL.path UTF8String]); yaze::SharedRom::shared_rom_->set_filename(filename); [selectedFileURL stopAccessingSecurityScopedResource]; diff --git a/src/test/gfx/compression_test.cc b/src/test/gfx/compression_test.cc index 1a058282..e69c1b2c 100644 --- a/src/test/gfx/compression_test.cc +++ b/src/test/gfx/compression_test.cc @@ -33,7 +33,8 @@ using ::testing::TypedEq; namespace { std::vector ExpectCompressOk(Rom& rom, uchar* in, int in_size) { - auto load_status = rom.LoadFromPointer(in, in_size, false); + std::vector data(in, in + in_size); + auto load_status = rom.LoadFromData(data); EXPECT_TRUE(load_status.ok()); auto compression_status = CompressV3(rom.vector(), 0, in_size); EXPECT_TRUE(compression_status.ok()); @@ -43,7 +44,7 @@ std::vector ExpectCompressOk(Rom& rom, uchar* in, int in_size) { std::vector ExpectDecompressBytesOk(Rom& rom, std::vector& in) { - auto load_status = rom.LoadFromBytes(in); + auto load_status = rom.LoadFromData(in); EXPECT_TRUE(load_status.ok()); auto decompression_status = DecompressV2(rom.data(), 0, in.size()); EXPECT_TRUE(decompression_status.ok()); @@ -52,7 +53,8 @@ std::vector ExpectDecompressBytesOk(Rom& rom, } std::vector ExpectDecompressOk(Rom& rom, uchar* in, int in_size) { - auto load_status = rom.LoadFromPointer(in, in_size, false); + std::vector data(in, in + in_size); + auto load_status = rom.LoadFromData(data); EXPECT_TRUE(load_status.ok()); auto decompression_status = DecompressV2(rom.data(), 0, in_size); EXPECT_TRUE(decompression_status.ok()); diff --git a/src/test/rom_test.cc b/src/test/rom_test.cc index 4dc4da0a..237f69ab 100644 --- a/src/test/rom_test.cc +++ b/src/test/rom_test.cc @@ -64,7 +64,7 @@ TEST_F(RomTest, LoadFromFileEmpty) { } TEST_F(RomTest, ReadByteOk) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); 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_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); 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_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); for (size_t i = 0; i < kMockRomData.size(); i += 4) { // Little endian @@ -112,7 +112,7 @@ TEST_F(RomTest, ReadLongInvalid) { } TEST_F(RomTest, ReadBytesOk) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); std::vector bytes; ASSERT_OK_AND_ASSIGN(bytes, rom_.ReadByteVector(0, kMockRomData.size())); @@ -125,7 +125,7 @@ TEST_F(RomTest, ReadBytesInvalid) { } TEST_F(RomTest, ReadBytesOutOfRange) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); std::vector bytes; EXPECT_THAT(rom_.ReadByteVector(kMockRomData.size() + 1, 1).status(), @@ -133,7 +133,7 @@ TEST_F(RomTest, ReadBytesOutOfRange) { } TEST_F(RomTest, WriteByteOk) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); for (size_t i = 0; i < kMockRomData.size(); ++i) { EXPECT_OK(rom_.WriteByte(i, 0xFF)); @@ -147,13 +147,13 @@ TEST_F(RomTest, WriteByteInvalid) { EXPECT_THAT(rom_.WriteByte(0, 0xFF), StatusIs(absl::StatusCode::kFailedPrecondition)); - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); EXPECT_THAT(rom_.WriteByte(kMockRomData.size(), 0xFF), StatusIs(absl::StatusCode::kOutOfRange)); } TEST_F(RomTest, WriteWordOk) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); for (size_t i = 0; i < kMockRomData.size(); i += 2) { EXPECT_OK(rom_.WriteWord(i, 0xFFFF)); @@ -167,13 +167,13 @@ TEST_F(RomTest, WriteWordInvalid) { EXPECT_THAT(rom_.WriteWord(0, 0xFFFF), StatusIs(absl::StatusCode::kFailedPrecondition)); - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); EXPECT_THAT(rom_.WriteWord(kMockRomData.size(), 0xFFFF), StatusIs(absl::StatusCode::kOutOfRange)); } TEST_F(RomTest, WriteLongOk) { - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + EXPECT_OK(rom_.LoadFromData(kMockRomData)); for (size_t i = 0; i < kMockRomData.size(); i += 4) { EXPECT_OK(rom_.WriteLong(i, 0xFFFFFF)); @@ -187,14 +187,14 @@ TEST_F(RomTest, WriteLongInvalid) { EXPECT_THAT(rom_.WriteLong(0, 0xFFFFFF), StatusIs(absl::StatusCode::kFailedPrecondition)); - EXPECT_OK(rom_.LoadFromBytes(kMockRomData)); + 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.LoadFromBytes(kMockRomData)); + EXPECT_OK(mock_rom.LoadFromData(kMockRomData)); EXPECT_CALL(mock_rom, WriteHelper(_)) .WillRepeatedly(Return(absl::OkStatus())); @@ -207,7 +207,7 @@ TEST_F(RomTest, WriteTransactionSuccess) { TEST_F(RomTest, WriteTransactionFailure) { MockRom mock_rom; - EXPECT_OK(mock_rom.LoadFromBytes(kMockRomData)); + EXPECT_OK(mock_rom.LoadFromData(kMockRomData)); EXPECT_CALL(mock_rom, WriteHelper(_)) .WillOnce(Return(absl::OkStatus())) @@ -221,7 +221,7 @@ TEST_F(RomTest, WriteTransactionFailure) { TEST_F(RomTest, ReadTransactionSuccess) { MockRom mock_rom; - EXPECT_OK(mock_rom.LoadFromBytes(kMockRomData)); + EXPECT_OK(mock_rom.LoadFromData(kMockRomData)); uint8_t byte_val; uint16_t word_val; @@ -233,7 +233,7 @@ TEST_F(RomTest, ReadTransactionSuccess) { TEST_F(RomTest, ReadTransactionFailure) { MockRom mock_rom; - EXPECT_OK(mock_rom.LoadFromBytes(kMockRomData)); + EXPECT_OK(mock_rom.LoadFromData(kMockRomData)); uint8_t byte_val; EXPECT_EQ(mock_rom.ReadTransaction(byte_val, 0x1000),