public void TestLiveDictionaryUnwrap()
{
LiveDictionary<int, Live<int>> x =
new[] {1, 2, 3, 4, 5}
.ToDictionary(i => i, i => i.ToLive())
.ToLiveDictionary();
var w = x.Unwrap<int, int, Live<int>>().ToIndependent();
w.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.UnorderedEqual(
new[]
{
KeyValuePair.Create(1, 1),
KeyValuePair.Create(2, 2),
KeyValuePair.Create(3, 3),
KeyValuePair.Create(4, 4),
KeyValuePair.Create(5, 5),
}));
Assert.IsTrue(s.Delta == null);
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Add(KeyValuePair.Create(0, 0.ToLive())),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.UnorderedEqual(
new[]
{
KeyValuePair.Create(1, 1),
KeyValuePair.Create(2, 2),
KeyValuePair.Create(3, 3),
KeyValuePair.Create(4, 4),
KeyValuePair.Create(5, 5),
KeyValuePair.Create(0, 0),
}));
Assert.IsTrue(s.Delta.Inserts.UnorderedEqual(
new[]
{
KeyValuePair.Create(0, 0),
}));
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Remove(x.ToArray().Single(i => i.Value.PublishValue == 3)),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.UnorderedEqual(
new[]
{
KeyValuePair.Create(1, 1),
KeyValuePair.Create(2, 2),
KeyValuePair.Create(4, 4),
KeyValuePair.Create(5, 5),
KeyValuePair.Create(0, 0),
}));
Assert.IsTrue(s.Delta.Deletes.UnorderedEqual(
new[]
{
KeyValuePair.Create(3, 3),
}));
});
w.States().Skip(1).Take(1).Check(
() => x.ToArray().Single(i => i.Key == 2).Value.PublishValue = -2,
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.UnorderedEqual(
new[]
{
KeyValuePair.Create(1, 1),
KeyValuePair.Create(2, -2),
KeyValuePair.Create(4, 4),
KeyValuePair.Create(5, 5),
KeyValuePair.Create(0, 0),
}));
Assert.IsTrue(s.Delta.Inserts.UnorderedEqual(
new[]
{
KeyValuePair.Create(2, -2),
}));
Assert.IsTrue(s.Delta.Deletes.UnorderedEqual(
new[]
{
KeyValuePair.Create(2, 2),
}));
});
}
public void TestLiveCollectionUnwrap()
{
var x = new[] { 1, 2, 3, 4, 5 }
.Select(i => i.ToLive(i))
.ToCollection()
.ToLiveCollection();
var w = x.Unwrap().ToIndependent();
w.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.UnorderedEqual(new[] { 1, 2, 3, 4, 5 }));
Assert.IsTrue(s.Delta == null);
Assert.AreEqual(5, s.LastUpdated);
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Add(0.ToLive(500), 1000),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.UnorderedEqual(new[] { 1, 2, 3, 4, 5, 0 }));
Assert.IsTrue(s.Delta.Inserts.UnorderedEqual(new[] { 0 }));
Assert.IsTrue(s.Delta.Deletes == null);
Assert.AreEqual(1000, s.LastUpdated);
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Remove(x.ToArray().Single(i => i.PublishValue == 3), 2000),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.UnorderedEqual(new[] { 1, 2, 4, 5, 0 }));
Assert.IsTrue(s.Delta.Inserts == null);
Assert.IsTrue(s.Delta.Deletes.UnorderedEqual(new[] { 3 }));
Assert.AreEqual(2000, s.LastUpdated);
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Connect(new[] { 10.ToLive(3000) }, 2900),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Reconnecting);
Assert.IsTrue(s.Inner.UnorderedEqual(new[] { 10 }));
Assert.IsTrue(s.Delta == null);
Assert.AreEqual(3000, s.LastUpdated);
});
}
public void TestLiveListUnwrap()
{
var x = new[] { 1, 2, 3, 4, 5 }
.Select(i => i.ToLive())
.ToList()
.ToLiveList();
var w = x.Unwrap<int>().ToIndependent();
w.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2, 3, 4, 5 }));
Assert.IsTrue(s.Delta == null);
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Add(6.ToLive()),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2, 3, 4, 5, 6 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 5,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 6 },
},
},
}, new IndexNodeComparer<int>()));
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.RemoveAt(2),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2, 4, 5, 6 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 2,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 3 },
},
},
}, new IndexNodeComparer<int>()));
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.Insert(0, 0.ToLive()),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 0, 1, 2, 4, 5, 6 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 0 },
},
},
}, new IndexNodeComparer<int>()));
});
w.States().Skip(1).Take(1).Check(
() => x.PublishInner.RemoveAt(1),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 0, 2, 4, 5, 6 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 1 },
},
},
}, new IndexNodeComparer<int>()));
});
}
