public void MountCacheStorage_SdCardIsPreferredOverBis()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
fs.CreateCacheStorage(applicationId, SaveDataSpaceId.SdCache, applicationId.Value, 0, 0, SaveDataFlags.None);
fs.MountCacheStorage("cache".ToU8Span(), applicationId);
fs.CreateFile("cache:/sd".ToU8Span(), 0);
fs.Commit("cache".ToU8Span());
fs.Unmount("cache".ToU8Span());
// Turn off the SD card so the User save is mounted
fs.SetSdCardAccessibility(false);
fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, SaveDataFlags.None);
fs.MountCacheStorage("cache".ToU8Span(), applicationId);
fs.CreateFile("cache:/bis".ToU8Span(), 0);
fs.Commit("cache".ToU8Span());
fs.Unmount("cache".ToU8Span());
fs.SetSdCardAccessibility(true);
Assert.Success(fs.MountCacheStorage("cache".ToU8String(), applicationId));
Assert.Success(fs.GetEntryType(out _, "cache:/sd".ToU8Span()));
Assert.Failure(fs.GetEntryType(out _, "cache:/bis".ToU8Span()));
}
public void CreateCacheStorage_InSdCacheSaveSpaceWhenNoSdCard_ReturnsSdCardNotFound()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(false);
Assert.Result(ResultFs.PortSdCardNoDevice, fs.CreateCacheStorage(applicationId, SaveDataSpaceId.SdCache, applicationId.Value, 0, 0, SaveDataFlags.None));
}
public void MountBcatSaveData_SaveDoesNotExist_ReturnsTargetNotFound()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Result(ResultFs.TargetNotFound, fs.MountBcatSaveData("bcat_test".ToU8Span(), applicationId));
}
public void CreateSaveData_SaveDataIteratorsAreOpen_IteratorsPointToSameEntry(int nextEntryWhenAdding,
int entryToAdd, int expectedNextEntry)
{
// Static save IDs must have the high bit set
const ulong mask = 0x8000000000000000;
const int count = 10;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create saves
for (int i = 0; i < count * 2; i++)
{
Assert.Success(fs.CreateSystemSaveData(SaveDataSpaceId.User, ((ulong)i * 2) | mask, 0, 0x4000,
0x4000, SaveDataFlags.None));
}
// Open an iterator
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
// Skip ahead a few entries. We skipped 0 and added every other ID, so divide by 2 and subtract 1
var infos = new SaveDataInfo[nextEntryWhenAdding / 2 - 1];
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, infos));
Assert.Equal(infos.Length, readCount);
// Create the save
Assert.Success(fs.CreateSystemSaveData(SaveDataSpaceId.User, (uint)entryToAdd | mask, (ulong)entryToAdd, 0x4000,
0x4000, SaveDataFlags.None));
// Check the save ID of the next entry
Assert.Success(iterator.ReadSaveDataInfo(out long readCount2, infos.AsSpan(0, 1)));
Assert.Equal(1, readCount2);
Assert.Equal((uint)expectedNextEntry | mask, infos[0].SaveDataId);
}
public void DeleteSaveData_SaveDataIteratorsAreOpen_IteratorsPointToSameEntry(int nextEntryWhenRemoving,
int entryToRemove, int expectedNextEntry)
{
const int count = 20;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create saves
Assert.Success(PopulateSaveData(fs, count));
// Open an iterator
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
// Skip ahead a few entries. Entries start counting at 1, so subtract 1
var infos = new SaveDataInfo[nextEntryWhenRemoving - 1];
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, infos));
Assert.Equal(infos.Length, readCount);
// Delete the save
Assert.Success(fs.DeleteSaveData(SaveDataSpaceId.User, (ulong)entryToRemove));
// Check the program ID of the next entry
Assert.Success(iterator.ReadSaveDataInfo(out long readCount2, infos.AsSpan(0, 1)));
Assert.Equal(1, readCount2);
Assert.Equal((ulong)expectedNextEntry, infos[0].ProgramId.Value);
}
public void DeleteSaveData_SaveExistsInUserSaveSpace_SaveIsDeleted()
{
var applicationId = new Ncm.ApplicationId(1);
var userId = new UserId(5, 4);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSaveData(applicationId, userId, 0, 0x1000, 0x1000, SaveDataFlags.None));
// Get the ID of the save
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo[1];
Assert.Success(iterator.ReadSaveDataInfo(out _, info));
// Delete the save
Assert.Success(fs.DeleteSaveData(info[0].SaveDataId));
// Iterate saves again
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator2, SaveDataSpaceId.User));
Assert.Success(iterator2.ReadSaveDataInfo(out long entriesRead, info));
// Make sure no saves were returned
Assert.Equal(0, entriesRead);
}
public void CreateCacheStorage_AlreadyExists_ReturnsPathAlreadyExists()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, SaveDataFlags.None));
Assert.Result(ResultFs.PathAlreadyExists, fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, SaveDataFlags.None));
}
public void MountSdCard_CanWriteToFsAfterMounted()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
fs.MountSdCard("sdcard".ToU8String());
Assert.Success(fs.CreateFile("sdcard:/file".ToU8Span(), 100, CreateFileOptions.None));
}
public void CreateBcatSaveData_AlreadyExists_ReturnsPathAlreadyExists()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateBcatSaveData(applicationId, 0x400000));
Assert.Result(ResultFs.PathAlreadyExists, fs.CreateBcatSaveData(applicationId, 0x400000));
}
public void MountBcatSaveData_SaveExists_ReturnsSuccess()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateBcatSaveData(applicationId, 0x400000));
Assert.Success(fs.MountBcatSaveData("bcat_test".ToU8Span(), applicationId));
}
public void MountCacheStorage_CanMountCreatedCacheStorage()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, SaveDataFlags.None);
Assert.Success(fs.MountCacheStorage("cache".ToU8Span(), applicationId));
}
public void SetSdCardAccessibility_SetAccessibilityPersists()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(false);
fs.SetSdCardAccessibility(true);
Assert.True(fs.IsSdCardAccessible());
fs.SetSdCardAccessibility(false);
Assert.False(fs.IsSdCardAccessible());
}
public void Commit_MultipleFileSystems_AllFileSystemsAreCommitted()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
var saveInfo = new List <(int id, string name)>
{
(1, "Save1"),
(3, "Save2"),
(2, "Save3")
};
foreach ((int id, string name)info in saveInfo)
{
var applicationId = new Ncm.ApplicationId((uint)info.id);
fs.CreateSaveData(applicationId, UserId.InvalidId, 0, 0x4000, 0x4000, SaveDataFlags.None);
fs.MountSaveData(info.name.ToU8Span(), applicationId, UserId.InvalidId);
}
foreach ((int id, string name)info in saveInfo)
{
fs.CreateFile($"{info.name}:/file{info.id}".ToU8Span(), 0);
}
var names = new List <U8String>();
foreach ((int id, string name)info in saveInfo)
{
names.Add(info.name.ToU8String());
}
Assert.Success(fs.Commit(names.ToArray()));
foreach ((int id, string name)info in saveInfo)
{
fs.Unmount(info.name.ToU8Span());
}
foreach ((int id, string name)info in saveInfo)
{
var applicationId = new Ncm.ApplicationId((uint)info.id);
fs.MountSaveData(info.name.ToU8Span(), applicationId, UserId.InvalidId);
}
foreach ((int id, string name)info in saveInfo)
{
Assert.Success(fs.GetEntryType(out _, $"{info.name}:/file{info.id}".ToU8Span()));
}
}
public void CreateCacheStorage_InSdCacheSaveSpace_StorageIsCreated()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.SdCache, applicationId.Value, 0, 0, SaveDataFlags.None));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.SdCache);
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
}
public void MountCacheStorage_WrittenDataPersists()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
fs.CreateCacheStorage(applicationId, SaveDataSpaceId.SdCache, applicationId.Value, 0, 0, SaveDataFlags.None);
fs.MountCacheStorage("cache".ToU8Span(), applicationId);
fs.CreateFile("cache:/file".ToU8Span(), 0);
fs.Commit("cache".ToU8Span());
fs.Unmount("cache".ToU8Span());
Assert.Success(fs.MountCacheStorage("cache".ToU8Span(), applicationId));
Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "cache:/file".ToU8Span()));
Assert.Equal(DirectoryEntryType.File, type);
}
public void CreateBcatSaveData_DoesNotExist_SaveIsCreated()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateBcatSaveData(applicationId, 0x400000));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(SaveDataType.Bcat, info[0].Type);
}
public void MountBcatSaveData_WrittenDataPersists()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateBcatSaveData(applicationId, 0x400000));
Assert.Success(fs.MountBcatSaveData("bcat_test".ToU8Span(), applicationId));
// Check that the path doesn't exist
Assert.Result(ResultFs.PathNotFound, fs.GetEntryType(out _, "bcat_test:/file".ToU8Span()));
fs.CreateFile("bcat_test:/file".ToU8Span(), 0);
fs.Commit("bcat_test".ToU8Span());
fs.Unmount("bcat_test".ToU8Span());
Assert.Success(fs.MountBcatSaveData("bcat_test".ToU8Span(), applicationId));
Assert.Success(fs.GetEntryType(out DirectoryEntryType type, "bcat_test:/file".ToU8Span()));
Assert.Equal(DirectoryEntryType.File, type);
}
public void OpenSaveDataIterator_MultipleSavesExist_IteratorReturnsSavesInOrder()
{
const int count = 20;
const int rngSeed = 359;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(PopulateSaveData(fs, count, rngSeed));
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo();
for (int i = 0; i < count; i++)
{
Assert.Success(iterator.ReadSaveDataInfo(out long readCount, SpanHelpers.AsSpan(ref info)));
Assert.Equal(1, readCount);
Assert.Equal((ulong)i, info.ProgramId.Value);
}
}
public void CreateSystemSaveData_HasBuiltInSystemPermission_SaveIsCreatedInSystem(AccessControlBits.Bits permissions)
{
ulong saveId = 0x8000000001234000;
Horizon hos = FileSystemServerFactory.CreateHorizonServer();
var mainProgramId = new ProgramId(0x123456);
HorizonClient client = hos.CreateHorizonClient(new ProgramLocation(mainProgramId, StorageId.BuiltInSystem),
permissions);
HorizonClient privilegedClient = hos.CreatePrivilegedHorizonClient();
// Create the save
if (permissions.HasFlag(AccessControlBits.Bits.SystemSaveData))
{
Assert.Success(client.Fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
}
else
{
// Creation should fail if we don't have the right permissions.
Assert.Failure(client.Fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
return;
}
// Make sure it was placed in the System save space with the right info.
Assert.Success(privilegedClient.Fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.System));
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(SaveDataType.System, info[0].Type);
Assert.Equal(SaveDataSpaceId.System, info[0].SpaceId);
Assert.Equal(saveId, info[0].StaticSaveDataId);
Assert.Equal(saveId, info[0].SaveDataId);
Assert.Equal(SaveDataState.Normal, info[0].State);
}
public void CreateCacheStorage_WithIndex_CreatesMultiple()
{
var applicationId = new Ncm.ApplicationId(1);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 0, 0, 0, SaveDataFlags.None));
Assert.Success(fs.CreateCacheStorage(applicationId, SaveDataSpaceId.User, applicationId.Value, 1, 0, 0, SaveDataFlags.None));
fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User);
var info = new SaveDataInfo[3];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(2, entriesRead);
Assert.Equal(applicationId, info[0].ProgramId);
Assert.Equal(applicationId, info[1].ProgramId);
ushort[] expectedIndexes = { 0, 1 };
ushort[] actualIndexes = info.Take(2).Select(x => x.Index).OrderBy(x => x).ToArray();
Assert.Equal(expectedIndexes, actualIndexes);
}
public void CreateSystemSaveData_DoesNotExist_SaveIsCreatedInSystem()
{
ulong saveId = 0x8000000001234000;
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSystemSaveData(saveId, 0x1000, 0x1000, SaveDataFlags.None));
// Make sure it was placed in the System save space with the right info.
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.System));
var info = new SaveDataInfo[2];
Assert.Success(iterator.ReadSaveDataInfo(out long entriesRead, info));
Assert.Equal(1, entriesRead);
Assert.Equal(SaveDataType.System, info[0].Type);
Assert.Equal(SaveDataSpaceId.System, info[0].SpaceId);
Assert.Equal(saveId, info[0].StaticSaveDataId);
Assert.Equal(saveId, info[0].SaveDataId);
Assert.Equal(SaveDataState.Normal, info[0].State);
}
public void CreateSaveData_DoesNotExist_HasCorrectOwnerId()
{
uint ownerId = 1;
var applicationId = new Ncm.ApplicationId(ownerId);
var userId = new UserId(5, 4);
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
// Create the save
Assert.Success(fs.CreateSaveData(applicationId, userId, ownerId, 0x1000, 0x1000, SaveDataFlags.None));
// Get the created save data's ID
Assert.Success(fs.OpenSaveDataIterator(out SaveDataIterator iterator, SaveDataSpaceId.User));
var info = new SaveDataInfo[2];
iterator.ReadSaveDataInfo(out long entriesRead, info);
Assert.Equal(1, entriesRead);
// Get the created save data's owner ID
Assert.Success(fs.GetSaveDataOwnerId(out ulong actualOwnerId, info[0].SaveDataId));
public void IsSdCardAccessible_CardIsNotInserted_ReturnsFalse()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(false);
Assert.False(fs.IsSdCardAccessible());
}
public void IsSdCardAccessible_CardIsInserted_ReturnsTrue()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.True(fs.IsSdCardAccessible());
}
public void MountSdCard_CardIsNotInserted_Fails()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(false);
Assert.Result(ResultFs.SdCardNotFound, fs.MountSdCard("sdcard".ToU8Span()));
}
public void MountSdCard_CardIsInserted_Succeeds()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Success(fs.MountSdCard("sdcard".ToU8Span()));
}
public void DeleteSaveData_DoesNotExist_ReturnsTargetNotFound()
{
FileSystemClient fs = FileSystemServerFactory.CreateClient(true);
Assert.Result(ResultFs.TargetNotFound, fs.DeleteSaveData(1));
}
