public void GivenNotInRangeIndex_MustReturnTrue(int size, int index)
{
var slot = CreateSlot(size);
var inrange = BlockSlotsExtensions.IsInRange(slot, index);
Assert.IsFalse(inrange);
}
public async Task GetAll_MustReturnAllValue()
{
var slot = CreateSlot(10);
var data = await BlockSlotsExtensions.GetAllAsync(slot);
Assert.AreEqual(10, data.Length);
}
public async Task GotLoadEnumerable_ReturnLoadEnumerable(int start, int?end)
{
var slot = CreateSlot(10);
var enu = BlockSlotsExtensions.ToLoadEnumerable(slot, start, end).ToArray();
var count = Math.Max(0, (end ?? slot.Size) - start);
Assert.AreEqual(count, enu.Length);
foreach (var item in enu)
{
await item();
}
Assert.AreEqual(count, slot.GetCreatedValues().Count());
}
public async Task GivenNullValueToCreateMap_MustThrowException()
{
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.GetCreatedValues <object>(null).ToArray());
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.GetCreatedValueMap <object>(null));
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.IsInRange <object>(null, 1));
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.ToDataCursor <object>(null));
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.ToLoadEnumerable <object>(null).ToArray());
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.ToLoadEnumerable <object>(null, 0).ToArray());
Assert.ThrowsException <ArgumentNullException>(() => BlockSlotsExtensions.ToLoadEnumerable <object>(null, 0, 0).ToArray());
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => BlockSlotsExtensions.GetRangeAsync <object>(null, 0, 0));
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => BlockSlotsExtensions.GetAllAsync <object>(null));
}
public async Task GotCreatedValues_ReturnMustCreatedValues()
{
var slot = CreateSlot(10);
var val = BlockSlotsExtensions.GetCreatedValues(slot);
Assert.AreEqual(0, val.Count());
await slot.GetAsync(0);
await slot.GetAsync(1);
await slot.GetAsync(2);
val = BlockSlotsExtensions.GetCreatedValues(slot);
Assert.AreEqual(3, val.Count());
}
public async Task GotValueMap_ReturnMustDataToMap()
{
var slot = CreateSlot(10);
var map = BlockSlotsExtensions.GetCreatedValueMap(slot);
Assert.AreEqual(0, map.Count);
for (int i = 0; i < slot.Size; i++)
{
await slot.GetAsync(i);
}
map = BlockSlotsExtensions.GetCreatedValueMap(slot);
for (int i = 0; i < slot.Size; i++)
{
Assert.IsTrue(map.ContainsKey(i), i.ToString());
Assert.IsNotNull(map[i]);
}
}
public async Task GivenNotInRangeIndex_MustReturnTrue(int size, int left, int right)
{
var slot = CreateSlot(size);
var datas = await BlockSlotsExtensions.GetRangeAsync(slot, left, right);
Assert.AreEqual(right - left, datas.Length);
for (int i = 0; i < slot.Size; i++)
{
var val = slot[i];
if (i >= left && i < right)
{
Assert.IsNull(val);
}
else
{
Assert.AreEqual(val, datas[i - left]);
}
}
}
public async Task ToDataCursor_MustReturnACursor()
{
var slot = CreateSlot(10);
var cur = BlockSlotsExtensions.ToDataCursor(slot);
Assert.AreEqual(slot.Size, cur.Count);
var datas = new object[slot.Size];
for (int i = 0; i < cur.Count; i++)
{
await cur.MoveAsync(i);
datas[i] = cur.Current;
}
for (int i = 0; i < cur.Count; i++)
{
Assert.AreEqual(slot[i], datas[i], i.ToString());
}
}
public async Task GivenOutOfRange_MustThrowException(int size, int left, int right)
{
var slot = CreateSlot(size);
await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(() => BlockSlotsExtensions.GetRangeAsync(slot, left, right));
}
public void GotLoadEnumerableWithOutOfRange_MustThrowException(int start, int?end)
{
var slot = CreateSlot(10);
Assert.ThrowsException <ArgumentOutOfRangeException>(() => BlockSlotsExtensions.ToLoadEnumerable(slot, start, end).ToArray());
}
