LibHac/tests/LibHac.Tests/RomFsTests.cs

using System;
using LibHac.FsSystem.RomFs;
using Xunit;

namespace LibHac.Tests
{
    public class RomFsTests
    {
        [Fact]
        public void SimpleAddAndRead()
        {
            const string path = "/a/b";

            var table = new HierarchicalRomFileTable<RomFileInfo>();
            var item = new RomFileInfo { Length = 1, Offset = 1 };

            table.AddFile(path, ref item);
            bool success = table.TryOpenFile(path, out RomFileInfo readItem);

            Assert.True(success, "Table read failed");
            Assert.Equal(item, readItem);
        }

        [Fact]
        public void UpdateExistingFile()
        {
            const string path = "/a/b";

            var table = new HierarchicalRomFileTable<RomFileInfo>();
            var originalItem = new RomFileInfo { Length = 1, Offset = 1 };
            var newItem = new RomFileInfo { Length = 1, Offset = 1 };

            table.AddFile(path, ref originalItem);
            table.AddFile(path, ref newItem);

            bool success = table.TryOpenFile(path, out RomFileInfo readItem);

            Assert.True(success, "Table read failed");
            Assert.Equal(newItem, readItem);
        }

        [Fact]
        public void AddingDirectory()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();
            var expectedPosition = new FindPosition { NextDirectory = -1, NextFile = -1 };

            table.AddDirectory("/dir");
            bool success = table.TryOpenDirectory("/dir", out FindPosition position);

            Assert.True(success, "Opening directory failed");
            Assert.Equal(expectedPosition, position);
        }

        [Fact]
        public void AddingEmptyPathThrows()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();
            var item = new RomFileInfo();

            Assert.Throws<ArgumentException>(() => table.AddFile("", ref item));
        }

        [Fact]
        public void OpeningNonexistentFileFails()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            bool success = table.TryOpenFile("/foo", out _);
            Assert.False(success);
        }

        [Fact]
        public void OpeningNonexistentDirectoryFails()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            bool success = table.TryOpenDirectory("/foo", out _);
            Assert.False(success);
        }

        [Fact]
        public void OpeningFileAsDirectoryFails()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();
            var fileInfo = new RomFileInfo();
            table.AddFile("/file", ref fileInfo);

            bool success = table.TryOpenDirectory("/file", out _);
            Assert.False(success);
        }

        [Fact]
        public void OpeningDirectoryAsFileFails()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();
            table.AddDirectory("/dir");

            bool success = table.TryOpenFile("/dir", out _);
            Assert.False(success);
        }

        [Fact]
        public void ChildFileIteration()
        {
            const int fileCount = 10;
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            for (int i = 0; i < fileCount; i++)
            {
                var item = new RomFileInfo { Length = i, Offset = i };
                table.AddFile($"/a/{i}", ref item);
            }

            bool openDirSuccess = table.TryOpenDirectory("/a", out FindPosition position);
            Assert.True(openDirSuccess, "Error opening directory");

            for (int i = 0; i < fileCount; i++)
            {
                var expectedItem = new RomFileInfo { Length = i, Offset = i };
                string expectedName = i.ToString();

                bool success = table.FindNextFile(ref position, out RomFileInfo actualItem, out string actualName);

                Assert.True(success, $"Failed reading file {i}");
                Assert.Equal(expectedItem, actualItem);
                Assert.Equal(expectedName, actualName);
            }

            bool endOfFilesSuccess = table.FindNextFile(ref position, out _, out _);
            Assert.False(endOfFilesSuccess, "Table returned more files than it should");
        }

        [Fact]
        public void ChildFileIterationPeek()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            var itemA = new RomFileInfo { Length = 1, Offset = 1 };
            var itemB = new RomFileInfo { Length = 2, Offset = 2 };

            table.AddFile("/a/a", ref itemA);
            table.AddFile("/a/b", ref itemB);

            table.TryOpenDirectory("/a", out FindPosition position);

            table.TryOpenFile(position.NextFile, out RomFileInfo peekItemA);
            Assert.Equal(itemA, peekItemA);

            table.FindNextFile(ref position, out RomFileInfo iterateItemA, out _);
            Assert.Equal(itemA, iterateItemA);

            table.TryOpenFile(position.NextFile, out RomFileInfo peekItemB);
            Assert.Equal(itemB, peekItemB);

            table.FindNextFile(ref position, out RomFileInfo iterateItemB, out _);
            Assert.Equal(itemB, iterateItemB);
        }

        [Fact]
        public void AddingCousinFiles()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            var itemB1 = new RomFileInfo { Length = 1, Offset = 1 };
            var itemB2 = new RomFileInfo { Length = 2, Offset = 2 };
            var itemB3 = new RomFileInfo { Length = 3, Offset = 3 };

            table.AddFile("/a/b1/c", ref itemB1);
            table.AddFile("/a/b2/c", ref itemB2);
            table.AddFile("/a/b3/c", ref itemB3);

            table.TryOpenFile("/a/b1/c", out RomFileInfo actualItemB1);
            table.TryOpenFile("/a/b2/c", out RomFileInfo actualItemB2);
            table.TryOpenFile("/a/b3/c", out RomFileInfo actualItemB3);

            Assert.Equal(itemB1, actualItemB1);
            Assert.Equal(itemB2, actualItemB2);
            Assert.Equal(itemB3, actualItemB3);
        }

        [Fact]
        public void AddingSiblingFiles()
        {
            var table = new HierarchicalRomFileTable<RomFileInfo>();

            var itemC1 = new RomFileInfo { Length = 1, Offset = 1 };
            var itemC2 = new RomFileInfo { Length = 2, Offset = 2 };
            var itemC3 = new RomFileInfo { Length = 3, Offset = 3 };

            table.AddFile("/a/b/c1", ref itemC1);
            table.AddFile("/a/b/c2", ref itemC2);
            table.AddFile("/a/b/c3", ref itemC3);

            table.TryOpenFile("/a/b/c1", out RomFileInfo actualItemC1);
            table.TryOpenFile("/a/b/c2", out RomFileInfo actualItemC2);
            table.TryOpenFile("/a/b/c3", out RomFileInfo actualItemC3);

            Assert.Equal(itemC1, actualItemC1);
            Assert.Equal(itemC2, actualItemC2);
            Assert.Equal(itemC3, actualItemC3);
        }
    }
}