public void ComplexKeyOfDifferentSizeCanBeSorted(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
trie.Add(new [] { 2, 10, 232 }, 10);
trie.Add(new [] { 3, 1 }, 1);
Assert.Equal(2, trie.Count);
var sortedEntries = trie.GetEntrySet().ToArray();
Assert.Equal(2, sortedEntries.Length);
//Checking values
Assert.Equal(10, sortedEntries[0].Item2);
Assert.Equal(1, sortedEntries[1].Item2);
//Checking keys
Assert.Equal(2, sortedEntries[0].Item1[0]);
Assert.Equal(10, sortedEntries[0].Item1[1]);
Assert.Equal(232, sortedEntries[0].Item1[2]);
//Checking keys
Assert.Equal(3, sortedEntries[1].Item1[0]);
Assert.Equal(1, sortedEntries[1].Item1[1]);
}
public void ValueCanBeAddedByDoubleKey(NodeContainerType t)
{
var trie = GetTrie(t);
trie.Add(1, 10, false);
trie.Add(2, 10, true);
Assert.False(trie.TryGetValue(1, out _));
Assert.False(trie.TryGetValue(2, out _));
Assert.False(trie.TryGetValue(0, out _));
var addedValue = -1;
trie.TryGetValue(1, out addedValue, false);
Assert.True(trie.TryGetValue(2, out addedValue, true));
Assert.Equal(1, trie.Count);
trie.Add(1, 11);
trie.Add(2, 12);
Assert.True(trie.TryGetValue(1, out _));
Assert.True(trie.TryGetValue(2, out _));
trie.TryGetValue(1, out _, false);
Assert.True(trie.TryGetValue(2, out _));
}
public void ComplexKeysCanBeSorted(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
trie.Add(new [] { 3, 1 }, 1);
trie.Add(new [] { 2, 10 }, 10);
Assert.Equal(2, trie.Count);
var missingValue = trie.GetValue(new [] { 3, 50 }, -1);
Assert.Equal(-1, missingValue);
Assert.Equal(1, trie.GetValue(new [] { 3, 1 }));
Assert.Equal(10, trie.GetValue(new [] { 2, 10 }));
var sortedEntries = trie.GetEntrySet().ToArray();
Assert.Equal(2, sortedEntries.Length);
Assert.Equal(10, sortedEntries[0].Item2);
Assert.Equal(1, sortedEntries[1].Item2);
Assert.Equal(2, sortedEntries[0].Item1[0]);
Assert.Equal(10, sortedEntries[0].Item1[1]);
Assert.Equal(3, sortedEntries[1].Item1[0]);
Assert.Equal(1, sortedEntries[1].Item1[1]);
}
public void KeyValuesCanBeSortedByKey(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 10000000);
for (int i = 100000; i > 0; i--)
{
trie.Add(i, i);
}
for (int i = 1; i <= 100000; i++)
{
var value = -1;
var hasKey = trie.TryGetValue(i, out value);
Assert.True(hasKey);
Assert.Equal(i, value);
}
var expectedKey = 1;
foreach (var(key, value) in trie.GetEntrySet())
{
Assert.Equal(1, key.Count);
var keyValue = key[0];
Assert.Equal(keyValue, value);
Assert.True(expectedKey == keyValue);
expectedKey++;
}
Assert.Equal(100001, expectedKey);
}
public PlugableBinaryTrie <int> GetTrie(NodeContainerType t, int?initialSize = null)
{
var size = initialSize ?? 90000;
if (t == NodeContainerType.ArrayBacked)
{
container = new ArrayBackedNodesContainer <int>(size);
}
else if (t == NodeContainerType.MemoryMappedBacked)
{
container = new MemoryMappedNodeContainer <int>("./gtrie.bin", size);
}
else if (t == NodeContainerType.GrowableArrayBacked)
{
container = new GrowableArrayBackedNodeContainer <int>(100);
}
else
{
container = new GrowableMemoryMappedNodeContainer <int>("./gtrie", "t{0}.bin", 100);
}
trie = new PlugableBinaryTrie <int>(container);
return(trie);
}
public Test(NodeContainerType ContainerType, int Count, int MinLength, int MaxLength, int DistinctValues)
{
this.ContainerType = ContainerType;
this.Count = Count;
this.MinLength = MinLength;
this.MaxLength = MaxLength;
this.DistinctValues = DistinctValues;
}
public void ValueCanBeAddedByKey0(NodeContainerType t)
{
var trie = GetTrie(t);
Assert.False(trie.TryGetValue(0, out int result));
trie.Add(0, 100);
var addedValue = -1;
Assert.True(trie.TryGetValue(0, out addedValue));
Assert.Equal(100, addedValue);
}
public void ValueCanRemoved(NodeContainerType t)
{
var trie = GetTrie(t);
trie.Add(1, 10);
Assert.True(trie.TryGetValue(1, out _));
Assert.True(trie.Count == 1);
Assert.True(trie.TryRemove(1));
Assert.Equal(0, trie.Count);
Assert.False(trie.TryRemove(1));
Assert.False(trie.TryGetValue(1, out _));
}
public void ItemsCanBeAddedAndRetrievedByKey(NodeContainerType t)
{
var trie = GetTrie(t);
Assert.Equal(0, trie.Count);
trie.Add(10, 5);
Assert.Equal(1, trie.Count);
var value = -1;
var hasKey = trie.TryGetValue(10, out value);
Assert.True(hasKey);
Assert.Equal(5, value);
}
public void UserFunctionCanBeInvokedOnNotExistingSimpleKeyAndAdeed(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
var isFunctionInvoked = false;
trie.DoWithValue(3, (hasValue, currentValue) => {
isFunctionInvoked = true;
Assert.False(hasValue);
return(1000);
});
Assert.True(isFunctionInvoked);
var newValue = trie.GetValue(3, -10);
Assert.Equal(1000, newValue);
}
public void UserFunctionCanBeInvokedOnExistingKeySimpleKey(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
trie.Add(3, 5);
var isFunctionInvoked = false;
trie.DoWithValue(3, (hasValue, currentValue) => {
isFunctionInvoked = true;
Assert.True(hasValue);
return(currentValue * 2);
});
Assert.True(isFunctionInvoked);
var newValue = trie.GetValue(3);
Assert.Equal(10, newValue);
}
public void KeysCanBeSortedWhileReusingKeysContainerForAllItems(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
trie.Add(5, 10);
trie.Add(2, 15);
Assert.Equal(2, trie.Count);
var entriesEnumerator = trie.GetEntrySet(true).GetEnumerator();
Assert.True(entriesEnumerator.MoveNext());
Assert.Equal(15, entriesEnumerator.Current.Item2);
Assert.Equal(1, entriesEnumerator.Current.Item1.Count);
Assert.Equal(2, entriesEnumerator.Current.Item1[0]);
Assert.True(entriesEnumerator.MoveNext());
Assert.Equal(10, entriesEnumerator.Current.Item2);
Assert.Equal(1, entriesEnumerator.Current.Item1.Count);
Assert.Equal(5, entriesEnumerator.Current.Item1[0]);
Assert.False(entriesEnumerator.MoveNext());
}
public void KeysWithSamePrefixAreSortedCorrectly(NodeContainerType t)
{
var trie = GetTrie(t, initialSize: 100000);
trie.Add(new[] { 1, 2, 3 }, 5);
trie.Add(new[] { 1, 2 }, 9);
var sortedKvp = trie.GetEntrySet().ToArray();
Assert.Equal(2, sortedKvp.Length);
Assert.Equal(9, sortedKvp[0].Item2);
Assert.Equal(2, sortedKvp[0].Item1.Count);
Assert.Equal(1, sortedKvp[0].Item1[0]);
Assert.Equal(2, sortedKvp[0].Item1[1]);
Assert.Equal(5, sortedKvp[1].Item2);
Assert.Equal(3, sortedKvp[1].Item1.Count);
Assert.Equal(1, sortedKvp[1].Item1[0]);
Assert.Equal(2, sortedKvp[1].Item1[1]);
Assert.Equal(3, sortedKvp[1].Item1[2]);
}
public IntTrieTest(NodeContainerType ContainerType, int Count, int MinLength, int MaxLength, int DistinctValues)
: base(ContainerType, Count, MinLength, MaxLength, DistinctValues)
{
intTrie = new Trie <int[], int, int>(ContainerType);
intTrie.WildCard = -999;
}
public StringTrieTest(NodeContainerType ContainerType, int Count, int MinLength, int MaxLength, int DistinctValues)
: base(ContainerType, Count, MinLength, MaxLength, DistinctValues)
{
myTrie = new Trie <string, char, int>(ContainerType);
myTrie.WildCard = '?';
}
public CompoundClassTrieTest(NodeContainerType ContainerType, int Count, int MinLength, int MaxLength, int DistinctValues)
: base(ContainerType, Count, MinLength, MaxLength, DistinctValues)
{
}
public Trie(NodeContainerType ContainerType)
{
Root = new TrieNode(this);// (ContainerType);
this.ContainerType = ContainerType;
}
