public void CircularBufferTestConstructors()
{
var array = new long[5];
for (int i = 0; i < 5; i++)
{
array[i] = i + 10;
}
var buffer = new CircularBuffer <long>(15, array, 5);
Assert.AreEqual(10, buffer.Back());
Assert.AreEqual(14, buffer.Front());
Assert.AreEqual(5, buffer.Count);
Assert.AreEqual(15, buffer.Capacity);
Assert.AreEqual(false, buffer.IsEmpty);
}
public void CircularBufferTestEnumerationWhenPartiallyFull()
{
var buffer = new CircularBuffer <long>(3);
buffer.PushFront(1);
buffer.PushBack(0);
var i = 0;
foreach (var item in buffer)
{
Assert.AreEqual(i++, item);
}
Assert.AreEqual(i, 2);
Assert.AreEqual(buffer.Count, 2);
Assert.AreEqual(buffer.Capacity, 3);
}
public void CircularBufferTestBackOverwrite()
{
var buffer = new CircularBuffer <long>(3);
for (int i = 0; i < 5; i++)
{
buffer.PushBack(i);
}
Assert.AreEqual(4, buffer[0]);
Assert.AreEqual(3, buffer[1]);
Assert.AreEqual(2, buffer[2]);
Assert.AreEqual(2, buffer.Front());
Assert.AreEqual(4, buffer.Back());
Assert.AreEqual(buffer.Count, 3);
Assert.AreEqual(buffer.Capacity, 3);
}
public void UndoTestArray()
{
var undo = new Undo();
var instance = new UndoObjectArray
{
MyInts = new[] { 1, 2, 3, 4, 5 },
MyIntsProp = new[] { 1, 2, 3, 4, 5 },
};
using (new UndoBlock(undo, instance, "Edit"))
{
instance.MyInts[0] = 11;
instance.MyInts[1] = 12;
instance.MyInts[2] = 13;
instance.MyInts[3] = 14;
instance.MyInts[4] = 15;
instance.MyIntsProp[1] = 500;
}
undo.PerformUndo();
Assert.AreEqual(5, instance.MyInts.Length);
Assert.AreEqual(1, instance.MyInts[0]);
Assert.AreEqual(2, instance.MyInts[1]);
Assert.AreEqual(3, instance.MyInts[2]);
Assert.AreEqual(4, instance.MyInts[3]);
Assert.AreEqual(5, instance.MyInts[4]);
Assert.AreEqual(5, instance.MyIntsProp.Length);
Assert.AreEqual(1, instance.MyIntsProp[0]);
Assert.AreEqual(2, instance.MyIntsProp[1]);
Assert.AreEqual(3, instance.MyIntsProp[2]);
Assert.AreEqual(4, instance.MyIntsProp[3]);
Assert.AreEqual(5, instance.MyIntsProp[4]);
undo.PerformRedo();
Assert.AreEqual(5, instance.MyInts.Length);
Assert.AreEqual(11, instance.MyInts[0]);
Assert.AreEqual(12, instance.MyInts[1]);
Assert.AreEqual(13, instance.MyInts[2]);
Assert.AreEqual(14, instance.MyInts[3]);
Assert.AreEqual(15, instance.MyInts[4]);
Assert.AreEqual(5, instance.MyIntsProp.Length);
Assert.AreEqual(1, instance.MyIntsProp[0]);
Assert.AreEqual(500, instance.MyIntsProp[1]);
Assert.AreEqual(3, instance.MyIntsProp[2]);
Assert.AreEqual(4, instance.MyIntsProp[3]);
Assert.AreEqual(5, instance.MyIntsProp[4]);
}
public void HistoryStackTestBasic()
{
var stack = new HistoryStack(50);
for (int i = 0; i < 80; i++)
{
stack.Push(new HistoryTestObject(i));
}
for (int i = 80 - 1; i >= 80 - 50; i--)
{
Assert.AreEqual(i, (int)(HistoryTestObject)stack.PopHistory());
Assert.AreEqual(i, (int)(HistoryTestObject)stack.PeekReverse());
}
for (int i = 80 - 50; i < 80; i++)
{
Assert.AreEqual(i, (int)(HistoryTestObject)stack.PopReverse());
Assert.AreEqual(i, (int)(HistoryTestObject)stack.PeekHistory());
}
}
public void UndoTestRecursive2()
{
var undo = new Undo();
var instance = new UndoObject(true)
{
FieldObject =
{
FieldObject = new UndoObject(false),
PropertyObject = new UndoObject(false)
},
PropertyObject =
{
FieldObject = new UndoObject(false),
PropertyObject = new UndoObject(false)
}
};
using (new UndoBlock(undo, instance, "Edit"))
{
instance.FieldInteger = 1;
instance.FieldObject.FieldInteger = 10;
instance.PropertyObject.FieldInteger = 11;
instance.FieldObject.FieldObject.FieldInteger = 22;
instance.FieldObject.PropertyObject.FieldInteger = 23;
instance.PropertyObject.FieldObject.FieldInteger = 24;
instance.PropertyObject.PropertyObject.FieldInteger = 25;
}
undo.PerformUndo();
Assert.AreEqual(10, instance.FieldInteger);
Assert.AreEqual(1, instance.FieldObject.FieldInteger);
Assert.AreEqual(-1, instance.PropertyObject.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.FieldObject.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(10, instance.PropertyObject.FieldObject.FieldInteger);
Assert.AreEqual(10, instance.PropertyObject.PropertyObject.FieldInteger);
undo.PerformRedo();
Assert.AreEqual(1, instance.FieldInteger);
Assert.AreEqual(10, instance.FieldObject.FieldInteger);
Assert.AreEqual(11, instance.PropertyObject.FieldInteger);
Assert.AreEqual(22, instance.FieldObject.FieldObject.FieldInteger);
Assert.AreEqual(23, instance.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(24, instance.PropertyObject.FieldObject.FieldInteger);
Assert.AreEqual(25, instance.PropertyObject.PropertyObject.FieldInteger);
}
private static void BasicUndoRedo(Undo undo, UndoObject instance)
{
Assert.AreEqual("Basic", undo.FirstUndoName);
undo.PerformUndo();
Assert.AreEqual(10, instance.FieldInteger);
Assert.AreEqual(0.1f, instance.FieldFloat);
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreEqual(-10, instance.PropertyInteger);
Assert.AreEqual(-0.1f, instance.PropertyFloat);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreEqual("Basic", undo.FirstRedoName);
undo.PerformRedo();
Assert.AreEqual(0, instance.FieldInteger);
Assert.AreEqual(0, instance.FieldFloat);
Assert.AreEqual(null, instance.FieldObject);
Assert.AreEqual(0, instance.PropertyInteger);
Assert.AreEqual(0, instance.PropertyFloat);
Assert.AreEqual(null, instance.PropertyObject);
}
public void CircularBufferTestEnumerationWhenPartiallyFullLarge()
{
var buffer = new CircularBuffer <long>(20000);
int i = 0;
for (i = 0; i < 10000; i++)
{
buffer.PushFront(i);
}
i = 0;
foreach (var value in buffer)
{
Assert.AreEqual(i++, value);
}
Assert.AreEqual(i, 10000);
Assert.AreEqual(buffer.Count, 10000);
Assert.AreEqual(buffer.Capacity, 20000);
}
public void CircularBufferTestFrontAndBack()
{
var rand = new Random();
var buffer = new CircularBuffer <long>(3);
for (int i = 0; i < 25; i++)
{
var cur = rand.Next();
buffer.PushFront(cur);
Assert.AreEqual(cur, buffer.Front());
buffer.PopFront();
}
for (int i = 0; i < 25; i++)
{
var cur = rand.Next();
buffer.PushBack(cur);
Assert.AreEqual(cur, buffer.Back());
buffer.PopBack();
}
}
public void CircularBufferTestExceptions()
{
Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer <long>(0); });
Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { new CircularBuffer <long>(-5); });
var buffer = new CircularBuffer <long>(1);
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Front(); });
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.Back(); });
Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () =>
{
var test = buffer[-1];
});
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
{
var test = buffer[1];
});
Assert.ExceptionExpected(typeof(ArgumentOutOfRangeException), () => { buffer[-1] = 0; });
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer[1] = 0; });
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopBack(); });
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () => { buffer.PopFront(); });
}
public void CircularBufferTestMultipleIterations()
{
var buffer = new CircularBuffer <long>(50);
for (int i = 0; i < 80; i++)
{
buffer.PushFront(i);
}
for (int i = 0; i < 50; i++)
{
Assert.AreEqual(79 - i, buffer.PopFront());
}
for (int i = 0; i < 20; i++)
{
buffer.PushFront(i);
}
for (int i = 0; i < 20; i++)
{
Assert.AreEqual(i, buffer[i]);
}
}
public void HistoryStackTestTravel()
{
var stack = new HistoryStack(50);
for (int i = 0; i < 80; i++)
{
stack.Push(new HistoryTestObject(i));
}
Assert.AreEqual(0, stack.ReverseCount);
Assert.AreEqual(60, (int)(HistoryTestObject)stack.TravelBack(20));
Assert.AreEqual(20, stack.ReverseCount);
Assert.AreEqual(30, stack.HistoryCount);
Assert.AreEqual(74, (int)(HistoryTestObject)stack.TravelReverse(15));
Assert.AreEqual(5, stack.ReverseCount);
Assert.AreEqual(45, stack.HistoryCount);
Assert.AreEqual(79, (int)(HistoryTestObject)stack.TravelReverse(5));
Assert.AreEqual(0, stack.ReverseCount);
Assert.AreEqual(50, stack.HistoryCount);
Assert.AreEqual(30, (int)(HistoryTestObject)stack.TravelBack(50));
Assert.AreEqual(50, stack.ReverseCount);
Assert.AreEqual(0, stack.HistoryCount);
}
public void UndoTestRecursive()
{
var undo = new Undo();
var instance = new UndoObject(true);
undo.RecordAction(instance, "Basic", (i) =>
{
i.FieldObject = new UndoObject();
i.FieldObject.FieldObject = new UndoObject();
i.FieldObject.FieldObject.FieldObject = new UndoObject();
i.FieldObject.FieldObject.PropertyObject = new UndoObject();
i.FieldObject.FieldObject.PropertyObject.FieldInteger = 99;
i.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject.PropertyObject = new UndoObject();
i.PropertyObject.PropertyObject.FieldObject = new UndoObject();
i.PropertyObject.PropertyObject.FieldObject.FieldInteger = 99;
});
undo.PerformUndo();
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject);
Assert.AreEqual(null, instance.FieldObject.FieldObject.FieldObject);
Assert.AreEqual(null, instance.FieldObject.FieldObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject);
Assert.AreEqual(null, instance.PropertyObject.PropertyObject.PropertyObject);
Assert.AreEqual(null, instance.PropertyObject.PropertyObject.FieldObject);
undo.PerformRedo();
Assert.AreNotEqual(null, instance.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject.FieldObject);
Assert.AreNotEqual(null, instance.FieldObject.FieldObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject.PropertyObject);
Assert.AreNotEqual(null, instance.PropertyObject.PropertyObject.FieldObject);
Assert.AreEqual(99, instance.FieldObject.FieldObject.PropertyObject.FieldInteger);
Assert.AreEqual(99, instance.PropertyObject.PropertyObject.FieldObject.FieldInteger);
}
public void CircularBufferTestMixedUnderwrite()
{
var buffer = new CircularBuffer <long>(5);
buffer.PushFront(0);
buffer.PushFront(1);
buffer.PushBack(-1);
Assert.AreEqual(1, buffer.Front());
Assert.AreEqual(-1, buffer.Back());
buffer.PushFront(2);
Assert.AreEqual(2, buffer.Front());
Assert.AreEqual(-1, buffer.Back());
buffer.PopBack();
Assert.AreEqual(0, buffer.Back());
Assert.AreEqual(2, buffer.Front());
buffer.PushBack(-2);
Assert.AreEqual(2, buffer.Front());
Assert.AreEqual(-2, buffer.Back());
Assert.AreEqual(-2, buffer[0]);
Assert.AreEqual(0, buffer[1]);
Assert.AreEqual(1, buffer[2]);
Assert.AreEqual(2, buffer[3]);
Assert.ExceptionExpected(typeof(IndexOutOfRangeException), () =>
{
var test = buffer[4];
});
Assert.AreEqual(buffer.Count, 4);
Assert.AreEqual(buffer.Capacity, 5);
}
public void CircularBufferTestCopyToArray()
{
var buffer = new CircularBuffer <long>(3);
for (int i = 0; i < 5; i++)
{
buffer.PushFront(i);
}
var testArray = buffer.ToArray();
Assert.AreEqual(2, testArray[0]);
Assert.AreEqual(3, testArray[1]);
Assert.AreEqual(4, testArray[2]);
testArray = new long[3];
buffer.CopyTo(testArray, 0);
Assert.AreEqual(2, testArray[0]);
Assert.AreEqual(3, testArray[1]);
Assert.AreEqual(4, testArray[2]);
testArray = new long[5];
buffer.CopyTo(testArray, 2);
Assert.AreEqual(2, testArray[2]);
}
public void UndoTestRecursiveArray()
{
var undo = new Undo();
var instance = new UndoObjectWithArray
{
FieldArray = new[]
{
new UndoObjectWithArray
{
FieldInteger = 33,
PropertyFloat = 3.3f,
FieldArray = new UndoObjectWithArray[1]
{
new UndoObjectWithArray
{
FieldFloat = 1000.0f
},
},
PropertyArray = new UndoObjectWithArray[1]
{
new UndoObjectWithArray
{
FieldFloat = 1000.0f
},
}
},
new UndoObjectWithArray
{
FieldInteger = 34,
PropertyFloat = 3.4f,
FieldArray = new UndoObjectWithArray[0]
},
},
PropertyArray = new[]
{
new UndoObjectWithArray
{
FieldInteger = 33,
PropertyFloat = 3.3f,
FieldArray = new UndoObjectWithArray[1]
{
new UndoObjectWithArray
{
FieldFloat = 1000.0f
},
},
PropertyArray = new UndoObjectWithArray[1]
{
new UndoObjectWithArray
{
FieldFloat = 1000.0f
},
}
},
new UndoObjectWithArray
{
FieldInteger = 34,
PropertyFloat = 3.4f,
FieldArray = new UndoObjectWithArray[0]
},
},
};
using (new UndoBlock(undo, instance, "Edit"))
{
instance.FieldArray[0].FieldInteger = 11;
instance.FieldArray[0].PropertyFloat = 1.1f;
instance.FieldArray[1].FieldInteger = 12;
instance.FieldArray[1].PropertyFloat = 1.2f;
instance.FieldArray[0].FieldArray = null;
instance.FieldArray[0].PropertyArray[0].FieldFloat = -1;
instance.PropertyArray[0].FieldInteger = -11;
instance.PropertyArray[0].PropertyFloat = -1.1f;
instance.PropertyArray[1].FieldInteger = -12;
instance.PropertyArray[1].PropertyFloat = -1.2f;
instance.PropertyArray[0].FieldArray = null;
instance.PropertyArray[0].PropertyArray[0].FieldFloat = 1;
}
undo.PerformUndo();
Assert.AreEqual(2, instance.FieldArray.Length);
Assert.AreEqual(33, instance.FieldArray[0].FieldInteger);
Assert.AreEqual(3.3f, instance.FieldArray[0].PropertyFloat);
Assert.AreEqual(34, instance.FieldArray[1].FieldInteger);
Assert.AreEqual(3.4f, instance.FieldArray[1].PropertyFloat);
Assert.AreNotEqual(null, instance.FieldArray[0].FieldArray);
Assert.AreEqual(1000.0f, instance.FieldArray[0].PropertyArray[0].FieldFloat);
Assert.AreEqual(2, instance.PropertyArray.Length);
Assert.AreEqual(33, instance.PropertyArray[0].FieldInteger);
Assert.AreEqual(3.3f, instance.PropertyArray[0].PropertyFloat);
Assert.AreEqual(34, instance.PropertyArray[1].FieldInteger);
Assert.AreEqual(3.4f, instance.PropertyArray[1].PropertyFloat);
Assert.AreNotEqual(null, instance.PropertyArray[0].FieldArray);
Assert.AreEqual(1000.0f, instance.PropertyArray[0].PropertyArray[0].FieldFloat);
undo.PerformRedo();
Assert.AreEqual(11, instance.FieldArray[0].FieldInteger);
Assert.AreEqual(1.1f, instance.FieldArray[0].PropertyFloat);
Assert.AreEqual(12, instance.FieldArray[1].FieldInteger);
Assert.AreEqual(1.2f, instance.FieldArray[1].PropertyFloat);
Assert.AreEqual(null, instance.FieldArray[0].FieldArray);
Assert.AreEqual(-1, instance.FieldArray[0].PropertyArray[0].FieldFloat);
Assert.AreEqual(-11, instance.PropertyArray[0].FieldInteger);
Assert.AreEqual(-1.1f, instance.PropertyArray[0].PropertyFloat);
Assert.AreEqual(-12, instance.PropertyArray[1].FieldInteger);
Assert.AreEqual(-1.2f, instance.PropertyArray[1].PropertyFloat);
Assert.AreEqual(null, instance.PropertyArray[0].FieldArray);
Assert.AreEqual(1, instance.PropertyArray[0].PropertyArray[0].FieldFloat);
}
public void HistoryStackTestEmptyHistory()
{
var stack = new HistoryStack(50);
Assert.AreEqual(null, stack.PopHistory());
Assert.AreEqual(null, stack.PopReverse());
}
public void CircularBufferTestEvents()
{
//Front
var buffer = new CircularBuffer <long>(5);
var overflown = 0;
var added = 0;
var removed = 7;
var overflownHandler = new CircularBuffer <long> .ItemOverflownEventHandler((sender, args) =>
{
Assert.AreEqual(overflown++, args.Item);
Assert.AreEqual(false, args.WasFrontItem);
});
buffer.OnItemOverflown += overflownHandler;
var addHandler = new CircularBuffer <long> .ItemAddedEventHandler((sender, args) =>
{
Assert.AreEqual(added++, args.Item);
Assert.AreEqual(buffer.Count - 1, args.Index);
});
buffer.OnItemAdded += addHandler;
var removeHandler = new CircularBuffer <long> .ItemRemovedEventHandler((sender, args) =>
{
Assert.AreEqual(removed--, args.Item);
Assert.AreEqual(true, args.WasFrontItem);
});
buffer.OnItemRemoved += removeHandler;
for (int i = 0; i < 8; i++)
{
buffer.PushFront(i);
}
for (int i = 0; i < 5; i++)
{
buffer.PopFront();
}
buffer.OnItemOverflown -= overflownHandler;
buffer.OnItemAdded -= addHandler;
buffer.OnItemRemoved -= removeHandler;
//Back
buffer.Clear();
overflown = 0;
added = 0;
removed = 7;
overflownHandler = (sender, args) =>
{
Assert.AreEqual(overflown++, args.Item);
Assert.AreEqual(true, args.WasFrontItem);
};
buffer.OnItemOverflown += overflownHandler;
addHandler = (sender, args) =>
{
Assert.AreEqual(added++, args.Item);
Assert.AreEqual(0, args.Index);
};
buffer.OnItemAdded += addHandler;
removeHandler = (sender, args) =>
{
Assert.AreEqual(removed--, args.Item);
Assert.AreEqual(false, args.WasFrontItem);
};
buffer.OnItemRemoved += removeHandler;
for (int i = 0; i < 8; i++)
{
buffer.PushBack(i);
}
for (int i = 0; i < 5; i++)
{
buffer.PopBack();
}
buffer.OnItemOverflown -= overflownHandler;
buffer.OnItemAdded -= addHandler;
buffer.OnItemRemoved -= removeHandler;
}
public void ControlTestApi()
{
var testRect = new Rectangle(0, 5, 20, 25);
var basic = new SimpleControl(true, 0, 5, 20, 25);
var vec2 = new SimpleControl(true, new Vector2(0, 5), new Vector2(20, 25));
var rect = new SimpleControl(true, testRect);
Assert.AreEqual(testRect.Location, basic.Location);
Assert.AreEqual(testRect.Location, vec2.Location);
Assert.AreEqual(testRect.Location, rect.Location);
Assert.AreEqual(true, basic.AutoFocus);
Assert.AreEqual(true, vec2.AutoFocus);
Assert.AreEqual(true, rect.AutoFocus);
Assert.AreEqual(testRect.Size, basic.Size);
Assert.AreEqual(testRect.Size, vec2.Size);
Assert.AreEqual(testRect.Size, rect.Size);
Assert.AreEqual(testRect, basic.Bounds);
Assert.AreEqual(testRect, vec2.Bounds);
Assert.AreEqual(testRect, rect.Bounds);
Assert.AreEqual(testRect.Top, rect.Top);
Assert.AreEqual(testRect.Left, rect.Left);
Assert.AreEqual(testRect.Right, rect.Right);
Assert.AreEqual(testRect.Bottom, rect.Bottom);
Assert.AreEqual(testRect.BottomRight, rect.BottomRight);
Assert.AreEqual(testRect.BottomLeft, rect.BottomLeft);
Assert.AreEqual(testRect.UpperLeft, rect.UpperLeft);
Assert.AreEqual(testRect.UpperRight, rect.UpperRight);
Assert.AreEqual(testRect.Center, rect.Center);
Assert.AreEqual(testRect.Width, rect.Width);
Assert.AreEqual(testRect.Height, rect.Height);
Assert.AreEqual(testRect.X, rect.X);
Assert.AreEqual(testRect.Y, rect.Y);
testRect = new Rectangle(1, 6, 21, 26);
rect.X = 1;
rect.Y = 6;
rect.Width = 21;
rect.Height = 26;
Assert.AreEqual(testRect, rect.Bounds);
testRect = new Rectangle(2, 7, 22, 27);
rect.Location = new Vector2(2, 7);
rect.Size = new Vector2(22, 27);
Assert.AreEqual(testRect, rect.Bounds);
rect.BackgroundColor = Color.Azure;
Assert.AreEqual(Color.Azure, rect.BackgroundColor);
Assert.IsTrue(rect.Enabled);
rect.Enabled = false;
Assert.IsFalse(rect.Enabled);
rect.Enabled = true;
Assert.IsTrue(rect.Enabled);
Assert.IsTrue(rect.Visible);
rect.Visible = false;
Assert.IsFalse(rect.Visible);
rect.Visible = true;
Assert.IsTrue(rect.Visible);
}
