public static void Verify(PtrIntDict *self)
{
Should.NotNull("self", self);
Should.InRange("self->level", self->level, 0, Const.Lens.Length - 1);
Should.Equal("self->len", self->len, Const.Lens[self->level]);
Should.InRange("self->count", self->count, 0, self->len);
Should.InRange("self->free", self->free, -1, self->len - 1);
Mem.Verify(self->entries);
Should.NotNull("self->arr", self->arr);
int len = self->len;
int count = self->count;
int j = 0;
for (int i = 0; i < len; i += 1)
{
var entry = self->entries + i;
if (entry->val != null) // a real key
{
j += 1;
}
}
Should.Equal("j", j, count);
int freeCount = len - count;
int free = self->free;
while (free != -1)
{
freeCount -= 1;
free = self->entries[free].next;
}
Should.Zero("freeCount", freeCount);
j = 0;
for (int i = 0; i < len; i += 1)
{
int idx = self->arr[i];
while (idx != -1)
{
var entry = self->entries + idx;
Should.Equal("entry->hash % len", (uint)entry->hash % len, i);
j += 1;
idx = entry->next;
}
}
// Fdb.Dump(self->arr, self->len * IntSize);
// Fdb.Dump(self->entries, self->len * EntrySize, EntrySize);
Should.Equal("j", j, count);
}
public static void Verify(Pool *self)
{
Should.NotNull("self", self);
Should.TypeEqual("self", self->type, Type);
Should.GreaterThanZero("self->len", self->len);
Should.Equal("self->HeadSize", HeadSize, 3 * sizeof(int));
Should.Equal("self->TailSize", TailSize, sizeof(int));
int len = Mem.Verify(self->arr);
Should.Equal("self->len", self->len, len);
// Fdb.Dump(self->arr, len);
byte *arr = self->arr;
int * head;
head = (int *)(arr + self->len - HeadSize);
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
head = (int *)arr;
Should.Equal("firstHead->prev", head[0], -1); // head.prev = -1
Should.Equal("firstHead->size", head[2], 0); // head.size = 0
Should.Equal("firstTail->size", head[3], -1); // tail.size = -1
int curFree = head[1], lastFree = 0;
var dict = new System.Collections.Generic.Dictionary <int, int>();
while (curFree != -1)
{
head = (int *)(arr + curFree);
Should.Equal("head" + curFree + "->prev", head[0], lastFree);
Should.Equal("tail->size", *(int *)((byte *)head + HeadSize + head[2]), head[2]);
dict.Add(curFree, head[2]);
lastFree = curFree;
curFree = head[1];
}
head = (int *)(arr + HeadSize + TailSize);
int *end = (int *)(arr + self->len);
while (head < end)
{
int pos = (int)((byte *)head - self->arr);
int prev = head[0], next = head[1], size = head[2];
int *tail = (int *)((byte *)head + HeadSize + size);
if (tail < end)
{
int tailVal = tail[0];
if (tailVal == -1) // in use
{
Should.False("dict.ContainsKey(pos)", dict.ContainsKey(pos));
Should.Equal("prev", prev, -1);
Should.Equal("next", next, -1);
Should.GreaterThanZero("size", size);
}
else // free
{
Should.True("dict.ContainsKey(pos)" + pos, dict.ContainsKey(pos));
Should.GreaterThanOrEqualTo("prev", prev, 0);
Should.GreaterThanOrEqualTo("next", next, -1);
Should.Equal("size", size, dict[pos]);
dict.Remove(pos);
}
}
else // head is end sentinel, no tail
{
Should.Equal("head", head, (int *)(arr + len - HeadSize));
Should.Equal("endHead->prev", head[0], -1); // head.prev = -1
Should.Equal("endHead->next", head[1], -1); // head.next = -1
Should.Equal("endHead->size", head[2], 0); // head.size = 0
}
head = (int *)((byte *)head + HeadSize + size + TailSize);
}
Should.Zero("dict.Count", dict.Count);
}
