public void CompareToOperatorWithEqualObjects()
{
var first = new HistoryId(10);
object second = new HistoryId(10);
Assert.AreEqual(0, first.CompareTo(second));
}
public void Clone()
{
var first = new HistoryId(10);
var second = first.Clone();
Assert.AreEqual(first, second);
}
public void CompareToWithNullObject()
{
var first = new HistoryId(10);
object second = null;
Assert.AreEqual(1, first.CompareTo(second));
}
public void SmallerThanOperatorWithFirstObjectLarger()
{
var first = new HistoryId(11);
var second = new HistoryId(10);
Assert.IsFalse(first < second);
}
public void SmallerThanOperatorWithFirstObjectSmaller()
{
var first = new HistoryId(9);
var second = new HistoryId(10);
Assert.IsTrue(first < second);
}
public void SmallerThanOperatorWithBothObjectsNull()
{
HistoryId first = null;
HistoryId second = null;
Assert.IsFalse(first < second);
}
public void SmallerThanOperatorWithEqualObjects()
{
var first = new HistoryId(10);
var second = new HistoryId(10);
Assert.IsFalse(first < second);
}
public void SmallerThanOperatorWithFirstObjectNull()
{
HistoryId first = null;
var second = new HistoryId(10);
Assert.IsTrue(first < second);
}
public void SmallerThanOperatorWithSecondObjectNull()
{
var first = new HistoryId(10);
HistoryId second = null;
Assert.IsFalse(first < second);
}
public void LargerThanOperatorWithFirstObjectLarger()
{
var first = new HistoryId(11);
var second = new HistoryId(10);
Assert.IsTrue(first > second);
}
public void LargerThanOperatorWithSecondObjectNull()
{
var first = new HistoryId(10);
HistoryId second = null;
Assert.IsTrue(first > second);
}
public void LargerThanOperatorWithFirstObjectNull()
{
HistoryId first = null;
var second = new HistoryId(10);
Assert.IsFalse(first > second);
}
public void CompareToWithSmallerFirstObject()
{
var first = new HistoryId(10);
object second = new HistoryId(11);
Assert.IsTrue(first.CompareTo(second) < 0);
}
public void CompareToWithUnequalObjectTypes()
{
var first = new HistoryId(10);
object second = new object();
Assert.Throws <ArgumentException>(() => first.CompareTo(second));
}
public void MarkClearsForwardHistory()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
timeline.AddToTimeline();
timeline.Mark(new TimeMarker(2));
timeline.Object.SomeValue = 1;
timeline.Object.LotsOfValues.Add(2);
timeline.Mark(new TimeMarker(3));
timeline.DeleteFromTimeline();
timeline.Mark(new TimeMarker(4));
timeline.RollBackTo(new TimeMarker(2));
timeline.Object.SomeValue = 2;
timeline.Object.LotsOfValues.Add(3);
timeline.Mark(new TimeMarker(3));
timeline.RollForwardTo(new TimeMarker(10));
Assert.AreEqual(2, timeline.Object.SomeValue);
Assert.That(
timeline.Object.LotsOfValues,
Is.EquivalentTo(new int[] { 3 }));
}
public void DeleteClearsForwardHistory()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
timeline.AddToTimeline();
timeline.Mark(new TimeMarker(2));
timeline.Object.SomeValue = 1;
timeline.Object.LotsOfValues.Add(2);
timeline.Mark(new TimeMarker(3));
timeline.DeleteFromTimeline();
timeline.Mark(new TimeMarker(4));
timeline.RollBackTo(new TimeMarker(2));
timeline.DeleteFromTimeline();
timeline.Mark(new TimeMarker(3));
timeline.RollBackTo(new TimeMarker(2));
Assert.IsTrue(timeline.IsAlive());
Assert.AreEqual(new TimeMarker(2), timeline.CreationTime);
Assert.AreEqual(new TimeMarker(3), timeline.DeletionTime);
Assert.AreEqual(0, timeline.Object.SomeValue);
Assert.AreEqual(0, timeline.Object.LotsOfValues.Count);
}
public void RollForwardPastDeath()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
var creationTime = new TimeMarker(1);
timeline.AddToTimeline();
timeline.Mark(creationTime);
timeline.Object.SomeValue = 1;
timeline.Object.LotsOfValues.Add(2);
timeline.Mark(new TimeMarker(2));
var deletionTime = new TimeMarker(3);
timeline.DeleteFromTimeline();
timeline.Mark(deletionTime);
timeline.RollBackTo(new TimeMarker(1));
Assert.IsTrue(timeline.IsAlive());
timeline.RollForwardTo(new TimeMarker(4));
Assert.IsFalse(timeline.IsAlive());
Assert.IsNull(timeline.Object);
}
public void RollForwardWithLocalChange()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
var creationTime = new TimeMarker(1);
timeline.AddToTimeline();
timeline.Mark(creationTime);
timeline.Object.SomeValue = 1;
timeline.Object.LotsOfValues.Add(2);
timeline.Mark(new TimeMarker(2));
timeline.Object.SomeValue = 2;
timeline.Object.LotsOfValues.Add(4);
timeline.Mark(new TimeMarker(3));
timeline.RollBackTo(new TimeMarker(2));
timeline.Object.SomeValue = 3;
timeline.Object.LotsOfValues.Add(8);
timeline.RollForwardTo(new TimeMarker(3));
Assert.AreEqual(2, timeline.Object.SomeValue);
Assert.That(
timeline.Object.LotsOfValues,
Is.EquivalentTo(new int[] { 2, 4 }));
}
public void RollBackWhileNotExisting()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
Assert.DoesNotThrow(() => timeline.RollBackTo(new TimeMarker(0)));
}
public void RollBackFromDeathToLife()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
var creationTime = new TimeMarker(1);
timeline.AddToTimeline();
timeline.Mark(creationTime);
timeline.Object.SomeValue = 1;
timeline.Object.LotsOfValues.Add(2);
timeline.Mark(new TimeMarker(2));
var deletionTime = new TimeMarker(3);
timeline.DeleteFromTimeline();
timeline.Mark(deletionTime);
Assert.DoesNotThrow(() => timeline.RollBackTo(new TimeMarker(2)));
Assert.IsTrue(timeline.IsAlive());
Assert.IsNotNull(timeline.Object);
Assert.AreEqual(1, timeline.Object.SomeValue);
Assert.That(
timeline.Object.LotsOfValues,
Is.EquivalentTo(new int[] { 2 }));
}
public void RollBackToPreviousValue()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
var creationTime = new TimeMarker(1);
timeline.AddToTimeline();
timeline.Mark(creationTime);
int maximumValue = 10;
for (int i = 1; i < maximumValue; i++)
{
timeline.Object.SomeValue = i;
timeline.Object.LotsOfValues.Add(i);
timeline.Mark(new TimeMarker((ulong)(i + 1)));
}
for (int i = maximumValue - 1; i > 0; i--)
{
timeline.RollBackTo(new TimeMarker((ulong)(i + 1)));
Assert.AreEqual(i, timeline.Object.SomeValue);
Assert.AreEqual(i, timeline.Object.LotsOfValues.Count);
for (int j = 1; j <= i; j++)
{
Assert.IsTrue(timeline.Object.LotsOfValues.Contains(j));
}
}
}
public void RollBackToBeginning()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
var creationTime = new TimeMarker(1);
timeline.AddToTimeline();
timeline.Mark(creationTime);
int maximumValue = 10;
for (int i = 0; i < maximumValue; i++)
{
timeline.Object.SomeValue = i;
timeline.Object.LotsOfValues.Add(i);
timeline.Mark(new TimeMarker((ulong)(i + 2)));
}
timeline.RollBackTo(new TimeMarker(1));
Assert.IsTrue(timeline.IsAlive());
Assert.IsNotNull(timeline.Object);
Assert.AreEqual(0, timeline.Object.SomeValue);
Assert.AreEqual(0, timeline.Object.LotsOfValues.Count);
}
public void DeleteFromTimeline()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
timeline.AddToTimeline();
var creationTime = new TimeMarker(1);
timeline.Mark(creationTime);
Assert.IsTrue(timeline.IsAlive());
Assert.AreEqual(creationTime, timeline.CreationTime);
Assert.IsNull(timeline.DeletionTime);
Assert.IsNotNull(timeline.Object);
timeline.DeleteFromTimeline();
var deletionTime = new TimeMarker(2);
timeline.Mark(deletionTime);
Assert.IsFalse(timeline.IsAlive());
Assert.AreEqual(creationTime, timeline.CreationTime);
Assert.AreEqual(deletionTime, timeline.DeletionTime);
Assert.IsNull(timeline.Object);
}
public void DeleteFromTimelineWhileNotCreated()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
Assert.DoesNotThrow(() => timeline.DeleteFromTimeline());
}
private static MockHistoryObject BuildObject(
HistoryId id,
IEnumerable <Tuple <byte, IStoreTimelineValues> > members,
params object[] constructorArguments)
{
IVariableTimeline <int> someValue = null;
IListTimelineStorage <int> lotsOfValues = null;
foreach (var pair in members)
{
if (pair.Item1 == MockHistoryObject.SomeValueIndex)
{
someValue = pair.Item2 as IVariableTimeline <int>;
continue;
}
if (pair.Item1 == MockHistoryObject.LotsOfValuesIndex)
{
lotsOfValues = pair.Item2 as IListTimelineStorage <int>;
continue;
}
}
return(new MockHistoryObject(id, someValue, lotsOfValues));
}
/// <summary>
/// Removes the object with the given <see cref="HistoryId"/> from the timeline.
/// </summary>
/// <param name="id">The ID of the object that should be removed.</param>
public void RemoveFromTimeline(HistoryId id)
{
if ((id == null) || (!m_ObjectTimelines.ContainsKey(id) && !m_NonMarkedObjectTimelines.ContainsKey(id)))
{
return;
}
if (m_ObjectTimelines.ContainsKey(id))
{
// Only delete living objects. Don't delete objects that are already dead
// and don't delete objects that don't exist yet.
var timeline = m_ObjectTimelines[id];
if (timeline.IsAlive())
{
timeline.DeleteFromTimeline();
}
}
else
{
// The timeline exists but the object doesn't have a creation time. Thus the creation time
// must be the next marker. Hence we delete the object and then nuke the timeline.
var timeline = m_NonMarkedObjectTimelines[id];
timeline.DeleteFromTimeline();
m_NonMarkedObjectTimelines.Remove(id);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectUnknownToTimelineException"/> class.
/// </summary>
/// <param name="id">The history ID of the unknown object.</param>
public ObjectUnknownToTimelineException(HistoryId id)
: this(
string.Format(
CultureInfo.InvariantCulture,
Resources.Exceptions_Messages_ObjectUnknownToTimeline_WithId,
id))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TimelineIdDoesNotMatchException"/> class.
/// </summary>
/// <param name="provided">The ID number that was provided.</param>
/// <param name="expected">The ID number that was expected.</param>
public TimelineIdDoesNotMatchException(HistoryId provided, HistoryId expected)
: this(
string.Format(
CultureInfo.InvariantCulture,
Resources.Exceptions_Messages_HistoryIdDoesNotMatch_WithIds,
provided,
expected))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TimelineTraveller"/> class.
/// </summary>
/// <param name="owner">The ID number of the owner who created the time traveling information.</param>
/// <param name="information">
/// The information that should be provided to the owner after the roll-back or roll-forward.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="owner"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="information"/> is <see langword="null" />.
/// </exception>
public TimelineTraveller(HistoryId owner, Stream information)
{
{
Lokad.Enforce.Argument(() => owner);
Lokad.Enforce.Argument(() => information);
}
m_OwnerId = owner;
m_Information = information;
}
public void AddToTimelineWithExistingObject()
{
var id = new HistoryId();
var timeline = new ObjectTimeline <MockHistoryObject>(id, BuildStorageOfType, BuildObject);
timeline.AddToTimeline();
var marker = new TimeMarker(1);
timeline.Mark(marker);
Assert.Throws <ObjectHasAlreadyBeenAddedToTheTimelineException>(() => timeline.AddToTimeline());
}
