Mirror/LibHac
1
0
Fork 0
mirror of https://github.com/Thealexbarney/LibHac.git synced 2025-02-09 13:14:46 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update tests to use the updated fsa interfaces

Browse Source
This commit is contained in:
Alex Barney 2021-07-19 13:16:11 -07:00
parent 4ceb925cde
commit 77aef9166f
21 changed files with 599 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/LibHac/Fs/Fsa/IAttributeFileSystem.cs
View File

@ -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);
}
}

80
tests/LibHac.Tests/Fs/DirectorySaveDataFileSystemTests.cs
View File

@ -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();

265
tests/LibHac.Tests/Fs/FsaExtensions.cs Normal file
View File

@ -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<byte> outBuffer, ReadOnlySpan<byte> 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;
}
}
}

45
tests/LibHac.Tests/Fs/IFileSystemTestBase/CommittableIFileSystemTests.Commit.cs
View File

@ -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)
{

45
tests/LibHac.Tests/Fs/IFileSystemTestBase/IAttributeFileSystemTests.cs
View File

@ -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);
}

17
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CleanDirectoryRecursively.cs
View File

@ -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);

41
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateDirectory.cs
View File

@ -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);

45
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.CreateFile.cs
View File

@ -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);

41
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectory.cs
View File

@ -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);
}

17
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteDirectoryRecursively.cs
View File

@ -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);

35
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.DeleteFile.cs
View File

@ -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);

16
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IDirectory.cs
View File

@ -15,7 +15,7 @@ namespace LibHac.Tests.Fs.IFileSystemTestBase
IFileSystem fs = CreateFileSystem();
Span<DirectoryEntry> 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();

31
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Read.cs
View File

@ -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));

9
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Size.cs
View File

@ -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();

37
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.IFile.Write.cs
View File

@ -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);

7
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenDirectory.cs
View File

@ -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);
}

7
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.OpenFile.cs
View File

@ -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);
}

53
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameDirectory.cs
View File

@ -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);

51
tests/LibHac.Tests/Fs/IFileSystemTestBase/IFileSystemTests.RenameFile.cs
View File

@ -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();

68
tests/LibHac.Tests/Fs/LayeredFileSystemTests.cs
View File

@ -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<DirectoryEntry> 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);

12
tests/LibHac.Tests/Fs/SubdirectoryFileSystemTests.cs
View File

@ -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);
}
}