public void Operations_SingleElement()
{
var key = "oren";
var tree = new ZFastTrieSortedSet <string, string>(binarize);
Assert.True(tree.Add(key, "eini"));
Assert.Equal(key, tree.FirstKey());
Assert.Equal(key, tree.LastKey());
Assert.True(tree.Contains(key));
string value;
Assert.True(tree.TryGet(key, out value));
// x+ = min{y ? S | y = x} (the successor of x in S) - Page 160 of [1]
// Therefore the successor of the key "oren" is greater or equal to "oren"
Assert.Equal(key, tree.SuccessorOrDefault(key));
Assert.Null(tree.SuccessorOrDefault("qu"));
// x- = max{y ? S | y < x} (the predecessor of x in S) - Page 160 of [1]
// Therefore the predecessor of the key "oren" is strictly less than "oren".
Assert.Null(tree.PredecessorOrDefault(key));
Assert.Null(tree.PredecessorOrDefault("aq"));
Assert.Equal(key, tree.PredecessorOrDefault("pq"));
ZFastTrieDebugHelpers.StructuralVerify(tree);
}
public void Operations_SingleBranchInsertion()
{
string smallestKey = "Ar";
string lesserKey = "Oren";
string greaterKey = "oren";
string greatestKey = "zz";
var tree = new ZFastTrieSortedSet <string, string>(binarize);
Assert.True(tree.Add(lesserKey, "eini"));
ZFastTrieDebugHelpers.DumpTree(tree);
Assert.True(tree.Add(greaterKey, "Eini"));
ZFastTrieDebugHelpers.DumpTree(tree);
ZFastTrieDebugHelpers.StructuralVerify(tree);
Assert.Equal(lesserKey, tree.FirstKey());
Assert.Equal(greaterKey, tree.LastKey());
Assert.True(tree.Contains(greaterKey));
Assert.True(tree.Contains(lesserKey));
string value;
Assert.True(tree.TryGet(lesserKey, out value));
Assert.True(tree.TryGet(greaterKey, out value));
Assert.False(tree.TryGet(greaterKey + "1", out value));
Assert.False(tree.TryGet("1", out value));
// x+ = min{y ? S | y = x} (the successor of x in S) - Page 160 of [1]
// Therefore the successor of the key "oren" is greater or equal to "oren"
Assert.Equal(lesserKey, tree.SuccessorOrDefault(lesserKey));
Assert.Equal(greaterKey, tree.SuccessorOrDefault(greaterKey));
Assert.Equal(greaterKey, tree.SuccessorOrDefault(lesserKey + "1"));
Assert.Null(tree.SuccessorOrDefault(greatestKey));
// x- = max{y ? S | y < x} (the predecessor of x in S) - Page 160 of [1]
// Therefore the predecessor of the key "oren" is strictly less than "oren".
Assert.Equal(lesserKey, tree.PredecessorOrDefault(greaterKey));
Assert.Null(tree.PredecessorOrDefault(lesserKey));
Assert.Null(tree.PredecessorOrDefault(smallestKey));
}
public void Structure_RandomTester()
{
int count = 1000;
int size = 5;
for (int i = 0; i < 1; i++)
{
var keys = new string[count];
var tree = new ZFastTrieSortedSet <string, string>(binarize);
var insertedKeys = new HashSet <string>();
var generator = new Random(i + size);
for (int j = 0; j < count; j++)
{
string key = GenerateRandomString(generator, size);
if (!tree.Contains(key))
{
tree.Add(key, key);
}
keys[j] = key;
insertedKeys.Add(key);
}
ZFastTrieDebugHelpers.StructuralVerify(tree);
generator = new Random(i + size + 1);
for (int j = 0; j < count; j++)
{
string key = GenerateRandomString(generator, size);
if (!insertedKeys.Contains(key))
{
Assert.False(tree.Remove(key));
}
}
generator = new Random(i + size);
for (int j = 0; j < count; j++)
{
string key = GenerateRandomString(generator, size);
bool removed = tree.Remove(key);
Assert.True(removed);
}
Assert.Equal(0, tree.Count);
}
}
public void Structure_CappedSizeInsertion(int seed, int size, int count)
{
var generator = new Random(seed);
var tree = new ZFastTrieSortedSet <string, string>(binarize);
var keys = new string[count];
for (int i = 0; i < count; i++)
{
string key = GenerateRandomString(generator, size);
if (!tree.Contains(key))
{
tree.Add(key, key);
}
keys[i] = key;
}
ZFastTrieDebugHelpers.StructuralVerify(tree);
}
