public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_9()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"))
.SetItem(_node2, "b", GSet.Create("B"));
var m2 = ORDictionary.Create(_node2, "c", GSet.Create("C"));
var merged1 = m1.Merge(m2);
var m3 = merged1.ResetDelta().Remove(_node1, "b").Remove(_node2, "b");
var m4 = merged1.ResetDelta()
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"));
var merged2 = m3.Merge(m4);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B2", "B3");
merged2.Entries["c"].Elements.Should().BeEquivalentTo("C");
var merged3 = merged1.MergeDelta(m3.Delta).MergeDelta(m4.Delta);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B2", "B3");
merged3.Entries["c"].Elements.Should().BeEquivalentTo("C");
}
private static Props TestWriteAggregatorProps(GSet <string> data,
IWriteConsistency consistency,
IImmutableDictionary <Address, IActorRef> probes,
IImmutableList <Address> nodes,
IImmutableSet <Address> unreachable,
IActorRef replyTo,
bool durable) => Actor.Props.Create(() => new TestWriteAggregator <GSet <string> >(KeyA, data, null, consistency, probes, nodes, unreachable, replyTo, durable));
/// <summary>
/// Returns all variables which are occur within an old expression in <paramref name="node" />
/// and which satisfy <paramref name="pred" />
/// </summary>
public ISet <Variable> FindOldVariables(Absy node, Predicate <Variable> pred)
{
_freeOldVars = new GSet <Variable>();
_pred = pred;
Visit(node);
return(new HashSet <Variable>(_freeOldVars));
}
public void ReplicatedDataSerializer_should_serialize_ORDictionary_delta()
{
CheckSerialization(ORDictionary <string, GSet <string> > .Empty
.SetItem(_address1, "a", GSet.Create("A"))
.SetItem(_address2, "b", GSet.Create("B"))
.Delta);
CheckSerialization(ORDictionary <string, GSet <string> > .Empty
.SetItem(_address1, "a", GSet.Create("A"))
.ResetDelta()
.Remove(_address2, "a")
.Delta);
CheckSerialization(ORDictionary <string, GSet <string> > .Empty
.SetItem(_address1, "a", GSet.Create("A"))
.Remove(_address2, "a")
.Delta);
CheckSerialization(ORDictionary <string, ORSet <string> > .Empty
.SetItem(_address1, "a", ORSet.Create(_address1, "A"))
.SetItem(_address2, "b", ORSet.Create(_address2, "B"))
.AddOrUpdate(_address1, "a", ORSet <string> .Empty, old => old.Add(_address1, "C"))
.Delta);
CheckSerialization(ORDictionary <string, ORSet <string> > .Empty
.ResetDelta()
.AddOrUpdate(_address1, "a", ORSet <string> .Empty, old => old.Add(_address1, "C"))
.Delta);
}
public void A_GSet_should_be_able_to_have_its_user_set_correctly_merged_with_another_GSet_with_overlapping_user_sets()
{
var c11 = new GSet <string>();
var c12 = c11.Add(user1);
var c13 = c12.Add(user2);
var c14 = c13.Add(user3);
var c21 = new GSet <string>();
var c22 = c21.Add(user3);
var c23 = c22.Add(user4);
var c24 = c23.Add(user2);
var merged1 = c13.Merge(c23);
Assert.True(merged1.Contains(user1));
Assert.True(merged1.Contains(user2));
Assert.True(merged1.Contains(user3));
Assert.True(merged1.Contains(user4));
var merged2 = c23.Merge(c13);
Assert.True(merged2.Contains(user1));
Assert.True(merged2.Contains(user2));
Assert.True(merged2.Contains(user3));
Assert.True(merged2.Contains(user4));
}
public void ORDictionary_must_work_with_deltas_and_Add_for_GSet_elements_type()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"));
var m2 = m1.ResetDelta().AddOrUpdate(_node1, "a", GSet <string> .Empty, x => x.Add("B"));
var m3 = ORDictionary <string, GSet <string> > .Empty.MergeDelta(m1.Delta).MergeDelta(m2.Delta);
m3.Entries["a"].Should().BeEquivalentTo("A", "B");
}
public void ORDictionary_must_be_able_to_remove_entries()
{
var m = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"))
.Remove(_node1, "a");
m.Entries.Keys.Should().NotContain("a");
m.Entries.Keys.Should().Contain("b");
}
public TestWriteAggregator(
GSet <string> data,
IWriteConsistency consistency,
IImmutableDictionary <Address, IActorRef> probes,
IImmutableSet <Address> nodes,
IActorRef replyTo)
: base(Key, new DataEnvelope(data), consistency, null, nodes, replyTo)
{
_probes = probes;
}
public void A_ORDictionary_should_be_able_to_remove_entries()
{
var m = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"))
.Remove(_node1, "a");
Assert.DoesNotContain("a", m.Entries.Keys);
Assert.Contains("b", m.Entries.Keys);
}
static void Main(string[] args)
{
// 코드 생성
GEntry entry = new GEntry();
GVariable var = new GVariable("valueA");
GDefine def = new GDefine(var);
entry.Append(def);
GEvent main = new GEvent(new GCommand("this", "Loaded", typeof(void), GCommand.CommandType.Event));
GSet setValue = new GSet(var, new GNumberConst(5));
main.Append(setValue);
GIf ifCheck = new GIf(new GCompare(var, GCompare.ConditionType.GREATER_THEN, new GNumberConst(3)));
ifCheck.Append(
new GVoidCall(
new GCommand("Console", "WriteLine", typeof(void), GCommand.CommandType.Call),
new GObject[] { new GStringCat(new GStringConst("A"), new GConvertNumberToString(new GNumberConst(5))) }
)
);
main.Append(ifCheck);
entry.Append(main);
// 생성된 코드 컴파일
string source = entry.ToSource();
string resultFile = Path.GetTempFileName();
GCompiler compile = new GCompiler(source);
GCompilerResults result = compile.Build(resultFile);
Console.WriteLine(result.Source);
// 코드 컴파일 결과 분석
if (result.IsSuccess)
{
// 컴파일 성공
// 컴파일된 시나리오 실행
Console.WriteLine("컴파일 성공");
}
else
{
// 컴파일 실패
// 컴파일 오류 출력
foreach (CompilerError error in result.Results.Errors)
{
Console.WriteLine("컴파일 오류 : " + error.Line + " - " + error.ErrorNumber + ":" + error.ErrorText);
}
}
Console.ReadLine();
}
public CacheReplicationMonitor(FSNamesystem namesystem, CacheManager cacheManager
, long intervalMs, ReentrantLock Lock)
{
this.namesystem = namesystem;
this.blockManager = namesystem.GetBlockManager();
this.cacheManager = cacheManager;
this.cachedBlocks = cacheManager.GetCachedBlocks();
this.intervalMs = intervalMs;
this.Lock = Lock;
this.doRescan = this.Lock.NewCondition();
this.scanFinished = this.Lock.NewCondition();
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_11()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A"));
var m2 = ORDictionary.Create(_node2, "a", GSet <string> .Empty).Remove(_node2, "a");
var merged1 = m1.Merge(m2);
merged1.Entries["a"].Elements.Should().BeEquivalentTo("A");
var merged2 = m1.MergeDelta(m2.Delta);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
}
public void A_ORDictionary_should_be_able_to_add_entries()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
Assert.Equal(ImmutableHashSet.Create("A"), m["a"].Elements);
Assert.Equal(ImmutableHashSet.Create("B"), m["b"].Elements);
var m2 = m.SetItem(_node1, "a", GSet.Create("C"));
Assert.Equal(ImmutableHashSet.Create("C"), m2.Entries["a"].Elements);
}
public void ORDictionary_must_be_able_to_add_entries()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
m["a"].Elements.Should().BeEquivalentTo("A");
m["b"].Elements.Should().BeEquivalentTo("B");
var m2 = m.SetItem(_node1, "a", GSet.Create("C"));
m2.Entries["a"].Elements.Should().BeEquivalentTo("C");
}
public void A_GSet_should_be_able_to_add_user()
{
var c1 = new GSet <string>();
var c2 = c1.Add(user1);
var c3 = c2.Add(user2);
var c4 = c3.Add(user3);
var c5 = c4.Add(user4);
Assert.Equal(true, c5.Contains(user1));
Assert.Equal(true, c5.Contains(user2));
Assert.Equal(true, c5.Contains(user3));
Assert.Equal(true, c5.Contains(user4));
}
public void GSet_must_be_able_to_add_user()
{
var c1 = new GSet <string>();
var c2 = c1.Add(user1);
var c3 = c2.Add(user2);
var c4 = c3.Add(user3);
var c5 = c4.Add(user4);
Assert.True(c5.Contains(user1));
Assert.True(c5.Contains(user2));
Assert.True(c5.Contains(user3));
Assert.True(c5.Contains(user4));
}
public void ReplicatedDataSerializer_should_serialize_GSet()
{
CheckSerialization(GSet <string> .Empty);
CheckSerialization(GSet.Create("a"));
CheckSerialization(GSet.Create("a", "b"));
CheckSerialization(GSet.Create(1, 2, 3));
CheckSerialization(GSet.Create(_address1, _address2));
CheckSerialization(GSet.Create <object>(1L, "2", 3, _address1));
CheckSameContent(GSet.Create("a", "b"), GSet.Create("a", "b"));
CheckSameContent(GSet.Create("a", "b"), GSet.Create("b", "a"));
CheckSameContent(GSet.Create(_address1, _address2, _address3), GSet.Create(_address2, _address1, _address3));
CheckSameContent(GSet.Create(_address1, _address2, _address3), GSet.Create(_address3, _address2, _address1));
}
public override Expr VisitOldExpr(OldExpr node)
{
var freeVars = new GSet <object>();
node.Expr.ComputeFreeVariables(freeVars);
foreach (var v in freeVars)
{
// Note, "v" is either a Variable or a TypeVariable
if (v is Variable vVar && _pred(vVar))
{
_freeOldVars.Add(vVar);
}
}
return(node); // don't visit subexpressions, since ComputeFreeVariables has already gone through those
}
public void ORDictionary_must_be_able_to_add_entries_with_delta()
{
var m = ORDictionary.Create(
Tuple.Create(_node1, "a", GSet.Create("A")),
Tuple.Create(_node1, "b", GSet.Create("B")));
var md = m.Delta;
var m1 = ORDictionary <string, GSet <string> > .Empty.MergeDelta(md);
m1.Entries["a"].Should().BeEquivalentTo("A");
m1.Entries["b"].Should().BeEquivalentTo("B");
var m2 = m1.SetItem(_node1, "a", GSet.Create("C"));
m2.Entries["a"].Should().BeEquivalentTo("C");
}
public void A_ORDictionary_should_illustrate_the_danger_of_using_Remove_then_Add_to_replace_an_entry()
{
var m1 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"));
var m2 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node2, "c", GSet.Create("C"));
var merged1 = m1.Merge(m2);
var m3 = merged1.Remove(_node1, "b").SetItem(_node1, "b", GSet.Create("B2"));
var merged2 = merged1.Merge(m3);
Assert.Equal(ImmutableHashSet.Create("A"), merged2["a"].Elements);
Assert.Equal(ImmutableHashSet.Create("B", "B2"), merged2["b"].Elements);
Assert.Equal(ImmutableHashSet.Create("C"), merged2["c"].Elements);
}
public void ORDictionary_must_illustrate_the_danger_of_using_Remove_then_Add_to_replace_an_entry()
{
var m1 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"));
var m2 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node2, "c", GSet.Create("C"));
var merged1 = m1.Merge(m2);
var m3 = merged1.Remove(_node1, "b").SetItem(_node1, "b", GSet.Create("B2"));
var merged2 = merged1.Merge(m3);
merged2["a"].Elements.Should().BeEquivalentTo("A");
merged2["b"].Elements.Should().BeEquivalentTo("B", "B2");
merged2["c"].Elements.Should().BeEquivalentTo("C");
}
public void ORDictionary_must_be_able_to_remove_entry_using_a_delta()
{
var m = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"));
var addDelta = m.Delta;
var removeDelta = m.ResetDelta().RemoveKey(_node1, "a").Delta;
var m1 = ORDictionary <string, GSet <string> > .Empty.MergeDelta(addDelta);
m1.Entries.Keys.Should().Contain("a");
var m2 = m1.MergeDelta(removeDelta);
m2.Entries.Keys.Should().NotContain("a");
m2.Entries.Keys.Should().Contain("b");
}
public void ORDictionary_must_be_able_to_have_its_entries_correctly_merged_with_another_ORDictionary_with_other_entries()
{
var m1 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A"))
.SetItem(_node1, "b", GSet.Create("B"));
var m2 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node2, "c", GSet.Create("C"));
// merge both ways
var merged1 = m1.Merge(m2);
merged1.Entries.Keys.Should().Contain("a");
merged1.Entries.Keys.Should().Contain("b");
merged1.Entries.Keys.Should().Contain("c");
var merged2 = m2.Merge(m1);
merged2.Entries.Keys.Should().Contain("a");
merged2.Entries.Keys.Should().Contain("b");
merged2.Entries.Keys.Should().Contain("c");
}
public void ReplicatorMessageSerializer_should_serialize_Replicator_message()
{
var ref1 = Sys.ActorOf(Props.Empty, "ref1");
var data1 = GSet.Create("a");
CheckSerialization(new Get(_keyA, ReadLocal.Instance));
CheckSerialization(new Get(_keyA, new ReadMajority(TimeSpan.FromSeconds(2)), "x"));
CheckSerialization(new GetSuccess(_keyA, null, data1));
CheckSerialization(new GetSuccess(_keyA, "x", data1));
CheckSerialization(new NotFound(_keyA, "x"));
CheckSerialization(new GetFailure(_keyA, "x"));
CheckSerialization(new Subscribe(_keyA, ref1));
CheckSerialization(new Unsubscribe(_keyA, ref1));
CheckSerialization(new Changed(_keyA, data1));
CheckSerialization(new DataEnvelope(data1));
CheckSerialization(new DataEnvelope(data1, ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, IPruningState>
{
{ _address1, new PruningPerformed(DateTime.UtcNow) },
{ _address3, new PruningInitialized(_address2, _address1.Address) },
})));
CheckSerialization(new Write("A", new DataEnvelope(data1)));
CheckSerialization(WriteAck.Instance);
CheckSerialization(new Read("A"));
CheckSerialization(new ReadResult(new DataEnvelope(data1)));
CheckSerialization(new ReadResult(null));
CheckSerialization(new Internal.Status(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, ByteString>("A", ByteString.CopyFromUtf8("a")),
new KeyValuePair <string, ByteString>("B", ByteString.CopyFromUtf8("b")),
}), 3, 10));
CheckSerialization(new Gossip(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, DataEnvelope>("A", new DataEnvelope(data1)),
new KeyValuePair <string, DataEnvelope>("B", new DataEnvelope(GSet.Create("b").Add("b"))),
}), true));
}
public void ORDictionary_must_be_able_to_have_its_entries_correctly_merged_with_another_ORDictionary_with_overlaping_entries()
{
var m1 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A1"))
.SetItem(_node1, "b", GSet.Create("B1"))
.Remove(_node1, "a")
.SetItem(_node1, "d", GSet.Create("D1"));
var m2 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node2, "c", GSet.Create("C2"))
.SetItem(_node2, "a", GSet.Create("A2"))
.SetItem(_node2, "b", GSet.Create("B2"))
.Remove(_node2, "b")
.SetItem(_node2, "d", GSet.Create("D2"));
// merge both ways
var merged1 = m1.Merge(m2);
merged1.Entries.Keys.Should().Contain("a");
merged1["a"].Elements.Should().BeEquivalentTo("A2");
merged1.Entries.Keys.Should().Contain("b");
merged1["b"].Elements.Should().BeEquivalentTo("B1");
merged1.Entries.Keys.Should().Contain("c");
merged1.Entries.Keys.Should().Contain("d");
merged1["d"].Elements.Should().BeEquivalentTo("D1", "D2");
var merged2 = m2.Merge(m1);
merged2.Entries.Keys.Should().Contain("a");
merged2["a"].Elements.Should().BeEquivalentTo("A2");
merged2.Entries.Keys.Should().Contain("b");
merged2["b"].Elements.Should().BeEquivalentTo("B1");
merged2.Entries.Keys.Should().Contain("c");
merged2.Entries.Keys.Should().Contain("d");
merged2["d"].Elements.Should().BeEquivalentTo("D1", "D2");
}
public void ORDictionary_must_not_have_anomalies_for_remove_with_update_scenario_and_deltas_5()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node1, "b", GSet.Create("B"));
var m2 = ORDictionary.Create(_node2, "c", GSet.Create("C"));
var merged1 = m1.Merge(m2);
var m3 = merged1.ResetDelta().Remove(_node1, "b");
var m4 = merged1.ResetDelta().SetItem(_node2, "b", GSet <string> .Empty.Add("B2"));
var merged2 = m3.Merge(m4);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
// note that B is not included, because it was removed in both timelines
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B2");
merged2.Entries["c"].Elements.Should().BeEquivalentTo("C");
var merged3 = m3.MergeDelta(m4.Delta);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
// note that B is not included, because it was removed in both timelines
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B2");
merged3.Entries["c"].Elements.Should().BeEquivalentTo("C");
}
public void A_ORDictionary_should_be_able_to_have_its_entries_correctly_merged_with_another_ORDictionary_with_overlaping_entries()
{
var m1 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node1, "a", GSet.Create("A1"))
.SetItem(_node1, "b", GSet.Create("B1"))
.Remove(_node1, "a")
.SetItem(_node1, "d", GSet.Create("D1"));
var m2 = ORDictionary <string, GSet <string> > .Empty
.SetItem(_node2, "c", GSet.Create("C2"))
.SetItem(_node2, "a", GSet.Create("A2"))
.SetItem(_node2, "b", GSet.Create("B2"))
.Remove(_node2, "b")
.SetItem(_node2, "d", GSet.Create("D2"));
// merge both ways
var merged1 = m1.Merge(m2);
Assert.Contains("a", merged1.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("A2"), merged1["a"].Elements);
Assert.Contains("b", merged1.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("B1"), merged1["b"].Elements);
Assert.Contains("c", merged1.Entries.Keys);
Assert.Contains("d", merged1.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("D1", "D2"), merged1["d"].Elements);
var merged2 = m2.Merge(m1);
Assert.Contains("a", merged2.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("A2"), merged2["a"].Elements);
Assert.Contains("b", merged2.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("B1"), merged2["b"].Elements);
Assert.Contains("c", merged2.Entries.Keys);
Assert.Contains("d", merged2.Entries.Keys);
Assert.Equal(ImmutableHashSet.Create("D1", "D2"), merged2["d"].Elements);
}
public void ReplicatorMessageSerializer_should_serialize_Replicator_message()
{
var ref1 = Sys.ActorOf(Props.Empty, "ref1");
var data1 = GSet.Create("a");
var delta1 = GCounter.Empty.Increment(_address1, 17).Increment(_address2, 2).Delta;
var delta2 = delta1.Increment(_address2, 1).Delta;
var delta3 = ORSet <string> .Empty.Add(_address1, "a").Delta;
var delta4 = ORMultiValueDictionary <string, string> .Empty.AddItem(_address1, "a", "b").Delta;
CheckSerialization(new Get(_keyA, ReadLocal.Instance));
CheckSerialization(new Get(_keyA, new ReadMajority(TimeSpan.FromSeconds(2)), "x"));
CheckSerialization(new Get(_keyA, new ReadMajority(TimeSpan.FromMilliseconds(((double)int.MaxValue) + 50)), "x"));
CheckSerialization(new Get(_keyA, new ReadMajority(TimeSpan.FromSeconds(2), 3), "x"));
_serializer.Invoking(s =>
{
s.ToBinary(new Get(_keyA, new ReadMajority(TimeSpan.FromMilliseconds(((double)int.MaxValue) * 3)), "x"));
})
.ShouldThrow <ArgumentOutOfRangeException>("Our protobuf protocol does not support timeouts larger than unsigned ints")
.Which.Message.Contains("unsigned int");
CheckSerialization(new GetSuccess(_keyA, null, data1));
CheckSerialization(new GetSuccess(_keyA, "x", data1));
CheckSerialization(new NotFound(_keyA, "x"));
CheckSerialization(new GetFailure(_keyA, "x"));
CheckSerialization(new Subscribe(_keyA, ref1));
CheckSerialization(new Unsubscribe(_keyA, ref1));
CheckSerialization(new Changed(_keyA, data1));
CheckSerialization(new DataEnvelope(data1));
CheckSerialization(new DataEnvelope(data1, ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, IPruningState>
{
{ _address1, new PruningPerformed(DateTime.UtcNow) },
{ _address3, new PruningInitialized(_address2, _address1.Address) },
})));
CheckSerialization(new Write("A", new DataEnvelope(data1), _address1));
CheckSerialization(WriteAck.Instance);
CheckSerialization(WriteNack.Instance);
CheckSerialization(DeltaNack.Instance);
CheckSerialization(new Read("A", _address1));
CheckSerialization(new ReadResult(new DataEnvelope(data1)));
CheckSerialization(new ReadResult(null));
CheckSerialization(new Internal.Status(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, ByteString>("A", ByteString.CopyFromUtf8("a")),
new KeyValuePair <string, ByteString>("B", ByteString.CopyFromUtf8("b")),
}), 3, 10, 17, 19));
CheckSerialization(new Internal.Status(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, ByteString>("A", ByteString.CopyFromUtf8("a")),
new KeyValuePair <string, ByteString>("B", ByteString.CopyFromUtf8("b")),
}), 3, 10, null, 19)); // (from scala code) can be None when sending back to a node of version 2.5.21
CheckSerialization(new Gossip(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, DataEnvelope>("A", new DataEnvelope(data1)),
new KeyValuePair <string, DataEnvelope>("B", new DataEnvelope(GSet.Create("b").Add("c"))),
}), true, 17, 19));
CheckSerialization(new Gossip(ImmutableDictionary.CreateRange(new[]
{
new KeyValuePair <string, DataEnvelope>("A", new DataEnvelope(data1)),
new KeyValuePair <string, DataEnvelope>("B", new DataEnvelope(GSet.Create("b").Add("c"))),
}), true, null, 19)); // (from scala code) can be None when sending back to a node of version 2.5.21
CheckSerialization(new DeltaPropagation(_address1, true,
ImmutableDictionary.CreateRange(new Dictionary <string, Delta>
{
{ "A", new Delta(new DataEnvelope(delta1), 1, 1) },
{ "B", new Delta(new DataEnvelope(delta2), 3, 5) },
{ "C", new Delta(new DataEnvelope(delta3), 1, 1) },
{ "DC", new Delta(new DataEnvelope(delta4), 1, 1) }
})));
CheckSerialization(new DurableDataEnvelope(data1));
var pruning = ImmutableDictionary.CreateRange(new Dictionary <UniqueAddress, IPruningState>
{
{ _address1, new PruningPerformed(DateTime.UtcNow) },
{ _address3, new PruningInitialized(_address2, _address1.Address) },
});
var deserializedDurableDataEnvelope = CheckSerialization(
new DurableDataEnvelope(new DataEnvelope(data1, pruning, new SingleVersionVector(_address1, 13))));
var expectedPruning = pruning
.Where(kvp => kvp.Value is PruningPerformed)
.ToDictionary(k => k.Key, v => v.Value);
deserializedDurableDataEnvelope.DataEnvelope.Pruning.ShouldAllBeEquivalentTo(expectedPruning);
deserializedDurableDataEnvelope.DataEnvelope.DeltaVersions.Count.Should().Be(0);
}
public override void ComputeFreeVariables(GSet<object>/*!*/ freeVars) { Contract.Assert(false);throw new cce.UnreachableException(); }
public void ReplicatedDataSerializer_should_serialize_ORDictionary()
{
CheckSerialization(ORDictionary <string, GSet <string> > .Empty);
CheckSerialization(ORDictionary <string, GSet <string> > .Empty.SetItem(_address1, "a", GSet.Create("A")));
CheckSerialization(ORDictionary <IActorRef, GSet <string> > .Empty.SetItem(_address1, TestActor, GSet.Create("A")));
CheckSerialization(ORDictionary <string, GSet <string> > .Empty.SetItem(_address1, "a", GSet.Create("A")).SetItem(_address2, "b", GSet.Create("B")));
}
public void ORDictionary_must_work_with_delta_coalescing_scenario_1()
{
var m1 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node1, "b", GSet.Create("B"));
var m2 = m1.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"));
var merged1 = m1.Merge(m2);
merged1.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged1.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3");
var merged2 = m1.MergeDelta(m2.Delta);
merged2.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged2.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3");
var m3 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m4 = m3.ResetDelta().SetItem(_node2, "b", GSet.Create("B2")).SetItem(_node2, "b", GSet.Create("B3"));
var merged3 = m3.Merge(m4);
merged3.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged3.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var merged4 = m3.MergeDelta(m4.Delta);
merged4.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged4.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var m5 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m6 = m5.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B3"))
.AddOrUpdate(_node2, "b", GSet <string> .Empty, x => x.Add("B4"));
var merged5 = m5.Merge(m6);
merged5.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged5.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3", "B4");
var merged6 = m5.MergeDelta(m6.Delta);
merged6.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged6.Entries["b"].Elements.Should().BeEquivalentTo("B", "B2", "B3", "B4");
var m7 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m8 = m7.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.SetItem(_node2, "d", GSet.Create("D"))
.SetItem(_node2, "b", GSet.Create("B3"));
var merged7 = m7.Merge(m8);
merged7.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged7.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
merged7.Entries["d"].Elements.Should().BeEquivalentTo("D");
var merged8 = m7.MergeDelta(m8.Delta);
merged8.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged8.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
merged8.Entries["d"].Elements.Should().BeEquivalentTo("D");
var m9 = ORDictionary.Create(_node1, "a", GSet.Create("A")).SetItem(_node2, "b", GSet.Create("B"));
var m10 = m9.ResetDelta()
.SetItem(_node2, "b", GSet.Create("B2"))
.SetItem(_node2, "d", GSet.Create("D"))
.Remove(_node2, "d")
.SetItem(_node2, "b", GSet.Create("B3"));
var merged9 = m9.Merge(m10);
merged9.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged9.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
var merged10 = m9.MergeDelta(m10.Delta);
merged10.Entries["a"].Elements.Should().BeEquivalentTo("A");
merged10.Entries["b"].Elements.Should().BeEquivalentTo("B", "B3");
}
