public void TestBackupSaveSlots()
{
const string nickName = nameof(TestBackupSaveSlots);
DeleteSaveFiles(nickName);
var newSave = new SaveDataTestImpl(nickName);
Assume.That(newSave.AllSaveFilePaths, Is.Empty);
for (int numberOfSaveFiles = 1; numberOfSaveFiles < SaveData.BackupSaveSlots * 2; numberOfSaveFiles++)
{
newSave.Save(false);
Log($"Created new save file:[{numberOfSaveFiles}] {newSave}");
Assert.That(newSave.AllSaveFilePaths.Length, Is.LessThanOrEqualTo(SaveData.BackupSaveSlots), $"There should never be more than {SaveData.BackupSaveSlots} save files!");
Assert.That(
newSave.AllSaveFilePaths.Length,
Is.EqualTo(
Math.Min(numberOfSaveFiles, SaveData.BackupSaveSlots)
),
$"Didn't find the correct number of saves!" +
$"\n\t{string.Join("\n\t", SaveDataTestImpl.GetAllSaveFilePaths(newSave.Nickname))}"
);
}
}
private static void _TestTrimSaveFiles(int trimTo)
{
Assume.That(trimTo, Is.LessThanOrEqualTo(DummySaveDates.Count));
MakeDummyFiles();
SaveDataTestImpl.TrimSaves(DummyNickName, trimTo);
Assert.That(GetExistingSaveFiles().Count, Is.EqualTo(trimTo), "The incorrect number of files remained after trimming!");
}
public IEnumerator SaveTimeUnaffectedByLoading()
{
DateTime beforeNewSave = DateTime.Now;
yield return(null);
var saveData = SaveDataTestImpl.NewSaveFile(nameof(SaveTimeUnaffectedByLoading));
DateTime afterNewSave = DateTime.Now;
AssertAll.Of(
() => Assert.That(saveData.LastSaveTime, Is.InRange(beforeNewSave, afterNewSave)),
() => Assert.That(saveData.LastLoadTime, Is.Null)
);
var oldSaveTime = saveData.LastSaveTime;
var oldLoadTime = saveData.LastLoadTime;
yield return(new WaitForSecondsRealtime(1));
DateTime beforeReload = DateTime.Now;
yield return(null);
saveData.Reload();
DateTime afterReload = DateTime.Now;
AssertAll.Of(
() => Assert.That(saveData.LastSaveTime, Is.EqualTo(oldSaveTime), $"The {nameof(SaveDataTestImpl.LastSaveTime)} should not have changed, because we {nameof(SaveDataTestImpl.Reload)}-ed without {nameof(SaveDataTestImpl.Save)}-ing!"),
() => Assert.That(saveData.LastLoadTime, Is.Not.EqualTo(oldLoadTime), $"The {nameof(SaveDataTestImpl.LastLoadTime)} should have changed, because we {nameof(SaveDataTestImpl.Reload)}-ed!"),
() => Assert.That(saveData.LastLoadTime, Is.InRange(beforeReload, afterReload))
);
}
public void TestParseAutoSaveName()
{
foreach (var saveDate in DummySaveDates)
{
Assert.AreEqual(saveDate.Value, SaveDataTestImpl.GetSaveDate(saveDate.Key));
}
}
public void TestGetNickname()
{
foreach (var saveDate in DummySaveDates)
{
Assert.AreEqual(SaveDataTestImpl.GetNickname(saveDate.Key), DummyNickName);
}
}
public IEnumerator LoadTimeUnaffectedBySaving()
{
var beforeNewSave = DateTime.Now;
yield return(null);
var saveData = SaveDataTestImpl.NewSaveFile(nameof(LoadTimeUnaffectedBySaving));
var afterNewSave = DateTime.Now;
AssertAll.Of(
() => Assert.That(saveData.LastSaveTime, Is.InRange(beforeNewSave, afterNewSave)),
() => Assert.That(saveData.LastLoadTime, Is.Null)
);
var oldSaveTime = saveData.LastSaveTime;
var oldLoadTime = saveData.LastLoadTime;
yield return(new WaitForSecondsRealtime(1));
var beforeReSave = DateTime.Now;
yield return(null);
saveData.Save(false);
var afterReSave = DateTime.Now;
AssertAll.Of(
() => Assert.That(saveData.LastSaveTime, Is.InRange(beforeReSave, afterReSave)),
() => Assert.That(saveData.LastSaveTime, Is.Not.EqualTo(oldSaveTime)),
() => Assert.That(saveData.LastLoadTime, Is.EqualTo(oldLoadTime))
);
}
public void TestGenerateAutoSaveName()
{
foreach (var saveDate in DummySaveDates)
{
Log("Parsed to: " + SaveDataTestImpl.GetSaveFileNameWithDate(DummyNickName, saveDate.Value));
Assert.AreEqual(saveDate.Key, SaveDataTestImpl.GetSaveFileNameWithDate(DummyNickName, saveDate.Value));
}
}
public void LoadingMissingNickNameThrowsSaveDataException()
{
const string nickName = nameof(LoadingMissingNickNameThrowsSaveDataException);
Assume.That(SaveDataTestImpl.GetAllSaveFilePaths(nickName), Is.Empty, $"Save files with the nickname {nickName} were found - please delete them, then run this test again.");
Assert.Throws <SaveDataException>(() => SaveDataTestImpl.Load(nickName));
}
public void TestToStringMatchesToJson()
{
var newSave = SaveDataTestImpl.NewSaveFile(MethodBase.GetCurrentMethod().Name);
var saveJson = newSave.ToJson();
var saveString = newSave.ToString();
Assert.That(saveString, Is.EqualTo(saveJson));
}
public void TestSaveFilePathsAreSortedChronologically()
{
var loadedSaves = SaveDataTestImpl.GetAllSaveFilePaths(DummyNickName);
AssertAll.Of(
() => Assert.AreNotEqual(0, loadedSaves.Length, "No saves were actually loaded!"),
() => Assert.AreEqual(DummySaveFiles, loadedSaves)
);
}
public void EmptyObjectIsCorrect()
{
var saveData = new SaveDataTestImpl(nameof(EmptyObjectIsCorrect));
var emptySave = SaveDataTestImpl.EmptySaveData.Value;
AssertAll.Of(
() => Assert.That(emptySave.Word, Is.EqualTo(saveData.Word)),
() => Assert.That(emptySave.Word2, Is.EqualTo(saveData.Word2)),
() => Assert.That(emptySave, Has.Property(nameof(emptySave.LastLoadTime)).Null)
);
}
public void TestIgnoreReSaveDelay()
{
SaveDataTestImpl saveDataTestImpl = new SaveDataTestImpl(nameof(TestIgnoreReSaveDelay));
for (int i = 0; i < 5; i++)
{
try {
saveDataTestImpl.Save(false);
}
catch (ReSaveDelayException e) {
throw new AssertionException($"When useReSaveDelay is FALSE, we shouldn't throw a {nameof(ReSaveDelayException)}, but we threw {e.Message}!", e);
}
}
}
public void TestUseReSaveDelay()
{
SaveDataTestImpl saveDataTestImpl = SaveDataTestImpl.NewSaveFile(nameof(TestUseReSaveDelay));
var message = $"{nameof(ReSaveDelayException)} when saved again within the {nameof(SaveData.ReSaveDelay)} ({SaveData.ReSaveDelay})!";
try {
saveDataTestImpl.Save(true);
}
catch (ReSaveDelayException e) {
Assert.Pass($"Properly threw a {message}\nException: {e.Message}");
}
Assert.Fail($"Did NOT throw a {message}");
}
public void ResetSaveData()
{
var saveData = new SaveDataTestImpl(nameof(ResetSaveData));
var word_default = saveData.Word;
var word2_default = saveData.Word2;
saveData.Word += "_EDIT";
saveData.Word2 += "_EDIT";
saveData.Reset();
AssertAll.Of(
() => Assert.That(saveData.Word, Is.EqualTo(word_default)),
() => Assert.That(saveData.Word2, Is.EqualTo(word2_default)),
() => Assert.That(saveData, Has.Property(nameof(saveData.LastLoadTime)).Null)
);
}
public void ReloadingMissingSavePathThrowsSaveDataException()
{
const string nickName = nameof(ReloadingMissingSavePathThrowsSaveDataException);
var saveData = new SaveDataTestImpl(nickName);
Assume.That(
saveData.Exists,
Is.False,
$"{nameof(saveData)} (with the {nameof(saveData.Nickname)} {saveData.Nickname}) .{nameof(saveData.Exists)} should be FALSE!"
);
Assume.That(
SaveDataTestImpl.GetAllSaveFilePaths(nickName),
Is.Empty,
$"Save files with the nickname {nickName} were found - please delete them, then run this test again."
);
Assume.That(saveData.AllSaveFilePaths, Is.Empty);
Assert.Throws <SaveDataException>(() => saveData.Reload());
}
public IEnumerator TestLoadMostRecentSaveFile()
{
//save a few files
const int saveCount = 3;
const string nickName = nameof(TestLoadMostRecentSaveFile);
//create a new save file with the desired nickname
SaveDataTestImpl saveData = SaveDataTestImpl.NewSaveFile(nickName);
for (int i = 0; i < saveCount; i++)
{
if (i != 0)
{
Log($"Waiting {SaveData.ReSaveDelay} before continuing...");
}
//add a unique value into the save data
saveData.Word = $"SAVE_{i}";
//re-save the save data
yield return(new WaitForSecondsRealtime(0.1f));
saveData.Save(false);
Log($"Saved {nickName} #{i}:\n{saveData}");
AssertAll.Of(
//Assert that the timestamp in the filename matches the lastSaveTime
() => Assert.That(saveData, Has.Property(nameof(saveData.LastSaveTime_Exact)).Not.Null),
() => Assert.That(
saveData.LastSaveTime_Exact?.Ticks,
Is.EqualTo(SaveDataTestImpl.GetSaveDate(saveData.LatestSaveFilePath).Ticks),
$"Incorrect timestamp pulled from path {saveData.LatestSaveFilePath}"
),
//load the save data and check the unique value
() => Assert.That(SaveDataTestImpl.Load(nickName).Word, Is.EqualTo(saveData.Word))
);
}
}
public void LoadMostRecentFromInstance()
{
var saveData = SaveDataTestImpl.NewSaveFile(nameof(LoadMostRecentFromInstance));
var firstEdit = "First Edit";
saveData.Word = firstEdit;
saveData.Save(false);
var saveData2 = SaveDataTestImpl.NewSaveFile(saveData.Nickname);
var secondEdit = "Second Edit";
saveData2.Word = secondEdit;
saveData2.Save(false);
Assert.That(saveData.Word, Is.EqualTo(firstEdit));
Assert.That(saveData, Is.Not.SameAs(saveData2));
var loadedSave = saveData.Reload();
Assert.That(loadedSave, Is.SameAs(saveData));
Assert.That(saveData.Word, Is.Not.EqualTo(firstEdit));
Assert.That(saveData.Word, Is.EqualTo(secondEdit));
}
public void LoadingInvalidContentByNicknameThrowsSaveDataException()
{
Assert.Throws <SaveDataException>(() => SaveDataTestImpl.Load(DummyNickName));
}
public void LoadingInvalidJsonContentByPathThrowsSaveDataException()
{
Assert.Throws <SaveDataException>(() => SaveDataTestImpl.LoadByPath(DummySaveFiles[0]));
}
