public void TestParticipantEventsCacheEdge()
{
var size = 10;
var testSize = 11;
var participants = new Dictionary <string, int>
{
{ "alice", 0 },
{ "bob", 1 },
{ "charlie", 2 }
};
var pec = new ParticipantEventsCache(size, participants, logger);
var items = new Dictionary <string, List <string> >();
foreach (var p in participants)
{
items.Add(p.Key, new List <string>());
}
for (var i = 0; i < testSize; i++)
{
foreach (var p in participants)
{
var item = $"{p.Key}:{i}";
pec.Add(p.Key, item, i);
var pitems = items[p.Key];
pitems.Add(item);
}
}
foreach (var p in participants)
{
var expected = items[p.Key].Skip(size).ToArray();
var(cached, err) = pec.Get(p.Key, size - 1);
Assert.Null(err);
cached.ShouldCompareTo(expected);
}
}
public InmemStore(Dictionary <string, int> participants, int cacheSize, ILogger logger)
{
var rts = new Dictionary <string, Root>();
foreach (var p in participants)
{
rts.Add(p.Key, Root.NewBaseRoot());
}
this.participants = participants;
this.cacheSize = cacheSize;
this.logger = logger.AddNamedContext("InmemStore");
eventCache = new LruCache <string, Event>(cacheSize, null, logger, "EventCache");
roundCache = new LruCache <int, RoundInfo>(cacheSize, null, logger, "RoundCache");
blockCache = new LruCache <int, Block>(cacheSize, null, logger, "BlockCache");
consensusCache = new RollingIndex <string>(cacheSize);
participantEventsCache = new ParticipantEventsCache(cacheSize, participants, logger);
Roots = rts;
lastRound = -1;
}
public void TestParticipantEventsCache()
{
var size = 10;
var testSize = 25;
var participants = new Dictionary <string, int>
{
{ "alice", 0 },
{ "bob", 1 },
{ "charlie", 2 }
};
var pec = new ParticipantEventsCache(size, participants, logger);
var items = new Dictionary <string, List <string> >();
foreach (var p in participants)
{
items[p.Key] = new List <string>();
}
for (var i = 0; i < testSize; i++)
{
foreach (var p in participants)
{
var item = $"{p.Key}:{i}";
pec.Add(p.Key, item, i);
var pitems = items[p.Key];
pitems.Add(item);
items[p.Key] = pitems;
}
}
// GET ITEM ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
foreach (var p in participants)
{
var index1 = 9;
var(_, err) = pec.GetItem(p.Key, index1);
Assert.Equal(StoreErrorType.TooLate, err.StoreErrorType);
//--
var index2 = 15;
var expected2 = items[p.Key][index2];
var(actual2, err2) = pec.GetItem(p.Key, index2);
Assert.Null(err2);
actual2.ShouldCompareTo(expected2);
//--
var index3 = 27;
var expected3 = new string[] { };
var(actual3, err3) = pec.Get(p.Key, index3);
actual3.ShouldCompareTo(expected3);
}
// KNOWN ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
var known = pec.Known();
foreach (var(p, k) in known)
{
var expectedLastIndex = testSize - 1;
if (k != expectedLastIndex)
{
throw new Exception(string.Format("Known[{0}] should be {1}, not {2}", p, expectedLastIndex, k));
}
}
// GET ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
foreach (var p in participants)
{
var(_, err) = pec.Get(p.Key, 0);
Assert.Equal(StoreErrorType.TooLate, err.StoreErrorType);
//--
var skipIndex = 9;
var expected = items[p.Key].Skip(skipIndex + 1).ToArray();
var(cached, errc1) = pec.Get(p.Key, skipIndex);
Assert.Null(errc1);
cached.ShouldCompareTo(expected);
//--
var skipIndex2 = 15;
var expected2 = items[p.Key].Skip(skipIndex2 + 1).ToArray();
var(cached2, errc2) = pec.Get(p.Key, skipIndex2);
Assert.Null(errc2);
cached2.ShouldCompareTo(expected2);
//--
var skipIndex3 = 27;
var expected3 = new string[] { };
var(cached3, errc3) = pec.Get(p.Key, skipIndex3);
Assert.Null(errc3);
cached3.ShouldCompareTo(expected3);
}
}
