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