scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor ROM loading methods

Browse Source
This commit is contained in:
scawful
2025-01-18 12:33:33 -05:00
parent 3fc52cce62
commit 339df53674
8 changed files with 183 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/app/editor/graphics/graphics_editor.cc
View File

@@ -702,7 +702,7 @@ absl::Status GraphicsEditor::DrawClipboardImport() {
const auto clipboard_data =
std::vector<uint8_t>(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;
}

4
src/app/gfx/compression.cc
View File

@@ -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()))

151
src/app/rom.cc
View File

@@ -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<uint8_t> &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<uint8_t> &data) {
if (data.empty()) {
return absl::InvalidArgumentError(
"Could not load ROM: parameter `data` is empty.");
absl::StatusOr<uint8_t> Rom::ReadByte(int offset) {
if (offset >= static_cast<int>(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<uint16_t> Rom::ReadWord(int offset) {
if (offset + 1 >= static_cast<int>(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<uint32_t> Rom::ReadLong(int offset) {
if (offset + 2 >= static_cast<int>(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<std::vector<uint8_t>> Rom::ReadByteVector(
uint32_t offset, uint32_t length) const {
if (offset + length > static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError("Offset and length out of range");
}
std::vector<uint8_t> result;
for (uint32_t i = offset; i < offset + length; i++) {
result.push_back(rom_data_[i]);
}
return result;
}
absl::StatusOr<gfx::Tile16> 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<int>(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<int>(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<int>(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<uint32_t>(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<uint8_t> data) {
if (addr + static_cast<int>(data.size()) >
static_cast<int>(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<int>(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

189
src/app/rom.h
View File

@@ -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<uint8_t>& data);
absl::Status LoadFromData(const std::vector<uint8_t>& 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<uint8_t> ReadByte(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset >= static_cast<int>(rom_data_.size())) {
return absl::FailedPreconditionError("Offset out of range");
}
return rom_data_[offset];
}
absl::StatusOr<uint16_t> ReadWord(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + 1 >= static_cast<int>(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<uint32_t> ReadLong(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + 2 >= static_cast<int>(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<uint8_t> ReadByte(int offset);
absl::StatusOr<uint16_t> ReadWord(int offset);
absl::StatusOr<uint32_t> ReadLong(int offset);
absl::StatusOr<std::vector<uint8_t>> ReadByteVector(uint32_t offset,
uint32_t length) const {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + length > static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError("Offset and length out of range");
}
std::vector<uint8_t> result;
for (uint32_t i = offset; i < offset + length; i++) {
result.push_back(rom_data_[i]);
}
return result;
}
uint32_t length) const;
absl::StatusOr<gfx::Tile16> ReadTile16(uint32_t tile16_id);
absl::StatusOr<gfx::Tile16> 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<int>(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<int>(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<int>(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<uint32_t>(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<uint8_t> data) {
if (addr + static_cast<int>(data.size()) >
static_cast<int>(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<int>(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<uint8_t> data);
absl::Status WriteColor(uint32_t address, const gfx::SnesColor& color);
template <typename... Args>
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>(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];
}

3
src/cli/handlers/tile16_transfer.cc
View File

@@ -2,7 +2,6 @@
#include <vector>
#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<std::string>& arg_vec) {
}
} // namespace cli
} // namespace yaze
} // namespace yaze

6
src/ios/main.mm
View File

@@ -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<uint8_t> 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];

8
src/test/gfx/compression_test.cc
View File

@@ -33,7 +33,8 @@ using ::testing::TypedEq;
namespace {
std::vector<uint8_t> ExpectCompressOk(Rom& rom, uchar* in, int in_size) {
auto load_status = rom.LoadFromPointer(in, in_size, false);
std::vector<uint8_t> 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<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.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<uint8_t> ExpectDecompressBytesOk(Rom& rom,
}
std::vector<uint8_t> ExpectDecompressOk(Rom& rom, uchar* in, int in_size) {
auto load_status = rom.LoadFromPointer(in, in_size, false);
std::vector<uint8_t> 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());

30
src/test/rom_test.cc
View File

@@ -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<uint8_t> 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<uint8_t> 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),