LibHac/tests/LibHac.Tests/FsSrv/ProgramIndexMapInfoTests.cs

using System;
using LibHac.Common;
using LibHac.Fs;
using LibHac.Fs.Shim;
using LibHac.FsSrv;
using LibHac.FsSrv.Impl;
using LibHac.Ncm;
using LibHac.Util;
using Xunit;

namespace LibHac.Tests.FsSrv
{
    public class ProgramIndexMapInfoTests
    {
        [Fact]
        public void GetProgramIndexForAccessLog_IsMultiProgram_ReturnsCorrectIndex()
        {
            const int count = 7;

            Horizon hos = HorizonFactory.CreateBasicHorizon();

            var programs = new HorizonClient[count];

            programs[0] = hos.CreateHorizonClient(new ProgramLocation(new ProgramId(1), StorageId.BuiltInSystem),
                AccessControlBits.Bits.RegisterProgramIndexMapInfo);

            for (int i = 1; i < programs.Length; i++)
            {
                programs[i] =
                    hos.CreateHorizonClient(new ProgramLocation(new ProgramId((ulong)(i + 1)), StorageId.BuiltInSystem),
                        AccessControlBits.Bits.None);
            }

            var map = new ProgramIndexMapInfo[count];

            for (int i = 0; i < map.Length; i++)
            {
                map[i].MainProgramId = new ProgramId(1);
                map[i].ProgramId = new ProgramId((ulong)(i + 1));
                map[i].ProgramIndex = (byte)i;
            }

            Assert.Success(programs[0].Fs.RegisterProgramIndexMapInfo(map));

            for (int i = 0; i < programs.Length; i++)
            {
                using SharedRef<LibHac.FsSrv.Sf.IFileSystemProxy> fsProxy =
                    programs[i].Fs.Impl.GetFileSystemProxyServiceObject();
                Assert.Success(fsProxy.Get.GetProgramIndexForAccessLog(out int programIndex, out int programCount));

                Assert.Equal(i, programIndex);
                Assert.Equal(count, programCount);
            }
        }

        private ProgramIndexMapInfoManager CreatePopulatedManager(int count, Func<int, long> idCreator)
        {
            var manager = new ProgramIndexMapInfoManager();

            var map = new ProgramIndexMapInfo[count];

            for (int i = 0; i < map.Length; i++)
            {
                map[i].MainProgramId = new ProgramId((ulong)idCreator(0));
                map[i].ProgramId = new ProgramId((ulong)idCreator(i));
                map[i].ProgramIndex = (byte)i;
            }

            Assert.Success(manager.Reset(map));

            return manager;
        }

        [Fact]
        public void Get_IdDoesNotExist_ReturnsNull()
        {
            const int count = 5;

            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 3);

            Assert.False(manager.Get(new ProgramId(0)).HasValue);
            Assert.False(manager.Get(new ProgramId(2)).HasValue);
            Assert.False(manager.Get(new ProgramId(8)).HasValue);
            Assert.False(manager.Get(new ProgramId(9001)).HasValue);
        }

        [Fact]
        public void Get_IdExists_ReturnsCorrectMapInfo()
        {
            const int count = 5;

            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 1);

            // ReSharper disable PossibleInvalidOperationException
            Optional<ProgramIndexMapInfo> map = manager.Get(new ProgramId(1));
            Assert.True(map.HasValue);
            Assert.Equal(new ProgramId(1), map.Value.MainProgramId);
            Assert.Equal(new ProgramId(1), map.Value.ProgramId);
            Assert.Equal(0, map.Value.ProgramIndex);

            map = manager.Get(new ProgramId(4));
            Assert.True(map.HasValue);
            Assert.Equal(new ProgramId(1), map.Value.MainProgramId);
            Assert.Equal(new ProgramId(4), map.Value.ProgramId);
            Assert.Equal(3, map.Value.ProgramIndex);
            // ReSharper restore PossibleInvalidOperationException
        }

        [Fact]
        public void GetProgramId_WithIndex_ReturnsProgramIdOfSpecifiedIndex()
        {
            const int count = 5;

            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => (x + 1) * 5);

            // Check that the program ID can be retrieved using any program in the set
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(5), 3));
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(10), 3));
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(15), 3));
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(20), 3));
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(25), 3));

            // Check that any index can be used
            Assert.Equal(new ProgramId(5), manager.GetProgramId(new ProgramId(10), 0));
            Assert.Equal(new ProgramId(10), manager.GetProgramId(new ProgramId(10), 1));
            Assert.Equal(new ProgramId(15), manager.GetProgramId(new ProgramId(10), 2));
            Assert.Equal(new ProgramId(20), manager.GetProgramId(new ProgramId(10), 3));
            Assert.Equal(new ProgramId(25), manager.GetProgramId(new ProgramId(10), 4));
        }

        [Fact]
        public void GetProgramId_InputIdDoesNotExist_ReturnsInvalidId()
        {
            const int count = 5;

            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 1);

            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(0), 3));
            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(666), 3));
            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(777), 3));
        }

        [Fact]
        public void GetProgramId_InputIndexDoesNotExist_ReturnsInvalidId()
        {
            const int count = 5;

            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 1);

            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(2), 5));
            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(2), 12));
            Assert.Equal(ProgramId.InvalidId, manager.GetProgramId(new ProgramId(2), 255));
        }

        [Fact]
        public void GetProgramCount_MapIsEmpty_ReturnsZero()
        {
            var manager = new ProgramIndexMapInfoManager();

            Assert.Equal(0, manager.GetProgramCount());
        }

        [Fact]
        public void GetProgramCount_MapHasEntries_ReturnsCorrectCount()
        {
            ProgramIndexMapInfoManager manager = CreatePopulatedManager(1, x => x + 1);
            Assert.Equal(1, manager.GetProgramCount());

            manager = CreatePopulatedManager(10, x => x + 1);
            Assert.Equal(10, manager.GetProgramCount());

            manager = CreatePopulatedManager(255, x => x + 1);
            Assert.Equal(255, manager.GetProgramCount());
        }

        [Fact]
        public void Clear_MapHasEntries_CountIsZero()
        {
            const int count = 5;
            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 1);

            manager.Clear();

            Assert.Equal(0, manager.GetProgramCount());
        }

        [Fact]
        public void Clear_MapHasEntries_CannotGetOldEntry()
        {
            const int count = 5;
            ProgramIndexMapInfoManager manager = CreatePopulatedManager(count, x => x + 1);

            manager.Clear();

            Assert.False(manager.Get(new ProgramId(2)).HasValue);
        }
    }
}