Add unit and integration test suite

.github/workflows/tests.yml

@@ -0,0 +1,35 @@
+name: Tests
+
+on:
+  push:
+    branches: [ "*" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        run: sudo apt-get install cmake ninja-build libbz2-dev lcov
+      - name: Configure
+        run: cmake -H. -Bbuild -GNinja -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTS=ON -DBUILD_INTEGRATION_TESTS=ON -DENABLE_COVERAGE=ON
+      - name: Build
+        run: cmake --build build -j
+      - name: Unit Tests
+        run: build/torch_tests
+      - name: Integration Tests
+        # Integration tests require ROM files not present in CI.
+        # Tests will self-skip via GTEST_SKIP when ROMs are not found.
+        run: build/torch_integration_tests
+      - name: Collect Coverage
+        run: |
+          lcov --capture --directory build --output-file coverage.info --ignore-errors mismatch,inconsistent
+          lcov --remove coverage.info '/usr/*' '*/lib/*' '*/build/_deps/*' '*/tests/*' --output-file coverage.info --ignore-errors unused
+          genhtml coverage.info --output-directory coverage-report --ignore-errors inconsistent
+      - name: Upload Coverage Report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage-report/

.gitignore

@@ -17,6 +17,10 @@ tools/
 modding/*
 .cache
 
+# Coverage
+coverage-report/
+*.info
+
 # Doxygen output
 docs/html
 docs/latex

CMakeLists.txt

@@ -120,6 +120,12 @@ if(ENABLE_ASAN)
     add_link_options(-fsanitize=address)
 endif()
 
+option(ENABLE_COVERAGE "Enable code coverage instrumentation" OFF)
+if(ENABLE_COVERAGE)
+    add_compile_options(--coverage -fno-inline)
+    add_link_options(--coverage)
+endif()
+
 # Build
 if (USE_STANDALONE)
     add_definitions(-DSTANDALONE)
@@ -288,3 +294,52 @@ if(NOT USE_STANDALONE)
     target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src)
     target_include_directories(${PROJECT_NAME} PUBLIC ${yaml-cpp_SOURCE_DIR}/include)
 endif()
+
+# Unit Tests
+option(BUILD_TESTS "Build unit tests" OFF)
+if(BUILD_TESTS)
+    set(BUILD_GMOCK OFF CACHE BOOL "" FORCE)
+    set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
+    FetchContent_Declare(
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG v1.15.2
+    )
+    FetchContent_MakeAvailable(googletest)
+
+    enable_testing()
+
+    file(GLOB TEST_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tests/*.cpp)
+
+    set(TEST_SRC_DIR ${SRC_DIR})
+    list(FILTER TEST_SRC_DIR EXCLUDE REGEX "main\\.cpp$")
+
+    add_executable(torch_tests ${TEST_FILES} ${TEST_SRC_DIR})
+    target_include_directories(torch_tests PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_CURRENT_SOURCE_DIR}/lib
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
+    target_link_libraries(torch_tests PRIVATE gtest_main yaml-cpp tinyxml2 N64Graphics BinaryTools spdlog)
+    add_test(NAME torch_tests COMMAND torch_tests)
+
+    # Integration Tests
+    option(BUILD_INTEGRATION_TESTS "Build integration tests (require ROM files)" OFF)
+    if(BUILD_INTEGRATION_TESTS)
+        file(GLOB INTEGRATION_TEST_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tests/integration/*.cpp)
+
+        add_executable(torch_integration_tests ${INTEGRATION_TEST_FILES} ${TEST_SRC_DIR})
+        target_include_directories(torch_integration_tests PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+            ${CMAKE_CURRENT_SOURCE_DIR}/lib
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/tests/integration
+        )
+        target_compile_definitions(torch_integration_tests PRIVATE
+            INTEGRATION_TEST_DIR="${CMAKE_CURRENT_SOURCE_DIR}/tests/integration"
+            INTEGRATION_ROM_DIR="${CMAKE_CURRENT_SOURCE_DIR}/tests/roms"
+        )
+        target_link_libraries(torch_integration_tests PRIVATE gtest_main yaml-cpp tinyxml2 N64Graphics BinaryTools spdlog)
+        add_test(NAME torch_integration_tests COMMAND torch_integration_tests)
+    endif()
+endif()

src/factories/sm64/AnimationFactory.cpp

@@ -3,8 +3,6 @@
 
 #include "utils/Decompressor.h"
 
-#define ANIMINDEX_COUNT(boneCount) (((boneCount) + 1) * 6)
-
 ExportResult SM64::AnimationBinaryExporter::Export(std::ostream& write, std::shared_ptr<IParsedData> raw,
                                                    std::string& entryName, YAML::Node& node, std::string* replacement) {
     auto writer = LUS::BinaryWriter();

src/factories/sm64/AnimationFactory.h

@@ -2,6 +2,8 @@
 
 #include <factories/BaseFactory.h>
 
+#define ANIMINDEX_COUNT(boneCount) (((boneCount) + 1) * 6)
+
 namespace SM64 {
 class AnimationData : public IParsedData {
 public:

tests/BinaryReaderTest.cpp

@@ -0,0 +1,149 @@
+#include <gtest/gtest.h>
+#include "lib/binarytools/BinaryReader.h"
+#include "lib/binarytools/endianness.h"
+#include "lib/binarytools/Stream.h"
+#include <vector>
+#include <cstring>
+
+// Helper to create a BinaryReader from a vector of bytes
+static LUS::BinaryReader MakeReader(std::vector<uint8_t>& buf, Torch::Endianness endianness = Torch::Endianness::Big) {
+    LUS::BinaryReader reader(buf.data(), buf.size());
+    reader.SetEndianness(endianness);
+    return reader;
+}
+
+TEST(BinaryReaderTest, ReadInt8) {
+    std::vector<uint8_t> buf = {0x7F};
+    auto reader = MakeReader(buf);
+    EXPECT_EQ(reader.ReadInt8(), 0x7F);
+}
+
+TEST(BinaryReaderTest, ReadInt8Negative) {
+    std::vector<uint8_t> buf = {0x80};
+    auto reader = MakeReader(buf);
+    EXPECT_EQ(reader.ReadInt8(), -128);
+}
+
+TEST(BinaryReaderTest, ReadUByte) {
+    std::vector<uint8_t> buf = {0xFF};
+    auto reader = MakeReader(buf);
+    EXPECT_EQ(reader.ReadUByte(), 0xFF);
+}
+
+TEST(BinaryReaderTest, ReadInt16BigEndian) {
+    std::vector<uint8_t> buf = {0x01, 0x00};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadInt16(), 256);
+}
+
+TEST(BinaryReaderTest, ReadUInt16BigEndian) {
+    std::vector<uint8_t> buf = {0xFF, 0xFE};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadUInt16(), 0xFFFE);
+}
+
+TEST(BinaryReaderTest, ReadInt32BigEndian) {
+    std::vector<uint8_t> buf = {0x00, 0x01, 0x00, 0x00};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadInt32(), 0x00010000);
+}
+
+TEST(BinaryReaderTest, ReadUInt32BigEndian) {
+    std::vector<uint8_t> buf = {0xDE, 0xAD, 0xBE, 0xEF};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadUInt32(), 0xDEADBEEF);
+}
+
+TEST(BinaryReaderTest, ReadUInt64BigEndian) {
+    std::vector<uint8_t> buf = {0x00, 0x00, 0x00, 0x00, 0xDE, 0xAD, 0xBE, 0xEF};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadUInt64(), 0x00000000DEADBEEF);
+}
+
+TEST(BinaryReaderTest, ReadFloat) {
+    // IEEE 754: 1.0f = 0x3F800000
+    std::vector<uint8_t> buf = {0x3F, 0x80, 0x00, 0x00};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_FLOAT_EQ(reader.ReadFloat(), 1.0f);
+}
+
+TEST(BinaryReaderTest, GetLength) {
+    std::vector<uint8_t> buf = {0x01, 0x02, 0x03, 0x04};
+    auto reader = MakeReader(buf);
+    EXPECT_EQ(reader.GetLength(), 4u);
+}
+
+TEST(BinaryReaderTest, ReadCString) {
+    // "Hi" + null terminator
+    std::vector<uint8_t> buf = {'H', 'i', '\0'};
+    auto reader = MakeReader(buf);
+    std::string result = reader.ReadCString();
+    // ReadCString includes the null terminator in the string
+    EXPECT_EQ(result.size(), 3u);
+    EXPECT_EQ(result[0], 'H');
+    EXPECT_EQ(result[1], 'i');
+    EXPECT_EQ(result[2], '\0');
+}
+
+TEST(BinaryReaderTest, ReadString) {
+    // ReadString reads a big-endian int32 length prefix, then that many chars
+    // Length = 3, then "abc"
+    std::vector<uint8_t> buf = {0x00, 0x00, 0x00, 0x03, 'a', 'b', 'c'};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadString(), "abc");
+}
+
+TEST(BinaryReaderTest, SeekFromStart) {
+    std::vector<uint8_t> buf = {0xAA, 0xBB, 0xCC, 0xDD};
+    auto reader = MakeReader(buf);
+    reader.Seek(2, LUS::SeekOffsetType::Start);
+    EXPECT_EQ(reader.ReadUByte(), 0xCC);
+}
+
+TEST(BinaryReaderTest, SeekFromCurrent) {
+    std::vector<uint8_t> buf = {0xAA, 0xBB, 0xCC, 0xDD};
+    auto reader = MakeReader(buf);
+    reader.ReadUByte(); // now at offset 1
+    reader.Seek(1, LUS::SeekOffsetType::Current); // skip to offset 2
+    EXPECT_EQ(reader.ReadUByte(), 0xCC);
+}
+
+TEST(BinaryReaderTest, GetBaseAddress) {
+    std::vector<uint8_t> buf = {0xAA, 0xBB, 0xCC, 0xDD};
+    auto reader = MakeReader(buf);
+    EXPECT_EQ(reader.GetBaseAddress(), 0u);
+    reader.ReadUByte();
+    EXPECT_EQ(reader.GetBaseAddress(), 1u);
+    reader.ReadUByte();
+    EXPECT_EQ(reader.GetBaseAddress(), 2u);
+}
+
+TEST(BinaryReaderTest, EndiannessSwitching) {
+    // 0x0102 as bytes
+    std::vector<uint8_t> buf = {0x01, 0x02};
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadUInt16(), 0x0102);
+
+    // Reset and read as little-endian
+    reader.Seek(0, LUS::SeekOffsetType::Start);
+    reader.SetEndianness(Torch::Endianness::Native);
+    uint16_t native = reader.ReadUInt16();
+    // On little-endian (x86), native should read 0x0201
+    // On big-endian, native should read 0x0102
+    // Either way, it should differ from Big on little-endian platforms
+    EXPECT_EQ(reader.GetEndianness(), Torch::Endianness::Native);
+    (void)native; // value is platform-dependent
+}
+
+TEST(BinaryReaderTest, ReadMultipleValues) {
+    // Read a sequence: uint8, uint16, uint32
+    std::vector<uint8_t> buf = {
+        0xFF,                   // uint8
+        0x00, 0x0A,             // uint16 = 10
+        0x00, 0x00, 0x01, 0x00  // uint32 = 256
+    };
+    auto reader = MakeReader(buf, Torch::Endianness::Big);
+    EXPECT_EQ(reader.ReadUByte(), 0xFF);
+    EXPECT_EQ(reader.ReadUInt16(), 10);
+    EXPECT_EQ(reader.ReadUInt32(), 256);
+}