From 77aef9166f4d4807de527842ed1c9c7414b931fe Mon Sep 17 00:00:00 2001 From: Alex Barney Date: Mon, 19 Jul 2021 13:16:11 -0700 Subject: [PATCH] Update tests to use the updated fsa interfaces --- src/LibHac/Fs/Fsa/IAttributeFileSystem.cs | 44 +-- .../Fs/DirectorySaveDataFileSystemTests.cs | 80 +++--- tests/LibHac.Tests/Fs/FsaExtensions.cs | 265 ++++++++++++++++++ .../CommittableIFileSystemTests.Commit.cs | 45 ++- .../IAttributeFileSystemTests.cs | 45 ++- ...leSystemTests.CleanDirectoryRecursively.cs | 17 +- .../IFileSystemTests.CreateDirectory.cs | 41 ++- .../IFileSystemTests.CreateFile.cs | 45 ++- .../IFileSystemTests.DeleteDirectory.cs | 41 ++- ...eSystemTests.DeleteDirectoryRecursively.cs | 17 +- .../IFileSystemTests.DeleteFile.cs | 35 ++- .../IFileSystemTests.IDirectory.cs | 16 +- .../IFileSystemTests.IFile.Read.cs | 31 +- .../IFileSystemTests.IFile.Size.cs | 9 +- .../IFileSystemTests.IFile.Write.cs | 37 ++- .../IFileSystemTests.OpenDirectory.cs | 7 +- .../IFileSystemTests.OpenFile.cs | 7 +- .../IFileSystemTests.RenameDirectory.cs | 53 ++-- .../IFileSystemTests.RenameFile.cs | 51 ++-- .../LibHac.Tests/Fs/LayeredFileSystemTests.cs | 68 ++--- .../Fs/SubdirectoryFileSystemTests.cs | 12 +- 21 files changed, 599 insertions(+), 367 deletions(-) create mode 100644 tests/LibHac.Tests/Fs/FsaExtensions.cs diff --git a/src/LibHac/Fs/Fsa/IAttributeFileSystem.cs b/src/LibHac/Fs/Fsa/IAttributeFileSystem.cs index 85f0bc39..95bb183c 100644 --- a/src/LibHac/Fs/Fsa/IAttributeFileSystem.cs +++ b/src/LibHac/Fs/Fsa/IAttributeFileSystem.cs @@ -1,49 +1,31 @@ -using LibHac.Common; - -namespace LibHac.Fs.Fsa +namespace LibHac.Fs.Fsa { // ReSharper disable once InconsistentNaming public abstract class IAttributeFileSystem : IFileSystem { - public Result CreateDirectory(U8Span path, NxFileAttributes archiveAttribute) + public Result CreateDirectory(in Path path, NxFileAttributes archiveAttribute) { - if (path.IsNull()) - return ResultFs.NullptrArgument.Log(); - - return DoCreateDirectory(path, archiveAttribute); + return DoCreateDirectory(in path, archiveAttribute); } - public Result GetFileAttributes(out NxFileAttributes attributes, U8Span path) + public Result GetFileAttributes(out NxFileAttributes attributes, in Path path) { - UnsafeHelpers.SkipParamInit(out attributes); - - if (path.IsNull()) - return ResultFs.NullptrArgument.Log(); - - return DoGetFileAttributes(out attributes, path); + return DoGetFileAttributes(out attributes, in path); } - public Result SetFileAttributes(U8Span path, NxFileAttributes attributes) + public Result SetFileAttributes(in Path path, NxFileAttributes attributes) { - if (path.IsNull()) - return ResultFs.NullptrArgument.Log(); - - return DoSetFileAttributes(path, attributes); + return DoSetFileAttributes(in path, attributes); } - public Result GetFileSize(out long fileSize, U8Span path) + public Result GetFileSize(out long fileSize, in Path path) { - UnsafeHelpers.SkipParamInit(out fileSize); - - if (path.IsNull()) - return ResultFs.NullptrArgument.Log(); - - return DoGetFileSize(out fileSize, path); + return DoGetFileSize(out fileSize, in path); } - protected abstract Result DoCreateDirectory(U8Span path, NxFileAttributes archiveAttribute); - protected abstract Result DoGetFileAttributes(out NxFileAttributes attributes, U8Span path); - protected abstract Result DoSetFileAttributes(U8Span path, NxFileAttributes attributes); - protected abstract Result DoGetFileSize(out long fileSize, U8Span path); + protected abstract Result DoCreateDirectory(in Path path, NxFileAttributes archiveAttribute); + protected abstract Result DoGetFileAttributes(out NxFileAttributes attributes, in Path path); + protected abstract Result DoSetFileAttributes(in Path path, NxFileAttributes attributes); + protected abstract Result DoGetFileSize(out long fileSize, in Path path); } } diff --git a/tests/LibHac.Tests/Fs/DirectorySaveDataFileSystemTests.cs b/tests/LibHac.Tests/Fs/DirectorySaveDataFileSystemTests.cs index ec460090..c9d525e1 100644 --- a/tests/LibHac.Tests/Fs/DirectorySaveDataFileSystemTests.cs +++ b/tests/LibHac.Tests/Fs/DirectorySaveDataFileSystemTests.cs @@ -57,9 +57,9 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem saveFs) = CreateFileSystemInternal(); - saveFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + saveFs.CreateFile("/file", 0, CreateFileOptions.None); - Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/1/file".ToU8Span())); + Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/1/file")); Assert.Equal(DirectoryEntryType.File, type); } @@ -68,9 +68,9 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem saveFs) = CreateFileSystemInternal(); - saveFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + saveFs.CreateFile("/file", 0, CreateFileOptions.None); - Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/0/file".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/0/file")); } [Fact] @@ -78,11 +78,11 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem saveFs) = CreateFileSystemInternal(); - saveFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + saveFs.CreateFile("/file", 0, CreateFileOptions.None); Assert.Success(saveFs.Commit()); - Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/0/file".ToU8Span())); + Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/0/file")); Assert.Equal(DirectoryEntryType.File, type); } @@ -91,15 +91,15 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem saveFs) = CreateFileSystemInternal(); - saveFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + saveFs.CreateFile("/file", 0, CreateFileOptions.None); // Rollback should succeed Assert.Success(saveFs.Rollback()); // Make sure all the files are gone - Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file".ToU8Span())); - Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/0/file".ToU8Span())); - Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/1/file".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file")); + Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/0/file")); + Assert.Result(ResultFs.PathNotFound, baseFs.GetEntryType(out _, "/1/file")); } [Fact] @@ -107,17 +107,17 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem saveFs) = CreateFileSystemInternal(); - saveFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + saveFs.CreateFile("/file", 0, CreateFileOptions.None); saveFs.Commit(); - saveFs.DeleteFile("/file".ToU8Span()); + saveFs.DeleteFile("/file"); // Rollback should succeed Assert.Success(saveFs.Rollback()); // Make sure all the files are restored - Assert.Success(saveFs.GetEntryType(out _, "/file".ToU8Span())); - Assert.Success(baseFs.GetEntryType(out _, "/0/file".ToU8Span())); - Assert.Success(baseFs.GetEntryType(out _, "/1/file".ToU8Span())); + Assert.Success(saveFs.GetEntryType(out _, "/file")); + Assert.Success(baseFs.GetEntryType(out _, "/0/file")); + Assert.Success(baseFs.GetEntryType(out _, "/1/file")); } [Fact] @@ -125,18 +125,18 @@ namespace LibHac.Tests.Fs { var baseFs = new InMemoryFileSystem(); - baseFs.CreateDirectory("/0".ToU8Span()).ThrowIfFailure(); - baseFs.CreateDirectory("/1".ToU8Span()).ThrowIfFailure(); + baseFs.CreateDirectory("/0").ThrowIfFailure(); + baseFs.CreateDirectory("/1").ThrowIfFailure(); // Set the existing files before initializing the save FS - baseFs.CreateFile("/0/file1".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); - baseFs.CreateFile("/1/file2".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + baseFs.CreateFile("/0/file1", 0, CreateFileOptions.None).ThrowIfFailure(); + baseFs.CreateFile("/1/file2", 0, CreateFileOptions.None).ThrowIfFailure(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, true, true, true) .ThrowIfFailure(); - Assert.Success(saveFs.GetEntryType(out _, "/file1".ToU8Span())); - Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file2".ToU8Span())); + Assert.Success(saveFs.GetEntryType(out _, "/file1")); + Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file2")); } [Fact] @@ -144,18 +144,18 @@ namespace LibHac.Tests.Fs { var baseFs = new InMemoryFileSystem(); - baseFs.CreateDirectory("/_".ToU8Span()).ThrowIfFailure(); - baseFs.CreateDirectory("/1".ToU8Span()).ThrowIfFailure(); + baseFs.CreateDirectory("/_").ThrowIfFailure(); + baseFs.CreateDirectory("/1").ThrowIfFailure(); // Set the existing files before initializing the save FS - baseFs.CreateFile("/_/file1".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); - baseFs.CreateFile("/1/file2".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + baseFs.CreateFile("/_/file1", 0, CreateFileOptions.None).ThrowIfFailure(); + baseFs.CreateFile("/1/file2", 0, CreateFileOptions.None).ThrowIfFailure(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, true, true, true) .ThrowIfFailure(); - Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file1".ToU8Span())); - Assert.Success(saveFs.GetEntryType(out _, "/file2".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file1")); + Assert.Success(saveFs.GetEntryType(out _, "/file2")); } [Fact] @@ -163,16 +163,16 @@ namespace LibHac.Tests.Fs { var baseFs = new InMemoryFileSystem(); - baseFs.CreateDirectory("/1".ToU8Span()).ThrowIfFailure(); + baseFs.CreateDirectory("/1").ThrowIfFailure(); // Set the existing files before initializing the save FS - baseFs.CreateFile("/1/file2".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + baseFs.CreateFile("/1/file2", 0, CreateFileOptions.None).ThrowIfFailure(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, true, true, true) .ThrowIfFailure(); - Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file1".ToU8Span())); - Assert.Success(saveFs.GetEntryType(out _, "/file2".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, saveFs.GetEntryType(out _, "/file1")); + Assert.Success(saveFs.GetEntryType(out _, "/file2")); } [Fact] @@ -283,14 +283,14 @@ namespace LibHac.Tests.Fs { var baseFs = new InMemoryFileSystem(); - CreateExtraDataForTest(baseFs, "/ExtraData_".ToU8Span(), 0x12345).ThrowIfFailure(); - CreateExtraDataForTest(baseFs, "/ExtraData1".ToU8Span(), 0x67890).ThrowIfFailure(); + CreateExtraDataForTest(baseFs, "/ExtraData_", 0x12345).ThrowIfFailure(); + CreateExtraDataForTest(baseFs, "/ExtraData1", 0x67890).ThrowIfFailure(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, true, true, true) .ThrowIfFailure(); - + saveFs.ReadExtraData(out SaveDataExtraData extraData).ThrowIfFailure(); - + Assert.Equal(0x67890, extraData.DataSize); } @@ -300,7 +300,7 @@ namespace LibHac.Tests.Fs var random = new RandomGenerator(); RandomDataGenerator randomGeneratorFunc = buffer => random.GenerateRandom(buffer); var timeStampGetter = new TimeStampGetter(); - + var baseFs = new InMemoryFileSystem(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, timeStampGetter, randomGeneratorFunc, true, true, true, null).ThrowIfFailure(); @@ -328,7 +328,7 @@ namespace LibHac.Tests.Fs var random = new RandomGenerator(); RandomDataGenerator randomGeneratorFunc = buffer => random.GenerateRandom(buffer); var timeStampGetter = new TimeStampGetter(); - + var baseFs = new InMemoryFileSystem(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, timeStampGetter, randomGeneratorFunc, true, true, true, null).ThrowIfFailure(); @@ -356,7 +356,7 @@ namespace LibHac.Tests.Fs var random = new RandomGenerator(); RandomDataGenerator randomGeneratorFunc = buffer => random.GenerateRandom(buffer); var timeStampGetter = new TimeStampGetter(); - + var baseFs = new InMemoryFileSystem(); DirectorySaveDataFileSystem.CreateNew(out DirectorySaveDataFileSystem saveFs, baseFs, timeStampGetter, randomGeneratorFunc, true, true, true, null).ThrowIfFailure(); @@ -385,7 +385,7 @@ namespace LibHac.Tests.Fs private class TimeStampGetter : ISaveDataCommitTimeStampGetter { private long _currentTimeStamp = 1; - + public Result Get(out long timeStamp) { timeStamp = _currentTimeStamp++; @@ -411,7 +411,7 @@ namespace LibHac.Tests.Fs } } - private Result CreateExtraDataForTest(IFileSystem fileSystem, U8Span path, int saveDataSize) + private Result CreateExtraDataForTest(IFileSystem fileSystem, string path, int saveDataSize) { fileSystem.DeleteFile(path).IgnoreResult(); diff --git a/tests/LibHac.Tests/Fs/FsaExtensions.cs b/tests/LibHac.Tests/Fs/FsaExtensions.cs new file mode 100644 index 00000000..dab65e7e --- /dev/null +++ b/tests/LibHac.Tests/Fs/FsaExtensions.cs @@ -0,0 +1,265 @@ +using System; +using LibHac.Common; +using LibHac.Fs; +using LibHac.Fs.Fsa; +using LibHac.Util; + +namespace LibHac.Tests.Fs +{ + public static class FsaExtensions + { + private static Result SetUpPath(out Path path, string value) + { + path = new Path(); + + if (value is null) + return ResultFs.NullptrArgument.Log(); + + Result rc = path.Initialize(StringUtils.StringToUtf8(value)); + if (rc.IsFailure()) return rc; + + rc = path.Normalize(new PathFlags()); + if (rc.IsFailure()) return rc; + + return Result.Success; + } + + public static Result CreateFile(this IFileSystem fs, string path, long size, CreateFileOptions option) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.CreateFile(in pathNormalized, size, option); + + pathNormalized.Dispose(); + return rc; + } + + public static Result CreateFile(this IFileSystem fs, string path, long size) + { + return CreateFile(fs, path, size, CreateFileOptions.None); + } + + public static Result DeleteFile(this IFileSystem fs, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.DeleteFile(in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result CreateDirectory(this IFileSystem fs, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.CreateDirectory(in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result DeleteDirectory(this IFileSystem fs, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.DeleteDirectory(in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result DeleteDirectoryRecursively(this IFileSystem fs, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.DeleteDirectoryRecursively(in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result CleanDirectoryRecursively(this IFileSystem fs, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.CleanDirectoryRecursively(in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result RenameFile(this IFileSystem fs, string currentPath, string newPath) + { + Result rc = SetUpPath(out Path currentPathNormalized, currentPath); + if (rc.IsFailure()) return rc; + + rc = SetUpPath(out Path newPathNormalized, newPath); + if (rc.IsFailure()) return rc; + + rc = fs.RenameFile(in currentPathNormalized, in newPathNormalized); + + currentPathNormalized.Dispose(); + newPathNormalized.Dispose(); + return rc; + } + + public static Result RenameDirectory(this IFileSystem fs, string currentPath, string newPath) + { + Result rc = SetUpPath(out Path currentPathNormalized, currentPath); + if (rc.IsFailure()) return rc; + + rc = SetUpPath(out Path newPathNormalized, newPath); + if (rc.IsFailure()) return rc; + + rc = fs.RenameDirectory(in currentPathNormalized, in newPathNormalized); + + currentPathNormalized.Dispose(); + newPathNormalized.Dispose(); + return rc; + } + + public static Result GetEntryType(this IFileSystem fs, out DirectoryEntryType entryType, string path) + { + UnsafeHelpers.SkipParamInit(out entryType); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetEntryType(out entryType, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result GetFreeSpaceSize(this IFileSystem fs, out long freeSpace, string path) + { + UnsafeHelpers.SkipParamInit(out freeSpace); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetFreeSpaceSize(out freeSpace, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result GetTotalSpaceSize(this IFileSystem fs, out long totalSpace, string path) + { + UnsafeHelpers.SkipParamInit(out totalSpace); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetTotalSpaceSize(out totalSpace, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result OpenFile(this IFileSystem fs, out IFile file, string path, OpenMode mode) + { + UnsafeHelpers.SkipParamInit(out file); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.OpenFile(out file, in pathNormalized, mode); + + pathNormalized.Dispose(); + return rc; + } + + public static Result OpenDirectory(this IFileSystem fs, out IDirectory directory, string path, OpenDirectoryMode mode) + { + UnsafeHelpers.SkipParamInit(out directory); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.OpenDirectory(out directory, in pathNormalized, mode); + + pathNormalized.Dispose(); + return rc; + } + + public static Result GetFileTimeStampRaw(this IFileSystem fs, out FileTimeStampRaw timeStamp, string path) + { + UnsafeHelpers.SkipParamInit(out timeStamp); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetFileTimeStampRaw(out timeStamp, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result QueryEntry(this IFileSystem fs, Span outBuffer, ReadOnlySpan inBuffer, QueryId queryId, string path) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.QueryEntry(outBuffer, inBuffer, queryId, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result CreateDirectory(this IAttributeFileSystem fs, string path, NxFileAttributes archiveAttribute) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.CreateDirectory(in pathNormalized, archiveAttribute); + + pathNormalized.Dispose(); + return rc; + } + + public static Result GetFileAttributes(this IAttributeFileSystem fs, out NxFileAttributes attributes, string path) + { + UnsafeHelpers.SkipParamInit(out attributes); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetFileAttributes(out attributes, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + + public static Result SetFileAttributes(this IAttributeFileSystem fs, string path, NxFileAttributes attributes) + { + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.SetFileAttributes(in pathNormalized, attributes); + + pathNormalized.Dispose(); + return rc; + } + + public static Result GetFileSize(this IAttributeFileSystem fs, out long fileSize, string path) + { + UnsafeHelpers.SkipParamInit(out fileSize); + + Result rc = SetUpPath(out Path pathNormalized, path); + if (rc.IsFailure()) return rc; + + rc = fs.GetFileSize(out fileSize, in pathNormalized); + + pathNormalized.Dispose(); + return rc; + } + } +} diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/CommittableIFileSystemTests.Commit.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/CommittableIFileSystemTests.Commit.cs index 3ebc76f5..c9fb8e6e 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/CommittableIFileSystemTests.Commit.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/CommittableIFileSystemTests.Commit.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -18,14 +17,14 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IFileSystem fs = fsCreator.Create(); // Make sure to test both directories and files - fs.CreateDirectory("/dir1".ToU8Span()).ThrowIfFailure(); - fs.CreateDirectory("/dir2".ToU8Span()).ThrowIfFailure(); + fs.CreateDirectory("/dir1").ThrowIfFailure(); + fs.CreateDirectory("/dir2").ThrowIfFailure(); - fs.CreateFile("/dir1/file".ToU8Span(), data1.Length, CreateFileOptions.None).ThrowIfFailure(); - fs.CreateFile("/dir2/file".ToU8Span(), data2.Length, CreateFileOptions.None).ThrowIfFailure(); + fs.CreateFile("/dir1/file", data1.Length, CreateFileOptions.None).ThrowIfFailure(); + fs.CreateFile("/dir2/file", data2.Length, CreateFileOptions.None).ThrowIfFailure(); - fs.OpenFile(out IFile file1, "/dir1/file".ToU8Span(), OpenMode.Write).ThrowIfFailure(); - fs.OpenFile(out IFile file2, "/dir2/file".ToU8Span(), OpenMode.Write).ThrowIfFailure(); + fs.OpenFile(out IFile file1, "/dir1/file", OpenMode.Write).ThrowIfFailure(); + fs.OpenFile(out IFile file2, "/dir2/file", OpenMode.Write).ThrowIfFailure(); file1.Write(0, data1, WriteOption.Flush).ThrowIfFailure(); file2.Write(0, data2, WriteOption.Flush).ThrowIfFailure(); @@ -42,7 +41,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase byte[] readData1 = new byte[data1.Length]; byte[] readData2 = new byte[data2.Length]; - Assert.Success(fs.OpenFile(out file1, "/dir1/file".ToU8Span(), OpenMode.Read)); + Assert.Success(fs.OpenFile(out file1, "/dir1/file", OpenMode.Read)); using (file1) { @@ -52,7 +51,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase Assert.Equal(data1, readData1); - Assert.Success(fs.OpenFile(out file2, "/dir2/file".ToU8Span(), OpenMode.Read)); + Assert.Success(fs.OpenFile(out file2, "/dir2/file", OpenMode.Read)); using (file2) { @@ -68,15 +67,15 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()).ThrowIfFailure(); - fs.CreateFile("/dir/file".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + fs.CreateDirectory("/dir").ThrowIfFailure(); + fs.CreateFile("/dir/file", 0, CreateFileOptions.None).ThrowIfFailure(); // Rollback should succeed Assert.Success(fs.Rollback()); // Make sure the file and directory are gone - Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir".ToU8Span())); - Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir/file".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir")); + Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir/file")); } [Fact] @@ -85,16 +84,16 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IReopenableFileSystemCreator fsCreator = GetFileSystemCreator(); IFileSystem fs = fsCreator.Create(); - fs.CreateDirectory("/dir".ToU8Span()).ThrowIfFailure(); - fs.CreateFile("/dir/file".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + fs.CreateDirectory("/dir").ThrowIfFailure(); + fs.CreateFile("/dir/file", 0, CreateFileOptions.None).ThrowIfFailure(); // Close without committing and reopen the file system fs.Dispose(); fs = fsCreator.Create(); // Make sure the file and directory are gone - Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir".ToU8Span())); - Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir/file".ToU8Span())); + Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir")); + Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "/dir/file")); } [Fact] @@ -107,10 +106,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IReopenableFileSystemCreator fsCreator = GetFileSystemCreator(); IFileSystem fs = fsCreator.Create(); - fs.CreateDirectory("/dir".ToU8Span()).ThrowIfFailure(); - fs.CreateFile("/dir/file".ToU8Span(), data1.Length, CreateFileOptions.None).ThrowIfFailure(); + fs.CreateDirectory("/dir").ThrowIfFailure(); + fs.CreateFile("/dir/file", data1.Length, CreateFileOptions.None).ThrowIfFailure(); - fs.OpenFile(out IFile file, "/dir/file".ToU8Span(), OpenMode.Write).ThrowIfFailure(); + fs.OpenFile(out IFile file, "/dir/file", OpenMode.Write).ThrowIfFailure(); file.Write(0, data1, WriteOption.Flush).ThrowIfFailure(); file.Dispose(); @@ -121,7 +120,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase fs = fsCreator.Create(); // Make changes to the file - fs.OpenFile(out file, "/dir/file".ToU8Span(), OpenMode.Write).ThrowIfFailure(); + fs.OpenFile(out file, "/dir/file", OpenMode.Write).ThrowIfFailure(); file.Write(0, data2, WriteOption.Flush).ThrowIfFailure(); file.Dispose(); @@ -130,7 +129,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase // The file should contain the original data after the rollback byte[] readData = new byte[data1.Length]; - Assert.Success(fs.OpenFile(out file, "/dir/file".ToU8Span(), OpenMode.Read)); + Assert.Success(fs.OpenFile(out file, "/dir/file", OpenMode.Read)); using (file) { diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IAttributeFileSystemTests.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IAttributeFileSystemTests.cs index 3c42e8a7..ca32f355 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IAttributeFileSystemTests.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IAttributeFileSystemTests.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -14,9 +13,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - Assert.Success(fs.CreateDirectory("/dir".ToU8Span(), NxFileAttributes.None)); + Assert.Success(fs.CreateDirectory("/dir", NxFileAttributes.None)); - Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir".ToU8Span())); + Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir")); Assert.Equal(NxFileAttributes.Directory, attributes); } @@ -25,9 +24,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - Assert.Success(fs.CreateDirectory("/dir".ToU8Span(), NxFileAttributes.Archive)); + Assert.Success(fs.CreateDirectory("/dir", NxFileAttributes.Archive)); - Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir".ToU8Span())); + Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir")); Assert.Equal(NxFileAttributes.Directory | NxFileAttributes.Archive, attributes); } @@ -35,9 +34,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void GetFileAttributes_AttributesOnNewFileAreEmpty() { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/file".ToU8Span())); + Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/file")); Assert.Equal(NxFileAttributes.None, attributes); } @@ -45,9 +44,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void GetFileAttributes_AttributesOnNewDirHaveOnlyDirFlagSet() { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir".ToU8Span())); + Assert.Success(fs.GetFileAttributes(out NxFileAttributes attributes, "/dir")); Assert.Equal(NxFileAttributes.Directory, attributes); } @@ -56,7 +55,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - Result rc = fs.GetFileAttributes(out _, "/path".ToU8Span()); + Result rc = fs.GetFileAttributes(out _, "/path"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -66,7 +65,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - Result rc = fs.SetFileAttributes("/path".ToU8Span(), NxFileAttributes.None); + Result rc = fs.SetFileAttributes("/path", NxFileAttributes.None); Assert.Result(ResultFs.PathNotFound, rc); } @@ -75,10 +74,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void SetFileAttributes_SetAttributeOnFile() { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rcSet = fs.SetFileAttributes("/file".ToU8Span(), NxFileAttributes.Archive); - Result rcGet = fs.GetFileAttributes(out NxFileAttributes attributes, "/file".ToU8Span()); + Result rcSet = fs.SetFileAttributes("/file", NxFileAttributes.Archive); + Result rcGet = fs.GetFileAttributes(out NxFileAttributes attributes, "/file"); Assert.Success(rcSet); Assert.Success(rcGet); @@ -89,10 +88,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void SetFileAttributes_SetAttributeOnDirectory() { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rcSet = fs.SetFileAttributes("/dir".ToU8Span(), NxFileAttributes.Archive); - Result rcGet = fs.GetFileAttributes(out NxFileAttributes attributes, "/dir".ToU8Span()); + Result rcSet = fs.SetFileAttributes("/dir", NxFileAttributes.Archive); + Result rcGet = fs.GetFileAttributes(out NxFileAttributes attributes, "/dir"); Assert.Success(rcSet); Assert.Success(rcGet); @@ -104,9 +103,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateFile("/file".ToU8Span(), 845, CreateFileOptions.None); + fs.CreateFile("/file", 845, CreateFileOptions.None); - Assert.Success(fs.GetFileSize(out long fileSize, "/file".ToU8Span())); + Assert.Success(fs.GetFileSize(out long fileSize, "/file")); Assert.Equal(845, fileSize); } @@ -115,7 +114,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IAttributeFileSystem fs = CreateAttributeFileSystem(); - Result rc = fs.GetFileSize(out _, "/path".ToU8Span()); + Result rc = fs.GetFileSize(out _, "/path"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -124,9 +123,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void GetFileSize_PathIsDirectory_ReturnsPathNotFound() { IAttributeFileSystem fs = CreateAttributeFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rc = fs.GetFileSize(out _, "/dir".ToU8Span()); + Result rc = fs.GetFileSize(out _, "/dir"); Assert.Result(ResultFs.PathNotFound, rc); } diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CleanDirectoryRecursively.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CleanDirectoryRecursively.cs index 0540c57c..8543fd81 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CleanDirectoryRecursively.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CleanDirectoryRecursively.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,15 +11,15 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); - fs.CreateDirectory("/dir/dir2".ToU8Span()); - fs.CreateFile("/dir/file1".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); + fs.CreateDirectory("/dir/dir2"); + fs.CreateFile("/dir/file1", 0, CreateFileOptions.None); - Result rcDelete = fs.CleanDirectoryRecursively("/dir".ToU8Span()); + Result rcDelete = fs.CleanDirectoryRecursively("/dir"); - Result rcDir1Type = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir".ToU8Span()); - Result rcDir2Type = fs.GetEntryType(out _, "/dir/dir2".ToU8Span()); - Result rcFileType = fs.GetEntryType(out _, "/dir/file1".ToU8Span()); + Result rcDir1Type = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir"); + Result rcDir2Type = fs.GetEntryType(out _, "/dir/dir2"); + Result rcFileType = fs.GetEntryType(out _, "/dir/file1"); Assert.Success(rcDelete); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateDirectory.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateDirectory.cs index 9b469ca9..91bda4b1 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateDirectory.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateDirectory.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,9 +11,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/dir".ToU8Span())); + Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/dir")); Assert.Equal(DirectoryEntryType.Directory, type); } @@ -23,9 +22,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rc = fs.CreateDirectory("/dir".ToU8Span()); + Result rc = fs.CreateDirectory("/dir"); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -35,9 +34,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rc = fs.CreateDirectory("/file".ToU8Span()); + Result rc = fs.CreateDirectory("/file"); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -47,7 +46,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - Result rc = fs.CreateFile("/dir1/dir2".ToU8Span(), 0, CreateFileOptions.None); + Result rc = fs.CreateFile("/dir1/dir2", 0, CreateFileOptions.None); Assert.Result(ResultFs.PathNotFound, rc); } @@ -57,8 +56,8 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir/".ToU8Span()); - Result rc = fs.GetEntryType(out DirectoryEntryType type, "/dir/".ToU8Span()); + fs.CreateDirectory("/dir/"); + Result rc = fs.GetEntryType(out DirectoryEntryType type, "/dir/"); Assert.Success(rc); Assert.Equal(DirectoryEntryType.Directory, type); @@ -69,11 +68,11 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir2"); - Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1".ToU8Span()); - Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2".ToU8Span()); + Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1"); + Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2"); Assert.Success(rc1); Assert.Success(rc2); @@ -86,14 +85,14 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir2"); - fs.CreateDirectory("/dir1/dir1a".ToU8Span()); - fs.CreateDirectory("/dir2/dir2a".ToU8Span()); + fs.CreateDirectory("/dir1/dir1a"); + fs.CreateDirectory("/dir2/dir2a"); - Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1/dir1a".ToU8Span()); - Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2/dir2a".ToU8Span()); + Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1/dir1a"); + Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2/dir2a"); Assert.Success(rc1); Assert.Success(rc2); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateFile.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateFile.cs index 2755c6eb..dc65ecf9 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateFile.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateFile.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,8 +11,8 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); - Result rc = fs.GetEntryType(out DirectoryEntryType type, "/file".ToU8Span()); + fs.CreateFile("/file", 0, CreateFileOptions.None); + Result rc = fs.GetEntryType(out DirectoryEntryType type, "/file"); Assert.Success(rc); Assert.Equal(DirectoryEntryType.File, type); @@ -24,9 +23,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rc = fs.CreateFile("/dir".ToU8Span(), 0, CreateFileOptions.None); + Result rc = fs.CreateFile("/dir", 0, CreateFileOptions.None); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -36,9 +35,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rc = fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + Result rc = fs.CreateFile("/file", 0, CreateFileOptions.None); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -48,7 +47,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - Result rc = fs.CreateFile("/dir/file".ToU8Span(), 0, CreateFileOptions.None); + Result rc = fs.CreateFile("/dir/file", 0, CreateFileOptions.None); Assert.Result(ResultFs.PathNotFound, rc); } @@ -58,9 +57,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file/".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file/", 0, CreateFileOptions.None); - Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/file/".ToU8Span())); + Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/file/")); Assert.Equal(DirectoryEntryType.File, type); } @@ -71,9 +70,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), expectedSize, CreateFileOptions.None); + fs.CreateFile("/file", expectedSize, CreateFileOptions.None); - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); Assert.Success(file.GetSize(out long fileSize)); Assert.Equal(expectedSize, fileSize); @@ -84,11 +83,11 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/file2".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file1", 0, CreateFileOptions.None); + fs.CreateFile("/file2", 0, CreateFileOptions.None); - Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/file1".ToU8Span()); - Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/file2".ToU8Span()); + Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/file1"); + Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/file2"); Assert.Success(rc1); Assert.Success(rc2); @@ -101,14 +100,14 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir2"); - fs.CreateFile("/dir1/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/dir2/file2".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/dir1/file1", 0, CreateFileOptions.None); + fs.CreateFile("/dir2/file2", 0, CreateFileOptions.None); - Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1/file1".ToU8Span()); - Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2/file2".ToU8Span()); + Result rc1 = fs.GetEntryType(out DirectoryEntryType type1, "/dir1/file1"); + Result rc2 = fs.GetEntryType(out DirectoryEntryType type2, "/dir2/file2"); Assert.Success(rc1); Assert.Success(rc2); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectory.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectory.cs index 3abdcdf8..bc01ecb5 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectory.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectory.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,7 +11,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - Result rc = fs.DeleteDirectory("/dir".ToU8Span()); + Result rc = fs.DeleteDirectory("/dir"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -22,10 +21,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rcDelete = fs.DeleteDirectory("/dir".ToU8Span()); - Result rcEntry = fs.GetEntryType(out _, "/dir".ToU8Span()); + Result rcDelete = fs.DeleteDirectory("/dir"); + Result rcEntry = fs.GetEntryType(out _, "/dir"); Assert.Success(rcDelete); Assert.Result(ResultFs.PathNotFound, rcEntry); @@ -36,9 +35,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rc = fs.DeleteDirectory("/file".ToU8Span()); + Result rc = fs.DeleteDirectory("/file"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -48,12 +47,12 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir2"); - Result rcDelete = fs.DeleteDirectory("/dir2".ToU8Span()); - Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1".ToU8Span()); - Result rcEntry2 = fs.GetEntryType(out _, "/dir2".ToU8Span()); + Result rcDelete = fs.DeleteDirectory("/dir2"); + Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1"); + Result rcEntry2 = fs.GetEntryType(out _, "/dir2"); Assert.Success(rcDelete); Assert.Success(rcEntry1); @@ -67,12 +66,12 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir2".ToU8Span()); - fs.CreateDirectory("/dir1".ToU8Span()); + fs.CreateDirectory("/dir2"); + fs.CreateDirectory("/dir1"); - Result rcDelete = fs.DeleteDirectory("/dir2".ToU8Span()); - Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1".ToU8Span()); - Result rcEntry2 = fs.GetEntryType(out _, "/dir2".ToU8Span()); + Result rcDelete = fs.DeleteDirectory("/dir2"); + Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1"); + Result rcEntry2 = fs.GetEntryType(out _, "/dir2"); Assert.Success(rcDelete); Assert.Success(rcEntry1); @@ -86,10 +85,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); - fs.CreateFile("/dir/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); + fs.CreateFile("/dir/file", 0, CreateFileOptions.None); - Result rc = fs.DeleteDirectory("/dir".ToU8Span()); + Result rc = fs.DeleteDirectory("/dir"); Assert.Result(ResultFs.DirectoryNotEmpty, rc); } diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectoryRecursively.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectoryRecursively.cs index d66b0152..fde7613e 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectoryRecursively.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectoryRecursively.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,15 +11,15 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); - fs.CreateDirectory("/dir/dir2".ToU8Span()); - fs.CreateFile("/dir/file1".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); + fs.CreateDirectory("/dir/dir2"); + fs.CreateFile("/dir/file1", 0, CreateFileOptions.None); - Result rcDelete = fs.DeleteDirectoryRecursively("/dir".ToU8Span()); + Result rcDelete = fs.DeleteDirectoryRecursively("/dir"); - Result rcDir1Type = fs.GetEntryType(out _, "/dir".ToU8Span()); - Result rcDir2Type = fs.GetEntryType(out _, "/dir/dir2".ToU8Span()); - Result rcFileType = fs.GetEntryType(out _, "/dir/file1".ToU8Span()); + Result rcDir1Type = fs.GetEntryType(out _, "/dir"); + Result rcDir2Type = fs.GetEntryType(out _, "/dir/dir2"); + Result rcFileType = fs.GetEntryType(out _, "/dir/file1"); Assert.Success(rcDelete); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteFile.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteFile.cs index bf501862..06e87839 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteFile.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteFile.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,7 +11,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - Result rc = fs.DeleteFile("/file".ToU8Span()); + Result rc = fs.DeleteFile("/file"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -21,10 +20,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rcDelete = fs.DeleteFile("/file".ToU8Span()); - Result rcEntry = fs.GetEntryType(out _, "/file".ToU8Span()); + Result rcDelete = fs.DeleteFile("/file"); + Result rcEntry = fs.GetEntryType(out _, "/file"); Assert.Success(rcDelete); Assert.Result(ResultFs.PathNotFound, rcEntry); @@ -35,9 +34,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rc = fs.DeleteFile("/dir".ToU8Span()); + Result rc = fs.DeleteFile("/dir"); Assert.Result(ResultFs.PathNotFound, rc); } @@ -47,12 +46,12 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/file2".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file1", 0, CreateFileOptions.None); + fs.CreateFile("/file2", 0, CreateFileOptions.None); - Result rcDelete = fs.DeleteFile("/file2".ToU8Span()); - Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/file1".ToU8Span()); - Result rcEntry2 = fs.GetEntryType(out _, "/file2".ToU8Span()); + Result rcDelete = fs.DeleteFile("/file2"); + Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/file1"); + Result rcEntry2 = fs.GetEntryType(out _, "/file2"); Assert.Success(rcDelete); Assert.Success(rcEntry1); @@ -66,12 +65,12 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file2".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file2", 0, CreateFileOptions.None); + fs.CreateFile("/file1", 0, CreateFileOptions.None); - Result rcDelete = fs.DeleteFile("/file2".ToU8Span()); - Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/file1".ToU8Span()); - Result rcEntry2 = fs.GetEntryType(out _, "/file2".ToU8Span()); + Result rcDelete = fs.DeleteFile("/file2"); + Result rcEntry1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/file1"); + Result rcEntry2 = fs.GetEntryType(out _, "/file2"); Assert.Success(rcDelete); Assert.Success(rcEntry1); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IDirectory.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IDirectory.cs index 0d3c9bc5..d4fed187 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IDirectory.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IDirectory.cs @@ -15,7 +15,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IFileSystem fs = CreateFileSystem(); Span entries = stackalloc DirectoryEntry[1]; - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/", OpenDirectoryMode.All)); Assert.Success(directory.Read(out long entriesRead, entries)); Assert.Equal(0, entriesRead); @@ -26,7 +26,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/", OpenDirectoryMode.All)); Assert.Success(directory.GetEntryCount(out long entryCount)); Assert.Equal(0, entryCount); @@ -36,13 +36,13 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void IDirectoryRead_AllEntriesAreReturned() { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); - fs.CreateDirectory("/dir/dir1".ToU8Span()); - fs.CreateFile("/dir/dir1/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/dir/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/dir/file2".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); + fs.CreateDirectory("/dir/dir1"); + fs.CreateFile("/dir/dir1/file1", 0, CreateFileOptions.None); + fs.CreateFile("/dir/file1", 0, CreateFileOptions.None); + fs.CreateFile("/dir/file2", 0, CreateFileOptions.None); - Assert.Success(fs.OpenDirectory(out IDirectory dir, "/dir".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory dir, "/dir", OpenDirectoryMode.All)); var entry1 = new DirectoryEntry(); var entry2 = new DirectoryEntry(); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Read.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Read.cs index 62dd59fa..ee08d40a 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Read.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Read.cs @@ -1,5 +1,4 @@ using System; -using LibHac.Common; using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -13,10 +12,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 100, CreateFileOptions.None); + fs.CreateFile("/file", 100, CreateFileOptions.None); byte[] buffer = new byte[20]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Assert.Success(file.Read(out long bytesRead, 50, buffer, ReadOption.None)); @@ -29,10 +28,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Result rc = file.Read(out _, 1, buffer, ReadOption.None); @@ -45,10 +44,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); using (file) { Result rc = file.Read(out _, 0, buffer, ReadOption.None); @@ -61,10 +60,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); using (file) { Result rc = file.Read(out _, -5, buffer, ReadOption.None); @@ -77,10 +76,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); using (file) { Result rc = file.Read(out _, long.MaxValue - 5, buffer, ReadOption.None); @@ -93,10 +92,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 100, CreateFileOptions.None); + fs.CreateFile("/file", 100, CreateFileOptions.None); byte[] buffer = new byte[200]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Assert.Success(file.Read(out long bytesRead, 90, buffer, ReadOption.None)); @@ -109,10 +108,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 100, CreateFileOptions.None); + fs.CreateFile("/file", 100, CreateFileOptions.None); // The contents of a created file are undefined, so zero the file - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); using (file) { file.Write(0, new byte[100], WriteOption.None); @@ -124,7 +123,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase byte[] buffer = new byte[200]; buffer.AsSpan().Fill(0xCC); - fs.OpenFile(out file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out file, "/file", OpenMode.Read); using (file) { Assert.Success(file.Read(out _, 90, buffer, ReadOption.None)); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Size.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Size.cs index c6f6c710..61dbfe17 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Size.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Size.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -11,13 +10,13 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase public void SetSize_FileSizeModified() { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.All); + fs.OpenFile(out IFile file, "/file", OpenMode.All); Result rc = file.SetSize(54321); file.Dispose(); - fs.OpenFile(out file, "/file".ToU8Span(), OpenMode.All); + fs.OpenFile(out file, "/file", OpenMode.All); file.GetSize(out long fileSize); file.Dispose(); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Write.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Write.cs index ac4a740d..550433d5 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Write.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Write.cs @@ -1,5 +1,4 @@ using System; -using LibHac.Common; using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -15,15 +14,15 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), data.Length, CreateFileOptions.None); + fs.CreateFile("/file", data.Length, CreateFileOptions.None); - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); file.Write(0, data, WriteOption.None); file.Dispose(); byte[] readData = new byte[data.Length]; - fs.OpenFile(out file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out file, "/file", OpenMode.Read); using (file) { Assert.Success(file.Read(out long bytesRead, 0, readData, ReadOption.None)); @@ -38,10 +37,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); using (file) { Result rc = file.Write(5, buffer, WriteOption.None); @@ -54,10 +53,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Result rc = file.Write(5, buffer, WriteOption.None); @@ -70,10 +69,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Result rc = file.Write(-5, buffer, WriteOption.None); @@ -86,10 +85,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out IFile file, "/file", OpenMode.Read); using (file) { Result rc = file.Write(long.MaxValue - 5, buffer, WriteOption.None); @@ -102,10 +101,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.All); + fs.OpenFile(out IFile file, "/file", OpenMode.All); using (file) { Assert.Success(file.Write(5, buffer, WriteOption.None)); @@ -120,10 +119,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] buffer = new byte[10]; - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.All); + fs.OpenFile(out IFile file, "/file", OpenMode.All); using (file) { Assert.Success(file.Write(15, buffer, WriteOption.None)); @@ -138,7 +137,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 10, CreateFileOptions.None); + fs.CreateFile("/file", 10, CreateFileOptions.None); byte[] bufferExpected = new byte[25]; bufferExpected.AsSpan(15).Fill(0xCC); @@ -146,7 +145,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase byte[] writeBuffer = new byte[10]; writeBuffer.AsSpan().Fill(0xCC); - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.All); + fs.OpenFile(out IFile file, "/file", OpenMode.All); using (file) { Assert.Success(file.Write(15, writeBuffer, WriteOption.None)); @@ -157,7 +156,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase byte[] readBuffer = new byte[25]; - fs.OpenFile(out file, "/file".ToU8Span(), OpenMode.Read); + fs.OpenFile(out file, "/file", OpenMode.Read); using (file) { file.Read(out _, 0, readBuffer, ReadOption.None); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenDirectory.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenDirectory.cs index acbea17b..c8c3b669 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenDirectory.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenDirectory.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,9 +11,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file", 0, CreateFileOptions.None); - Result rc = fs.OpenDirectory(out _, "/file".ToU8Span(), OpenDirectoryMode.All); + Result rc = fs.OpenDirectory(out _, "/file", OpenDirectoryMode.All); Assert.Result(ResultFs.PathNotFound, rc); } diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenFile.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenFile.cs index c8f5a8c2..aee7ee75 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenFile.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenFile.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,9 +11,9 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateDirectory("/dir"); - Result rc = fs.OpenFile(out _, "/dir".ToU8Span(), OpenMode.All); + Result rc = fs.OpenFile(out _, "/dir", OpenMode.All); Assert.Result(ResultFs.PathNotFound, rc); } diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameDirectory.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameDirectory.cs index 861483ff..0a72ebbe 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameDirectory.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameDirectory.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,11 +11,11 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - Result rcRename = fs.RenameDirectory("/dir1".ToU8Span(), "/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + Result rcRename = fs.RenameDirectory("/dir1", "/dir2"); - Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2".ToU8Span()); - Result rcDir1 = fs.GetEntryType(out _, "/dir1".ToU8Span()); + Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2"); + Result rcDir1 = fs.GetEntryType(out _, "/dir1"); Assert.Success(rcRename); @@ -31,21 +30,21 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir1/dirC".ToU8Span()); - fs.CreateFile("/dir1/file1".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir1/dirC"); + fs.CreateFile("/dir1/file1", 0, CreateFileOptions.None); - Result rcRename = fs.RenameDirectory("/dir1".ToU8Span(), "/dir2".ToU8Span()); + Result rcRename = fs.RenameDirectory("/dir1", "/dir2"); // Check that renamed structure exists - Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2".ToU8Span()); - Result rcDirC = fs.GetEntryType(out DirectoryEntryType dir1CType, "/dir2/dirC".ToU8Span()); - Result rcFile1 = fs.GetEntryType(out DirectoryEntryType file1Type, "/dir2/file1".ToU8Span()); + Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2"); + Result rcDirC = fs.GetEntryType(out DirectoryEntryType dir1CType, "/dir2/dirC"); + Result rcFile1 = fs.GetEntryType(out DirectoryEntryType file1Type, "/dir2/file1"); // Check that old structure doesn't exist - Result rcDir1 = fs.GetEntryType(out _, "/dir1".ToU8Span()); - Result rcDirCOld = fs.GetEntryType(out _, "/dir1/dirC".ToU8Span()); - Result rcFile1Old = fs.GetEntryType(out _, "/dir1/file1".ToU8Span()); + Result rcDir1 = fs.GetEntryType(out _, "/dir1"); + Result rcDirCOld = fs.GetEntryType(out _, "/dir1/dirC"); + Result rcFile1Old = fs.GetEntryType(out _, "/dir1/file1"); Assert.Success(rcRename); @@ -67,14 +66,14 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/parent1".ToU8Span()); - fs.CreateDirectory("/parent2".ToU8Span()); - fs.CreateDirectory("/parent1/dir1".ToU8Span()); + fs.CreateDirectory("/parent1"); + fs.CreateDirectory("/parent2"); + fs.CreateDirectory("/parent1/dir1"); - Result rcRename = fs.RenameDirectory("/parent1/dir1".ToU8Span(), "/parent2/dir2".ToU8Span()); + Result rcRename = fs.RenameDirectory("/parent1/dir1", "/parent2/dir2"); - Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/parent2/dir2".ToU8Span()); - Result rcDir1 = fs.GetEntryType(out _, "/parent1/dir1".ToU8Span()); + Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/parent2/dir2"); + Result rcDir1 = fs.GetEntryType(out _, "/parent1/dir1"); Assert.Success(rcRename); @@ -90,13 +89,13 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateDirectory("/dir1".ToU8Span()); - fs.CreateDirectory("/dir2".ToU8Span()); + fs.CreateDirectory("/dir1"); + fs.CreateDirectory("/dir2"); - Result rcRename = fs.RenameDirectory("/dir1".ToU8Span(), "/dir2".ToU8Span()); + Result rcRename = fs.RenameDirectory("/dir1", "/dir2"); - Result rcDir1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1".ToU8Span()); - Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2".ToU8Span()); + Result rcDir1 = fs.GetEntryType(out DirectoryEntryType dir1Type, "/dir1"); + Result rcDir2 = fs.GetEntryType(out DirectoryEntryType dir2Type, "/dir2"); Assert.Result(ResultFs.PathAlreadyExists, rcRename); diff --git a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameFile.cs b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameFile.cs index acbc4981..669bdc3a 100644 --- a/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameFile.cs +++ b/tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameFile.cs @@ -1,5 +1,4 @@ -using LibHac.Common; -using LibHac.Fs; +using LibHac.Fs; using LibHac.Fs.Fsa; using Xunit; @@ -12,12 +11,12 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file1", 0, CreateFileOptions.None); - Assert.Success(fs.RenameFile("/file1".ToU8Span(), "/file2".ToU8Span())); + Assert.Success(fs.RenameFile("/file1", "/file2")); - Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/file2".ToU8Span())); - Result rc = fs.GetEntryType(out _, "/file1".ToU8Span()); + Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/file2")); + Result rc = fs.GetEntryType(out _, "/file1"); Assert.Equal(DirectoryEntryType.File, type); Assert.Result(ResultFs.PathNotFound, rc); @@ -27,13 +26,13 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateFile("/file1", 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); - Assert.Success(fs.RenameFile("/file1".ToU8Span(), "/dir/file2".ToU8Span())); + Assert.Success(fs.RenameFile("/file1", "/dir/file2")); - Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/dir/file2".ToU8Span())); - Result rc = fs.GetEntryType(out _, "/file1".ToU8Span()); + Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "/dir/file2")); + Result rc = fs.GetEntryType(out _, "/file1"); Assert.Equal(DirectoryEntryType.File, type); Assert.Result(ResultFs.PathNotFound, rc); @@ -44,10 +43,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateFile("/file2".ToU8Span(), 0, CreateFileOptions.None); + fs.CreateFile("/file1", 0, CreateFileOptions.None); + fs.CreateFile("/file2", 0, CreateFileOptions.None); - Result rc = fs.RenameFile("/file1".ToU8Span(), "/file2".ToU8Span()); + Result rc = fs.RenameFile("/file1", "/file2"); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -57,10 +56,10 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); - fs.CreateDirectory("/dir".ToU8Span()); + fs.CreateFile("/file", 0, CreateFileOptions.None); + fs.CreateDirectory("/dir"); - Result rc = fs.RenameFile("/file".ToU8Span(), "/dir".ToU8Span()); + Result rc = fs.RenameFile("/file", "/dir"); Assert.Result(ResultFs.PathAlreadyExists, rc); } @@ -70,13 +69,13 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase { IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file1".ToU8Span(), 54321, CreateFileOptions.None); - fs.CreateFile("/file2".ToU8Span(), 12345, CreateFileOptions.None); + fs.CreateFile("/file1", 54321, CreateFileOptions.None); + fs.CreateFile("/file2", 12345, CreateFileOptions.None); - fs.RenameFile("/file1".ToU8Span(), "/file2".ToU8Span()); + fs.RenameFile("/file1", "/file2"); - Assert.Success(fs.OpenFile(out IFile file1, "/file1".ToU8Span(), OpenMode.Read)); - Assert.Success(fs.OpenFile(out IFile file2, "/file2".ToU8Span(), OpenMode.Read)); + Assert.Success(fs.OpenFile(out IFile file1, "/file1", OpenMode.Read)); + Assert.Success(fs.OpenFile(out IFile file2, "/file2", OpenMode.Read)); using (file1) using (file2) @@ -96,17 +95,17 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase IFileSystem fs = CreateFileSystem(); - fs.CreateFile("/file".ToU8Span(), data.Length, CreateFileOptions.None); + fs.CreateFile("/file", data.Length, CreateFileOptions.None); - fs.OpenFile(out IFile file, "/file".ToU8Span(), OpenMode.Write); + fs.OpenFile(out IFile file, "/file", OpenMode.Write); file.Write(0, data, WriteOption.None); file.Dispose(); - fs.RenameFile("/file".ToU8Span(), "/renamed".ToU8Span()); + fs.RenameFile("/file", "/renamed"); byte[] readData = new byte[data.Length]; - fs.OpenFile(out file, "/renamed".ToU8Span(), OpenMode.Read); + fs.OpenFile(out file, "/renamed", OpenMode.Read); Result rc = file.Read(out long bytesRead, 0, readData, ReadOption.None); file.Dispose(); diff --git a/tests/LibHac.Tests/Fs/LayeredFileSystemTests.cs b/tests/LibHac.Tests/Fs/LayeredFileSystemTests.cs index 7544595b..b693c0e8 100644 --- a/tests/LibHac.Tests/Fs/LayeredFileSystemTests.cs +++ b/tests/LibHac.Tests/Fs/LayeredFileSystemTests.cs @@ -17,30 +17,30 @@ namespace LibHac.Tests.Fs var layeredFs = new LayeredFileSystem(lowerLayerFs, upperLayerFs); - lowerLayerFs.CreateDirectory("/dir".ToU8Span()).ThrowIfFailure(); - upperLayerFs.CreateDirectory("/dir".ToU8Span()).ThrowIfFailure(); - lowerLayerFs.CreateDirectory("/dir2".ToU8Span()).ThrowIfFailure(); - upperLayerFs.CreateDirectory("/dir2".ToU8Span()).ThrowIfFailure(); - lowerLayerFs.CreateDirectory("/dir3".ToU8Span()).ThrowIfFailure(); - upperLayerFs.CreateDirectory("/dir3".ToU8Span()).ThrowIfFailure(); + lowerLayerFs.CreateDirectory("/dir").ThrowIfFailure(); + upperLayerFs.CreateDirectory("/dir").ThrowIfFailure(); + lowerLayerFs.CreateDirectory("/dir2").ThrowIfFailure(); + upperLayerFs.CreateDirectory("/dir2").ThrowIfFailure(); + lowerLayerFs.CreateDirectory("/dir3").ThrowIfFailure(); + upperLayerFs.CreateDirectory("/dir3").ThrowIfFailure(); - lowerLayerFs.CreateDirectory("/lowerDir".ToU8Span()).ThrowIfFailure(); - upperLayerFs.CreateDirectory("/upperDir".ToU8Span()).ThrowIfFailure(); + lowerLayerFs.CreateDirectory("/lowerDir").ThrowIfFailure(); + upperLayerFs.CreateDirectory("/upperDir").ThrowIfFailure(); - lowerLayerFs.CreateFile("/dir/replacedFile".ToU8Span(), 1, CreateFileOptions.None).ThrowIfFailure(); - upperLayerFs.CreateFile("/dir/replacedFile".ToU8Span(), 2, CreateFileOptions.None).ThrowIfFailure(); + lowerLayerFs.CreateFile("/dir/replacedFile", 1, CreateFileOptions.None).ThrowIfFailure(); + upperLayerFs.CreateFile("/dir/replacedFile", 2, CreateFileOptions.None).ThrowIfFailure(); - lowerLayerFs.CreateFile("/dir2/lowerFile".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); - upperLayerFs.CreateFile("/dir2/upperFile".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + lowerLayerFs.CreateFile("/dir2/lowerFile", 0, CreateFileOptions.None).ThrowIfFailure(); + upperLayerFs.CreateFile("/dir2/upperFile", 0, CreateFileOptions.None).ThrowIfFailure(); - lowerLayerFs.CreateFile("/dir3/lowerFile".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); - upperLayerFs.CreateFile("/dir3/upperFile".ToU8Span(), 2, CreateFileOptions.None).ThrowIfFailure(); - lowerLayerFs.CreateFile("/dir3/replacedFile".ToU8Span(), 1, CreateFileOptions.None).ThrowIfFailure(); - upperLayerFs.CreateFile("/dir3/replacedFile".ToU8Span(), 2, CreateFileOptions.None).ThrowIfFailure(); + lowerLayerFs.CreateFile("/dir3/lowerFile", 0, CreateFileOptions.None).ThrowIfFailure(); + upperLayerFs.CreateFile("/dir3/upperFile", 2, CreateFileOptions.None).ThrowIfFailure(); + lowerLayerFs.CreateFile("/dir3/replacedFile", 1, CreateFileOptions.None).ThrowIfFailure(); + upperLayerFs.CreateFile("/dir3/replacedFile", 2, CreateFileOptions.None).ThrowIfFailure(); - lowerLayerFs.CreateFile("/replacedWithDir".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); - upperLayerFs.CreateDirectory("/replacedWithDir".ToU8Span()).ThrowIfFailure(); - upperLayerFs.CreateFile("/replacedWithDir/subFile".ToU8Span(), 0, CreateFileOptions.None).ThrowIfFailure(); + lowerLayerFs.CreateFile("/replacedWithDir", 0, CreateFileOptions.None).ThrowIfFailure(); + upperLayerFs.CreateDirectory("/replacedWithDir").ThrowIfFailure(); + upperLayerFs.CreateFile("/replacedWithDir/subFile", 0, CreateFileOptions.None).ThrowIfFailure(); return layeredFs; } @@ -58,7 +58,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Result(ResultFs.PathNotFound, fs.OpenFile(out _, "/fakefile".ToU8Span(), OpenMode.All)); + Assert.Result(ResultFs.PathNotFound, fs.OpenFile(out _, "/fakefile", OpenMode.All)); } [Fact] @@ -66,7 +66,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenFile(out IFile file, "/dir/replacedFile".ToU8Span(), OpenMode.All)); + Assert.Success(fs.OpenFile(out IFile file, "/dir/replacedFile", OpenMode.All)); Assert.Success(file.GetSize(out long fileSize)); Assert.Equal(2, fileSize); @@ -77,8 +77,8 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenFile(out _, "/dir2/lowerFile".ToU8Span(), OpenMode.All)); - Assert.Success(fs.OpenFile(out _, "/dir2/upperFile".ToU8Span(), OpenMode.All)); + Assert.Success(fs.OpenFile(out _, "/dir2/lowerFile", OpenMode.All)); + Assert.Success(fs.OpenFile(out _, "/dir2/upperFile", OpenMode.All)); } [Fact] @@ -86,7 +86,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Result(ResultFs.PathNotFound, fs.OpenDirectory(out _, "/fakedir".ToU8Span(), OpenDirectoryMode.All)); + Assert.Result(ResultFs.PathNotFound, fs.OpenDirectory(out _, "/fakedir", OpenDirectoryMode.All)); } [Fact] @@ -94,7 +94,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenDirectory(out IDirectory dir, "/lowerDir".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory dir, "/lowerDir", OpenDirectoryMode.All)); Assert.Equal(typeof(InMemoryFileSystem), dir.GetType().DeclaringType); } @@ -103,7 +103,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenDirectory(out IDirectory dir, "/dir".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory dir, "/dir", OpenDirectoryMode.All)); Assert.Equal(typeof(LayeredFileSystem), dir.GetType().DeclaringType); } @@ -112,8 +112,8 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.GetEntryType(out _, "/dir2/lowerFile".ToU8Span())); - Assert.Success(fs.GetEntryType(out _, "/dir2/upperFile".ToU8Span())); + Assert.Success(fs.GetEntryType(out _, "/dir2/lowerFile")); + Assert.Success(fs.GetEntryType(out _, "/dir2/upperFile")); } [Fact] @@ -122,7 +122,7 @@ namespace LibHac.Tests.Fs IFileSystem fs = CreateFileSystem(); Span entries = stackalloc DirectoryEntry[4]; - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3", OpenDirectoryMode.All)); Assert.Success(directory.Read(out long entriesRead, entries)); Assert.Equal(3, entriesRead); @@ -134,7 +134,7 @@ namespace LibHac.Tests.Fs IFileSystem fs = CreateFileSystem(); var entry = new DirectoryEntry(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir", OpenDirectoryMode.All)); Assert.Success(directory.Read(out _, SpanHelpers.AsSpan(ref entry))); Assert.Equal("replacedFile", StringUtils.Utf8ZToString(entry.Name)); @@ -147,7 +147,7 @@ namespace LibHac.Tests.Fs IFileSystem fs = CreateEmptyFileSystem(); var entry = new DirectoryEntry(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/", OpenDirectoryMode.All)); Assert.Success(directory.Read(out long entriesRead, SpanHelpers.AsSpan(ref entry))); Assert.Equal(0, entriesRead); @@ -158,7 +158,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateFileSystem(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3", OpenDirectoryMode.All)); Assert.Success(directory.GetEntryCount(out long entryCount)); Assert.Equal(3, entryCount); @@ -170,7 +170,7 @@ namespace LibHac.Tests.Fs IFileSystem fs = CreateFileSystem(); var entry = new DirectoryEntry(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/dir3", OpenDirectoryMode.All)); // Read all entries long entriesRead; @@ -188,7 +188,7 @@ namespace LibHac.Tests.Fs { IFileSystem fs = CreateEmptyFileSystem(); - Assert.Success(fs.OpenDirectory(out IDirectory directory, "/".ToU8Span(), OpenDirectoryMode.All)); + Assert.Success(fs.OpenDirectory(out IDirectory directory, "/", OpenDirectoryMode.All)); Assert.Success(directory.GetEntryCount(out long entryCount)); Assert.Equal(0, entryCount); diff --git a/tests/LibHac.Tests/Fs/SubdirectoryFileSystemTests.cs b/tests/LibHac.Tests/Fs/SubdirectoryFileSystemTests.cs index c49a572e..f59d6964 100644 --- a/tests/LibHac.Tests/Fs/SubdirectoryFileSystemTests.cs +++ b/tests/LibHac.Tests/Fs/SubdirectoryFileSystemTests.cs @@ -17,8 +17,8 @@ namespace LibHac.Tests.Fs private (IFileSystem baseFs, IFileSystem subDirFs) CreateFileSystemInternal() { var baseFs = new InMemoryFileSystem(); - baseFs.CreateDirectory("/sub".ToU8Span()); - baseFs.CreateDirectory("/sub/path".ToU8Span()); + baseFs.CreateDirectory("/sub"); + baseFs.CreateDirectory("/sub/path"); var subFs = new SubdirectoryFileSystem(baseFs); subFs.Initialize("/sub/path".ToU8String()).ThrowIfFailure(); @@ -31,9 +31,9 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem subDirFs) = CreateFileSystemInternal(); - subDirFs.CreateFile("/file".ToU8Span(), 0, CreateFileOptions.None); + subDirFs.CreateFile("/file", 0, CreateFileOptions.None); - Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/sub/path/file".ToU8Span())); + Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/sub/path/file")); Assert.Equal(DirectoryEntryType.File, type); } @@ -42,9 +42,9 @@ namespace LibHac.Tests.Fs { (IFileSystem baseFs, IFileSystem subDirFs) = CreateFileSystemInternal(); - subDirFs.CreateDirectory("/dir".ToU8Span()); + subDirFs.CreateDirectory("/dir"); - Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/sub/path/dir".ToU8Span())); + Assert.Success(baseFs.GetEntryType(out DirectoryEntryType type, "/sub/path/dir")); Assert.Equal(DirectoryEntryType.Directory, type); } }