From 567c3a2ee7162e0e62d5ecd511e6d137a6b217c2 Mon Sep 17 00:00:00 2001 From: MerryMage Date: Mon, 1 May 2017 20:55:45 +0100 Subject: [PATCH] tests: Arm testing framework --- src/tests/CMakeLists.txt | 2 + src/tests/core/arm/arm_test_common.cpp | 123 +++++++++++++++++++++++++ src/tests/core/arm/arm_test_common.h | 83 +++++++++++++++++ 3 files changed, 208 insertions(+) create mode 100644 src/tests/core/arm/arm_test_common.cpp create mode 100644 src/tests/core/arm/arm_test_common.h diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index a14df325a8..5882960bc4 100644 --- a/src/tests/CMakeLists.txt +++ b/src/tests/CMakeLists.txt @@ -1,5 +1,6 @@ set(SRCS common/param_package.cpp + core/arm/arm_test_common.cpp core/file_sys/path_parser.cpp core/hle/kernel/hle_ipc.cpp glad.cpp @@ -7,6 +8,7 @@ set(SRCS ) set(HEADERS + core/arm/arm_test_common.h ) create_directory_groups(${SRCS} ${HEADERS}) diff --git a/src/tests/core/arm/arm_test_common.cpp b/src/tests/core/arm/arm_test_common.cpp new file mode 100644 index 0000000000..1d41e3376c --- /dev/null +++ b/src/tests/core/arm/arm_test_common.cpp @@ -0,0 +1,123 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/core.h" +#include "core/memory_setup.h" +#include "tests/core/arm/arm_test_common.h" + +namespace ArmTests { + +TestEnvironment::TestEnvironment(bool mutable_memory_) + : mutable_memory(mutable_memory_), test_memory(std::make_shared(this)) { + Memory::MapIoRegion(0x00000000, 0x80000000, test_memory); + Memory::MapIoRegion(0x80000000, 0x80000000, test_memory); +} + +TestEnvironment::~TestEnvironment() { + Memory::UnmapRegion(0x80000000, 0x80000000); + Memory::UnmapRegion(0x00000000, 0x80000000); +} + +void TestEnvironment::SetMemory64(VAddr vaddr, u64 value) { + SetMemory32(vaddr + 0, static_cast(value)); + SetMemory32(vaddr + 4, static_cast(value >> 32)); +} + +void TestEnvironment::SetMemory32(VAddr vaddr, u32 value) { + SetMemory16(vaddr + 0, static_cast(value)); + SetMemory16(vaddr + 2, static_cast(value >> 16)); +} + +void TestEnvironment::SetMemory16(VAddr vaddr, u16 value) { + SetMemory8(vaddr + 0, static_cast(value)); + SetMemory8(vaddr + 1, static_cast(value >> 8)); +} + +void TestEnvironment::SetMemory8(VAddr vaddr, u8 value) { + test_memory->data[vaddr] = value; +} + +std::vector TestEnvironment::GetWriteRecords() const { + return write_records; +} + +void TestEnvironment::ClearWriteRecords() { + write_records.clear(); +} + +TestEnvironment::TestMemory::~TestMemory() {} + +bool TestEnvironment::TestMemory::IsValidAddress(VAddr addr) { + return true; +} + +u8 TestEnvironment::TestMemory::Read8(VAddr addr) { + auto iter = data.find(addr); + if (iter == data.end()) { + return addr; // Some arbitrary data + } + return iter->second; +} + +u16 TestEnvironment::TestMemory::Read16(VAddr addr) { + return Read8(addr) | static_cast(Read8(addr + 1)) << 8; +} + +u32 TestEnvironment::TestMemory::Read32(VAddr addr) { + return Read16(addr) | static_cast(Read16(addr + 2)) << 16; +} + +u64 TestEnvironment::TestMemory::Read64(VAddr addr) { + return Read32(addr) | static_cast(Read32(addr + 4)) << 32; +} + +bool TestEnvironment::TestMemory::ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) { + VAddr addr = src_addr; + u8* data = static_cast(dest_buffer); + + for (size_t i = 0; i < size; i++, addr++, data++) { + *data = Read8(addr); + } + + return true; +} + +void TestEnvironment::TestMemory::Write8(VAddr addr, u8 data) { + env->write_records.emplace_back(8, addr, data); + if (env->mutable_memory) + env->SetMemory8(addr, data); +} + +void TestEnvironment::TestMemory::Write16(VAddr addr, u16 data) { + env->write_records.emplace_back(16, addr, data); + if (env->mutable_memory) + env->SetMemory16(addr, data); +} + +void TestEnvironment::TestMemory::Write32(VAddr addr, u32 data) { + env->write_records.emplace_back(32, addr, data); + if (env->mutable_memory) + env->SetMemory32(addr, data); +} + +void TestEnvironment::TestMemory::Write64(VAddr addr, u64 data) { + env->write_records.emplace_back(64, addr, data); + if (env->mutable_memory) + env->SetMemory64(addr, data); +} + +bool TestEnvironment::TestMemory::WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) { + VAddr addr = dest_addr; + const u8* data = static_cast(src_buffer); + + for (size_t i = 0; i < size; i++, addr++, data++) { + env->write_records.emplace_back(8, addr, *data); + if (env->mutable_memory) + env->SetMemory8(addr, *data); + } + + return true; +} + +} // namespace ArmTests diff --git a/src/tests/core/arm/arm_test_common.h b/src/tests/core/arm/arm_test_common.h new file mode 100644 index 0000000000..af747f8c98 --- /dev/null +++ b/src/tests/core/arm/arm_test_common.h @@ -0,0 +1,83 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include +#include +#include + +#include "common/common_types.h" +#include "core/mmio.h" + +namespace ArmTests { + +struct WriteRecord { + WriteRecord(size_t size, VAddr addr, u64 data) : size(size), addr(addr), data(data) {} + size_t size; + VAddr addr; + u64 data; + bool operator==(const WriteRecord& o) const { + return std::tie(size, addr, data) == std::tie(o.size, o.addr, o.data); + } +}; + +class TestEnvironment final { +public: + /* + * Inititalise test environment + * @param mutable_memory If false, writes to memory can never be read back. (Memory is immutable.) + */ + explicit TestEnvironment(bool mutable_memory = false); + + /// Shutdown test environment + ~TestEnvironment(); + + /// Sets value at memory location vaddr. + void SetMemory8(VAddr vaddr, u8 value); + void SetMemory16(VAddr vaddr, u16 value); + void SetMemory32(VAddr vaddr, u32 value); + void SetMemory64(VAddr vaddr, u64 value); + + /** + * Whenever Memory::Write{8,16,32,64} is called within the test environment, + * a new write-record is made. + * @returns A vector of write records made since they were last cleared. + */ + std::vector GetWriteRecords() const; + + /// Empties the internal write-record store. + void ClearWriteRecords(); + +private: + friend struct TestMemory; + struct TestMemory final : Memory::MMIORegion { + explicit TestMemory(TestEnvironment* env_) : env(env_) {} + TestEnvironment* env; + + ~TestMemory() override; + + bool IsValidAddress(VAddr addr) override; + + u8 Read8(VAddr addr) override; + u16 Read16(VAddr addr) override; + u32 Read32(VAddr addr) override; + u64 Read64(VAddr addr) override; + + bool ReadBlock(VAddr src_addr, void* dest_buffer, size_t size) override; + + void Write8(VAddr addr, u8 data) override; + void Write16(VAddr addr, u16 data) override; + void Write32(VAddr addr, u32 data) override; + void Write64(VAddr addr, u64 data) override; + + bool WriteBlock(VAddr dest_addr, const void* src_buffer, size_t size) override; + + std::unordered_map data; + }; + + bool mutable_memory; + std::shared_ptr test_memory; + std::vector write_records; +}; + +} // namespace ArmTests