public void MergeClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = new VectorClock();
clock2 = clock2.Increment("key2");
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key3");
VectorClock mergedClock = new VectorClock();
mergedClock = mergedClock.Merge(clock1);
mergedClock = mergedClock.Increment("key1");
mergedClock = mergedClock.Merge(clock2);
mergedClock = mergedClock.Merge(clock3);
Assert.That(mergedClock["key1"] == 4 && mergedClock["key2"] == 2 && mergedClock["key3"] == 1);
// Merge should not affect the original VectorClock
Assert.That(clock1["key1"] == 3);
}
public void Benchmark_Commutative_AssignAndRemove_WithVectorClock()
{
TestType value;
TCRDT replica;
List <TCRDT> downstreamReplicas;
var clock = new VectorClock(_nodes);
for (int i = 0; i < _nodes.Count; i++)
{
replica = _replicas[_nodes[i]];
downstreamReplicas = _replicas.Where(r => r.Key.Id != _nodes[i].Id).Select(v => v.Value).ToList();
for (int j = 0; j < _iterations; j++)
{
// Assign
value = _objects[i * _iterations + j];
CommutativeAssignWithVectorClock(replica, value.Id, JToken.FromObject(value), clock, downstreamReplicas);
clock.Increment(_nodes[i]);
// Remove
CommutativeRemoveWithVectorClock(replica, value, clock, downstreamReplicas);
clock.Increment(_nodes[i]);
}
}
}
public void MergeClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = new VectorClock();
clock2 = clock2.Increment("key2");
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key3");
VectorClock mergedClock = new VectorClock();
mergedClock = mergedClock.Merge(clock1);
mergedClock = mergedClock.Increment("key1");
mergedClock = mergedClock.Merge(clock2);
mergedClock = mergedClock.Merge(clock3);
Assert.That(mergedClock["key1"] == 4 && mergedClock["key2"] == 2 && mergedClock["key3"] == 1);
// Merge should not affect the original VectorClock
Assert.That(clock1["key1"] == 3);
}
public void Benchmark_AddUpdateAndRemove_WithVectorClock()
{
TestType value;
TCRDT replica;
List <TCRDT> downstreamReplicas;
var clock = new VectorClock(_nodes);
for (int i = 0; i < _nodes.Count; i++)
{
replica = _replicas[_nodes[i]];
downstreamReplicas = _replicas.Where(r => r.Key.Id != _nodes[i].Id).Select(v => v.Value).ToList();
for (int j = 0; j < _iterations; j++)
{
// Add
value = _addObjects[i * _iterations + j];
AddWithVectorClock(replica, value, clock, downstreamReplicas);
clock = clock.Increment(_nodes[i]);
// Update
value = _updateObjects[i * _iterations + j];
UpdateWithVectorClock(replica, value, clock, downstreamReplicas);
clock = clock.Increment(_nodes[i]);
// Remove
RemoveWithVectorClock(replica, value, clock, downstreamReplicas);
clock = clock.Increment(_nodes[i]);
}
}
}
public void IsConcurrentAgainstNull()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
p.Increment(3);
Assert.AreEqual(ConcurrencyComparison.Concurrent, p.Compare(null));
}
public void IsBeforeSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.Before, p.Compare(q));
}
public void IsAfterSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.After, q.Compare(p));
}
public void IncrementClock()
{
Dictionary<string, int> vector = new Dictionary<string, int>();
vector["key1"] = 2;
vector["key2"] = 3;
VectorClock clock = new VectorClock(vector);
clock = clock.Increment("key1");
clock = clock.Increment("key2");
Assert.That(clock["key1"] == 3 && clock["key2"] == 4);
}
public void IsEqual()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
var q = new VectorClock();
q.Increment(1);
q.Increment(2);
Assert.AreEqual(ConcurrencyComparison.Equal, p.Compare(q));
}
public void IncrementClock()
{
Dictionary <string, int> vector = new Dictionary <string, int>();
vector["key1"] = 2;
vector["key2"] = 3;
VectorClock clock = new VectorClock(vector);
clock = clock.Increment("key1");
clock = clock.Increment("key2");
Assert.That(clock["key1"] == 3 && clock["key2"] == 4);
}
public void IsBeforeSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.Before, p.Compare(q));
}
public void IsAfterSameElements()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
q.Increment(1);
Assert.AreEqual(ConcurrencyComparison.After, q.Compare(p));
}
public void IsEqual()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
var q = new VectorClock();
q.Increment(1);
q.Increment(2);
Assert.AreEqual(ConcurrencyComparison.Equal, p.Compare(q));
}
public void CopyClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key1");
Assert.That(clock1 != clock2);
Assert.That(clock1["key1"] == 3);
Assert.That(clock2["key1"] == 4);
}
public void CopyClock()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key1");
Assert.That(clock1 != clock2);
Assert.That(clock1["key1"] == 3);
Assert.That(clock2["key1"] == 4);
}
public void SetUp()
{
this.SetupApplicationState();
this.evt6 = new TestEvent(); // Earliest timestamp, but should be last based on VectorClock
Thread.Sleep(10);
VectorClock clock = new VectorClock();
this.evt1 = new TestEvent();
this.evt1.VectorClock = clock.Increment("key1");
this.evt2 = new TestEvent();
this.evt2.VectorClock = this.evt1.VectorClock.Increment("key1");
this.evt3 = new TestEvent();
this.evt3.VectorClock = this.evt2.VectorClock.Increment("key1");
Thread.Sleep(10); // Add sleep so the timestamp is different between evt3 and evt4
this.evt4 = new TestEvent();
this.evt4.VectorClock = this.evt2.VectorClock.Increment("key2");
this.evt5 = new TestEvent();
this.evt5.VectorClock = this.evt3.VectorClock.Merge(this.evt4.VectorClock).Increment("key3");
this.evt6.VectorClock = this.evt5.VectorClock.Increment("key1");
}
public void DetectSimultaneousOperations()
{
VectorClock baseClock = new VectorClock();
baseClock = baseClock.Increment("key1");
baseClock = baseClock.Increment("key1");
VectorClock clock1 = baseClock.Copy();
VectorClock clock2 = baseClock.Copy();
VectorClock clock3 = baseClock.Copy();
clock1 = clock1.Increment("key1");
clock2 = clock2.Increment("key2");
clock3 = clock3.Increment("key3");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock1.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
VectorClock clock4 = clock1.Merge(clock2);
clock4 = clock4.Merge(clock3);
Assert.That(clock4.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock2) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock3) == VectorClock.ComparisonResult.Greater);
Assert.That(clock1.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock3.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
// All previous clocks descend from baseClock which has the vector ["key1" : 2]
VectorClock otherClock = new VectorClock();
otherClock = otherClock.Increment("key4");
// otherClock should be simultaneous with all of them since it doesnt recognize ["key1" : 2]
Assert.That(otherClock.CompareVectors(baseClock) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock4) == VectorClock.ComparisonResult.Simultaneous);
}
public void StartAtOne()
{
VectorClock clock = new VectorClock();
Assert.That(!clock.ContainsKey("key1"));
clock = clock.Increment("key1");
Assert.That(clock["key1"] == 1);
}
public void Setup()
{
var(vcBefore, nodes) = CreateVectorClockOfSize(ClockSize);
_vcBefore = vcBefore;
_nodes = nodes;
_firstNode = nodes.First();
_lastNode = nodes.Last();
_middleNode = nodes[ClockSize / 2];
_vcBaseLast = vcBefore.Increment(_lastNode);
_vcAfterLast = _vcBaseLast.Increment(_firstNode);
_vcConcurrentLast = _vcBaseLast.Increment(_lastNode);
_vcBaseMiddle = _vcBefore.Increment(_middleNode);
_vcAfterMiddle = _vcBaseMiddle.Increment(_firstNode);
_vcConcurrentMiddle = _vcBaseMiddle.Increment(_middleNode);
}
public void StartAtOne()
{
VectorClock clock = new VectorClock();
Assert.That(!clock.ContainsKey("key1"));
clock = clock.Increment("key1");
Assert.That(clock["key1"] == 1);
}
public void NullObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
object c = null;
Assert.IsFalse(p.Equals(c));
}
public void CompareVectors()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key1");
clock3 = clock3.Increment("key2");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Equal);
}
public void NullTypedEquals()
{
var p = new VectorClock();
p.Increment(1);
VectorClock q = null;
Assert.IsFalse(p.Equals(q));
}
public void TypedEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
Assert.IsTrue(p.Equals(q));
}
public void Commutative_Assign_UpdateSingleField()
{
var nodes = CreateNodes(3);
var commutativeReplicas = CreateCommutativeReplicas(nodes);
var initialValue = _builder.Build();
var valueId = initialValue.Id;
var clock = new VectorClock(nodes);
var firstReplica = commutativeReplicas.First();
firstReplica.Value.LocalAssign(valueId, JToken.FromObject(initialValue), clock);
CommutativeDownstreamAssign(firstReplica.Key.Id, valueId, JToken.FromObject(firstReplica.Value.GetValue(valueId).Value), clock, commutativeReplicas);
clock = clock.Increment(firstReplica.Key);
foreach (var replica in commutativeReplicas)
{
for (int i = 0; i < 1; i++)
{
initialValue.StringValue = Guid.NewGuid().ToString();
var jToken = JToken.Parse($"{{\"StringValue\":\"{initialValue.StringValue}\"}}");
replica.Value.LocalAssign(valueId, jToken, clock);
CommutativeDownstreamAssign(replica.Key.Id, valueId, jToken, clock, commutativeReplicas);
clock = clock.Increment(replica.Key);
}
}
foreach (var replica in commutativeReplicas)
{
Assert.Equal(initialValue, replica.Value.GetValue(valueId).Value);
}
}
public void ObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
object c = q;
Assert.IsTrue(p.Equals(c));
}
public void Commutative_Assign_NewValue()
{
var nodes = CreateNodes(3);
var commutativeReplicas = CreateCommutativeReplicas(nodes);
var initialValue = _builder.Build();
var valueId = initialValue.Id;
var clock = new VectorClock(nodes);
var firstReplica = commutativeReplicas.First();
firstReplica.Value.LocalAssign(valueId, JToken.FromObject(initialValue), clock);
CommutativeDownstreamAssign(firstReplica.Key.Id, valueId, JToken.FromObject(firstReplica.Value.GetValue(valueId).Value), clock, commutativeReplicas);
clock = clock.Increment(firstReplica.Key);
foreach (var replica in commutativeReplicas)
{
for (int i = 0; i < 100; i++)
{
initialValue = _builder.Build(valueId);
replica.Value.LocalAssign(valueId, JToken.FromObject(initialValue), clock);
CommutativeDownstreamAssign(replica.Key.Id, valueId, JToken.FromObject(replica.Value.GetValue(valueId).Value), clock, commutativeReplicas);
clock = clock.Increment(replica.Key);
}
}
foreach (var replica in commutativeReplicas)
{
Assert.Equal(initialValue, replica.Value.GetValue(valueId).Value);
}
}
public void Convergent_Assign_UpdateSingleField()
{
var nodes = CreateNodes(3);
var convergentReplicas = CreateConvergentReplicas(nodes);
var initialValue = _builder.Build();
var valueId = initialValue.Id;
var clock = new VectorClock(nodes);
var firstReplica = convergentReplicas.First();
firstReplica.Value.LocalAssign(initialValue, clock);
ConvergentDownstreamAssign(firstReplica.Key.Id, firstReplica.Value.GetValue(valueId).Value, clock, convergentReplicas);
clock = clock.Increment(firstReplica.Key);
foreach (var replica in convergentReplicas)
{
for (int i = 0; i < 100; i++)
{
initialValue.StringValue = Guid.NewGuid().ToString();
replica.Value.LocalAssign(initialValue, clock);
ConvergentDownstreamAssign(replica.Key.Id, replica.Value.GetValue(valueId).Value, clock, convergentReplicas);
clock = clock.Increment(replica.Key);
}
}
foreach (var replica in convergentReplicas)
{
Assert.Equal(initialValue, replica.Value.GetValue(valueId).Value);
}
}
public void CanCopyVector()
{
Guid deviceOne = Guid.NewGuid();
Guid deviceTwo = Guid.NewGuid();
VectorClock clock = new VectorClock();
clock = clock.Increment(deviceOne);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
Thread.Sleep(100);
var newClock = clock.Copy();
Assert.That(clock.Count, Is.EqualTo(newClock.Count));
Assert.That(clock.Timestamp, Is.EqualTo(newClock.Timestamp));
foreach (var kvp in clock)
{
Assert.That(newClock.ContainsKey(kvp.Key), Is.True);
Assert.That(newClock[kvp.Key], Is.EqualTo(clock[kvp.Key]));
}
}
public void CanConvertVectorClockToByteArray()
{
Guid deviceOne = Guid.NewGuid();
Guid deviceTwo = Guid.NewGuid();
VectorClock clock = new VectorClock();
clock = clock.Increment(deviceOne);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
clock = clock.Increment(deviceTwo);
var bytes = clock.ToByteArray();
var newClock = new VectorClock(bytes);
Assert.That(clock.Count, Is.EqualTo(newClock.Count));
Assert.That(clock.Timestamp, Is.EqualTo(newClock.Timestamp));
foreach (var kvp in clock)
{
Assert.That(newClock.ContainsKey(kvp.Key), Is.True);
Assert.That(newClock[kvp.Key], Is.EqualTo(clock[kvp.Key]));
}
}
public void Benchmark_Convergent_AssignSingleProperty_WithVectorClock()
{
TestType value = _objects[0];
TCRDT replica;
List <TCRDT> downstreamReplicas;
var clock = new VectorClock(_nodes);
for (int i = 0; i < _nodes.Count; i++)
{
replica = _replicas[_nodes[i]];
downstreamReplicas = _replicas.Where(r => r.Key.Id != _nodes[i].Id).Select(v => v.Value).ToList();
for (int j = 0; j < _iterations; j++)
{
// Assign
value.StringValue = Guid.NewGuid().ToString();
ConvergentAssignWithVectorClock(replica, value, clock, downstreamReplicas);
clock.Increment(_nodes[i]);
}
}
}
public void SetUp()
{
this.evt6 = new TestEvent(); // Earliest timestamp, but should be last based on VectorClock
Thread.Sleep(10);
VectorClock clock = new VectorClock();
this.evt1 = new TestEvent();
this.evt1.VectorClock = clock.Increment("key1");
this.evt2 = new TestEvent();
this.evt2.VectorClock = this.evt1.VectorClock.Increment("key1");
this.evt3 = new TestEvent();
this.evt3.VectorClock = this.evt2.VectorClock.Increment("key1");
Thread.Sleep(10); // Add sleep so the timestamp is different between evt3 and evt4
this.evt4 = new TestEvent();
this.evt4.VectorClock = this.evt2.VectorClock.Increment("key2");
this.evt5 = new TestEvent();
this.evt5.VectorClock = this.evt3.VectorClock.Merge(this.evt4.VectorClock).Increment("key3");
this.evt6.VectorClock = this.evt5.VectorClock.Increment("key1");
}
public void NullTypedEquals()
{
var p = new VectorClock();
p.Increment(1);
VectorClock q = null;
Assert.IsFalse(p.Equals(q));
}
public void CompareVectors()
{
VectorClock clock1 = new VectorClock();
clock1 = clock1.Increment("key1");
VectorClock clock2 = clock1.Copy();
clock2 = clock2.Increment("key2");
VectorClock clock3 = new VectorClock();
clock3 = clock3.Increment("key1");
clock3 = clock3.Increment("key2");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Equal);
}
public void ObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
object c = q;
Assert.IsTrue(p.Equals(c));
}
public void DetectSimultaneousOperations()
{
VectorClock baseClock = new VectorClock();
baseClock = baseClock.Increment("key1");
baseClock = baseClock.Increment("key1");
VectorClock clock1 = baseClock.Copy();
VectorClock clock2 = baseClock.Copy();
VectorClock clock3 = baseClock.Copy();
clock1 = clock1.Increment("key1");
clock2 = clock2.Increment("key2");
clock3 = clock3.Increment("key3");
Assert.That(clock1.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock1.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock3.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(clock2.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
VectorClock clock4 = clock1.Merge(clock2);
clock4 = clock4.Merge(clock3);
Assert.That(clock4.CompareVectors(clock1) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock2) == VectorClock.ComparisonResult.Greater);
Assert.That(clock4.CompareVectors(clock3) == VectorClock.ComparisonResult.Greater);
Assert.That(clock1.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock2.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
Assert.That(clock3.CompareVectors(clock4) == VectorClock.ComparisonResult.Smaller);
// All previous clocks descend from baseClock which has the vector ["key1" : 2]
VectorClock otherClock = new VectorClock();
otherClock = otherClock.Increment("key4");
// otherClock should be simultaneous with all of them since it doesnt recognize ["key1" : 2]
Assert.That(otherClock.CompareVectors(baseClock) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock1) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock2) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock3) == VectorClock.ComparisonResult.Simultaneous);
Assert.That(otherClock.CompareVectors(clock4) == VectorClock.ComparisonResult.Simultaneous);
}
public void NullObjectEquals()
{
var p = new VectorClock();
p.Increment(1);
object c = null;
Assert.IsFalse(p.Equals(c));
}
public void TypedEquals()
{
var p = new VectorClock();
p.Increment(1);
var q = new VectorClock();
q.Increment(1);
Assert.IsTrue(p.Equals(q));
}
public void IsConcurrentAgainstNull()
{
var p = new VectorClock();
p.Increment(1);
p.Increment(2);
p.Increment(3);
Assert.AreEqual(ConcurrencyComparison.Concurrent, p.Compare(null));
}
