private MemoryList getMemoryList() { MemoryList memories; if (File.Exists(pathAndFileName)) { using (TextReader r = new StreamReader(pathAndFileName)) { try { XmlSerializer s = new XmlSerializer(typeof(MemoryList)); memories = (MemoryList)s.Deserialize(r); } finally { r.Close(); } } } else { memories = new MemoryList(); setMemoryList(memories); } return(memories); }
public void Setup(MemoryList memoryList, DialogDisplay dialogBox) { this.memoryList = memoryList; this.dialogBox = dialogBox; if (canMove) { throw new System.Exception("player is allowed to move around before Setup is called"); } memoryList.onMemoryLost += (_1, _2) => { if (finishedTips) { return; } canMove = false; finishedTips = true; StartCoroutine(dialogBox.DisplayText(new string[] { "(I feel like I haven just forgotten something)", "(Damn it, this headache just won't go way!)", "<Due to the condition, you can only remember the last 10 topics>" }, () => { canMove = true; })); }; }
/// <summary> /// 异步获取实例 /// </summary> /// <returns></returns> public static async Task <MemoryListViewModel> GetInstanceAsync() { if (_uniqueInstance != null) { return(_uniqueInstance); } lock (Locker) { // 如果类的实例不存在则创建,否则直接返回 if (_uniqueInstance == null) { // ReSharper disable once PossibleMultipleWriteAccessInDoubleCheckLocking _uniqueInstance = new MemoryListViewModel(); } } _uniqueInstance._memoryList = await MemoryList.GetInstanceAsync(); foreach (var memoryModel in _uniqueInstance._memoryList.MemoryModels) { var memoryViewModel = await MemoryViewModel.GetInstanceAsync(memoryModel); _uniqueInstance.MemoryViewModels.Add(memoryViewModel); } return(_uniqueInstance); }
public void MemoryList_isNotEmpty() { MemoryList <string> l = new MemoryList <string>(); l.StoreValue("V"); Assert.True(l.HasValues()); }
public void AddedItemsShouldBeContained(int value) { var list = new MemoryList <int>(); list.Add(value); Assert.True(list.Contains(value)); }
public void TryParseInt32Multisegment(int expected) { byte[] array = new byte[32]; Utf8Formatter.TryFormat(expected, array, out var written); array[written] = (byte)'#'; var memory = new Memory <byte>(array, 0, written + 1); for (int pivot = 0; pivot < written; pivot++) { var front = memory.Slice(0, pivot); var back = memory.Slice(pivot); var first = new MemoryList(front); var last = first.Append(back); var bytes = new ReadOnlyBytes(first, last); Assert.True(Sequence.TryParse(bytes, out int value, out int consumed)); Assert.Equal(expected, value); Assert.True(Sequence.TryParse(bytes, out value, out Position consumedPosition)); Assert.Equal(expected, value); var afterValue = bytes.Slice(consumedPosition); Assert.Equal((byte)'#', afterValue.Memory.Span[0]); } }
public void ValidInputOnlyMultiByte() { Span <byte> inputSpan = new byte[1000]; Base64TestHelper.InitalizeDecodableBytes(inputSpan); int requiredLength = Base64.GetMaxDecodedFromUtf8Length(inputSpan.Length); Span <byte> expected = new byte[requiredLength]; Assert.Equal(OperationStatus.Done, Base64.DecodeFromUtf8(inputSpan, expected, out int bytesConsumed, out int bytesWritten)); byte[][] input = new byte[10][]; int[] split = { 100, 102, 98, 101, 2, 97, 101, 1, 2, 396 }; int sum = 0; for (int i = 0; i < split.Length; i++) { int splitter = split[i]; input[i] = inputSpan.Slice(sum, splitter).ToArray(); sum += splitter; } Assert.Equal(1000, sum); var(list, lenght) = MemoryList.Create(input); var output = new TestOutput(); Base64Experimental.Utf8ToBytesDecoder.Pipe(new ReadOnlyBytes(list, lenght), output); var expectedArray = expected.ToArray(); var array = output.GetBuffer.ToArray(); Assert.True(expected.SequenceEqual(output.GetBuffer.Slice(0, requiredLength))); }
public void NewListShouldNotHaveContainedAnything(string item) { var sut = new MemoryList <string>(); var contained = sut.HasEverContained(item); Assert.False(contained); }
public void TimestampCheck() { var mlTest = new MemoryList(0); var ts = mlTest.Timestamp; mlTest[0] = 1; Assert.Greater(mlTest.Timestamp, ts); }
public void CheckModified() { var mlTest = new MemoryList(0); Assert.IsFalse(mlTest.Modified); mlTest[0] = 1; Assert.IsTrue(mlTest.Modified); }
public void HasContainedShouldBeFalseForHasNotContained() { var list = new MemoryList <int>(); var result = HasContained(10); Assert.False(result); }
public void AddedItemsAreContained(int val) { var list = new MemoryList <int>(); list.Add(val); Assert.True(list.Contains(val)); }
public void ContainIsTrue() { var list = new MemoryList <int>(); list.Add(7); Assert.True(list.Contains(7)); }
public void MemoryList_has1ItemAfter2AddsCaseInsensitve() { MemoryList <string> l = new MemoryList <string>("MyListName", true, true); l.StoreValue("Giraffe"); l.StoreValue("giraffe"); Assert.True(l.UnconsumedCount() == 1); }
public void MemoryList_has2ItemsAfter2AddsCaseSensitve() { MemoryList <string> l = new MemoryList <string>("MyListName", false, false); l.StoreValue("Giraffe"); l.StoreValue("giraffe"); Assert.That(l.UnconsumedCount() == 2); }
public void ContainIsFalse() { var list = new MemoryList <int>(); list.Add(7); Assert.False(list.Contains(9)); }
public void ContainsShouldBeFalse() { var Memory = new MemoryList(); var result = Memory.Contains("asdf"); Assert.False(result); }
public void ListWithSomeItemsAddedAndRemovedShouldNotHaveContainedOthers(string extra, params string[] items) { var sut = new MemoryList <string>(); sut.AddRange(items); sut.Remove(items[0]); Assert.False(sut.HasEverContained(extra)); }
public void MemoryList_isEmptyAfterItemRecall() { MemoryList <string> l = new MemoryList <string>(); l.StoreValue("V"); string v = l.RecallValue(); Assert.False(l.HasValues()); }
public static ReadOnlyBytes CreateRob(params byte[][] buffers) { if (buffers.Length == 1) { return(new ReadOnlyBytes(buffers[0])); } var(first, last) = MemoryList.Create(buffers); return(new ReadOnlyBytes(first, last)); }
public void RemovedItemsShouldNotBeContained() { var list = new MemoryList <int>(); list.Add(5); list.Remove(5); Assert.True(list.Contains(5)); }
public void OneItemAddedShouldHaveBeenContained(string item) { var sut = new MemoryList <string>(); sut.Add(item); var contained = sut.HasEverContained(item); Assert.True(contained); }
public void ListCanRemove() { var list = new MemoryList <int>(); list.Add(7); list.Remove(7); Assert.False(list.Contains(7)); }
public void MemoryList_isQueue() { MemoryList <string> l = new MemoryList <string>("MyListName", false, true, MemoryList <string> .MemoryListRetrieveSequence.Queue); l.StoreValue("Dog"); l.StoreValue("Cat"); string v = l.RecallValue(); Assert.That(v == "Dog"); }
public void MemoryList_has1ItemAfterStoreRecallStoreCaseInsensitve() { // this test uses the default settings for the class: unique = false,ignoreCase = true MemoryList <string> l = new MemoryList <string>(); l.StoreValue("Giraffe"); l.RecallValue(); l.StoreValue("giraffe"); Assert.That(l.UnconsumedCount() == 1); }
public void HasContainedShouldBeTrueForHasContained() { var list = new MemoryList <int>(); list.Add(8); var result = list.HasContained(8); Assert.True(result); }
public void ContainsShouldBeTrueForContained() { var list = new MemoryList <int>(); list.Add(6); var result = list.Contains(6); Assert.True(result); }
public void RemoveShouldTakeOutVariableIfAvailable(int value) { var memoryList = new MemoryList <int>(); memoryList.Add(5); memoryList.Add(1000); memoryList.Add(80); memoryList.Remove(value); Assert.DoesNotContain(value, memoryList); }
public void SequencePositionOfMultiSegment() { var(list, length) = MemoryList.Create( new byte[] { 1, 2 }, new byte[] { 3, 4 } ); var bytes = new ReadOnlyBytes(list, length); Assert.Equal(4, length); Assert.Equal(4, bytes.Length); // Static method call to avoid calling instance methods Assert.Equal(Position.End, Sequence.PositionOf(bytes, 0)); for (int i = 0; i < bytes.Length; i++) { var value = (byte)(i + 1); var listPosition = Sequence.PositionOf(list, value); var(node, index) = listPosition.Get <IMemoryList <byte> >(); if (!listPosition.IsEnd) { Assert.Equal(value, node.Memory.Span[index]); } var robPosition = bytes.PositionOf(value); var robSequencePosition = Sequence.PositionOf(bytes, value); Assert.Equal(listPosition, robPosition); Assert.Equal(listPosition, robSequencePosition); var robSlice = bytes.Slice(1); robPosition = robSlice.PositionOf(value); robSequencePosition = Sequence.PositionOf(robSlice, value); if (i > 0) { Assert.Equal(listPosition, robPosition); Assert.Equal(listPosition, robSequencePosition); } else { Assert.Equal(Position.End, robPosition); Assert.Equal(Position.End, robSequencePosition); } if (listPosition != Position.End) { robSlice = bytes.Slice(listPosition); Assert.Equal(value, robSlice.Memory.Span[0]); } } }
public void SeveralItemsAddRangedShouldHaveBeenContained(params string[] items) { var sut = new MemoryList <string>(); sut.AddRange(items); foreach (var item in items) { Assert.True(sut.HasEverContained(item)); } }