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