public void TestC_Put_1()
{
int size = 16;
NativeDictionary <BitBag> nat = new NativeDictionary <BitBag>(size);
nat.Put("key1", new BitBag(1));
nat.Put("key2", new BitBag(2));
Assert.AreEqual(1, nat.Get("key1").value);
Assert.AreEqual(2, nat.Get("key2").value);
}
public void TestA_Get_2()
{
int size = 4;
string key1 = "one";
string key2 = "two";
string key3 = "three";
string key4 = "four";
NativeDictionary <int> nat = new NativeDictionary <int>(size);
nat.Put(key1, 614);
nat.Put(key2, 921);
nat.Put(key3, 53);
nat.Put(key4, 910);
int index1 = 0;
int index2 = 0;
int index3 = 0;
int index4 = 0;
for (int i = 0; i < size; i++)
{
if (nat.values[i] == 0)
{
continue;
}
else if (nat.slots[i] == key1)
{
index1 = i;
}
else if (nat.slots[i] == key2)
{
index2 = i;
}
else if (nat.slots[i] == key3)
{
index3 = i;
}
else if (nat.slots[i] == key4)
{
index4 = i;
}
else
{
break;
}
}
Assert.AreEqual(nat.values[index1], nat.Get("one"));
Assert.AreEqual(nat.values[index2], nat.Get("two"));
Assert.AreEqual(nat.values[index3], nat.Get("three"));
Assert.AreEqual(nat.values[index4], nat.Get("four"));
}
public void TestA_Put_5()
{
NativeDictionary <int> nat = new NativeDictionary <int>(16);
nat.Put("1", 1);
nat.Put("11", 2);
nat.Put("111", 3);
Assert.AreEqual(1, nat.Get("1"));
Assert.AreEqual(2, nat.Get("11"));
Assert.AreEqual(3, nat.Get("111"));
}
public void TestB_Put_5()
{
NativeDictionary <string> nat = new NativeDictionary <string>(16);
nat.Put("1", "1");
nat.Put("11", "2");
nat.Put("111", "3");
Assert.AreEqual("1", nat.Get("1"));
Assert.AreEqual("2", nat.Get("11"));
Assert.AreEqual("3", nat.Get("111"));
}
public static void TestsNativeDictionaryGet()
{
var testDict = new NativeDictionary <int>(3);
Assert.AreEqual(3, testDict.size);
testDict.Put("one", 1);
Assert.AreEqual("one", testDict.slots[1]);
Assert.AreEqual(1, testDict.values[1]);
Assert.AreEqual(1, testDict.Get("one"));
Assert.AreEqual(default(int), testDict.Get("two"));
}
public void TestC_Put_2()
{
int size = 16;
BitBag bb1 = new BitBag(1);
BitBag bb2 = new BitBag(2);
NativeDictionary <BitBag> nat = new NativeDictionary <BitBag>(size);
nat.Put("key1", bb1);
nat.Put("key2", bb2);
Assert.AreEqual(bb1, nat.Get("key1"));
Assert.AreEqual(bb2, nat.Get("key2"));
}
public void TestB_Put_4()
{
NativeDictionary <string> nat = new NativeDictionary <string>(16);
nat.Put("one", "1");
nat.Put("two", "5");
nat.Put("three", "12");
nat.Put("four", "20");
nat.Put("five", "34");
Assert.AreEqual("1", nat.Get("one"));
Assert.AreEqual("5", nat.Get("two"));
Assert.AreEqual("12", nat.Get("three"));
Assert.AreEqual("20", nat.Get("four"));
Assert.AreEqual("34", nat.Get("five"));
}
public void Get_in_Empty_Dict()
{
NativeDictionary <string> clients = new NativeDictionary <string>(3);
string key = "Laura";
Assert.IsNull(clients.Get(key));
}
public void TestB_Put_2()
{
NativeDictionary <string> nat = new NativeDictionary <string>(16);
nat.Put("one", "pet");
nat.Put("two", "fat");
nat.Put("three", "bat");
nat.Put("four", "dot");
nat.Put("five", "bed");
Assert.AreEqual("pet", nat.Get("one"));
Assert.AreEqual("fat", nat.Get("two"));
Assert.AreEqual("bat", nat.Get("three"));
Assert.AreEqual("dot", nat.Get("four"));
Assert.AreEqual("bed", nat.Get("five"));
}
public void TestA_Put_4()
{
NativeDictionary <int> nat = new NativeDictionary <int>(16);
nat.Put("one", 1);
nat.Put("two", 5);
nat.Put("three", 12);
nat.Put("four", 20);
nat.Put("five", 34);
Assert.AreEqual(1, nat.Get("one"));
Assert.AreEqual(5, nat.Get("two"));
Assert.AreEqual(12, nat.Get("three"));
Assert.AreEqual(20, nat.Get("four"));
Assert.AreEqual(34, nat.Get("five"));
}
public void Put()
{
NativeDictionary <int> dict = new NativeDictionary <int>(5);
dict.Put("1", 1);
Assert.True(dict.Get("1") == 1);
dict.Put("1", -1);
Assert.True(dict.Get("1") == -1);
dict.Put("2", 2);
Assert.True(dict.Get("1") == -1);
Assert.True(dict.Get("2") == 2);
Assert.True(dict.Get("3") == 0);
}
public void Try()
{
NativeDictionary <int, int> nativeDictionary = new NativeDictionary <int, int>(50, Allocator.Temp, (i, j) => i == j);
nativeDictionary.Add(1, 3);
nativeDictionary.Add(2, 4);
int result;
nativeDictionary.Get(1, out result);
Debug.Log(result);
nativeDictionary.Get(2, out result);
Debug.Log(result);
nativeDictionary.Get(3, out result);
Debug.Log(result);
nativeDictionary.Dispose();
}
public void TestA_Put_1()
{
NativeDictionary <int> nat = new NativeDictionary <int>(16);
nat.Put("one", 1);
Assert.AreEqual(1, nat.Get("one"));
}
public void TestB_Put_1()
{
NativeDictionary <string> nat = new NativeDictionary <string>(16);
nat.Put("one", "1");
Assert.AreEqual("1", nat.Get("one"));
}
public void Test_Get()
{
var dictionary = new NativeDictionary <int>(2);
dictionary.Put("a", 1);
dictionary.Put("k", 2);
var result = dictionary.Get("k");
Assert.AreEqual(2, result);
}
public void Test1_FirstStartTest()
{
int size = 16;
string key1 = "key1";
int item1 = 1;
string key2 = "key2";
string item2 = "1";
string key3 = "key3";
BitBag item3 = new BitBag(1);
string key4 = "key4";
BitBagE item4 = new BitBagE(1);
NativeDictionary <int> nat1 = new NativeDictionary <int>(size);
NativeDictionary <string> nat2 = new NativeDictionary <string>(size);
NativeDictionary <BitBag> nat3 = new NativeDictionary <BitBag>(size);
nat1.Put(key1, item1);
nat2.Put(key2, item2);
nat3.Put(key3, item3);
nat3.Put(key4, item4);
Assert.AreEqual(true, nat1.IsKey(key1));
Assert.AreEqual(item1, nat1.Get(key1));
Assert.AreEqual(true, nat2.IsKey(key2));
Assert.AreEqual(item2, nat2.Get(key2));
Assert.AreEqual(true, nat3.IsKey(key3));
Assert.AreEqual(item3, nat3.Get(key3));
Assert.AreEqual(true, nat3.IsKey(key4));
Assert.AreEqual(item4, nat3.Get(key4));
}
public void TestB_Put_7()
{
int size = 16;
NativeDictionary <string> nat = new NativeDictionary <string>(size);
nat.Put("key", null);
for (int i = 0; i < size; i++)
{
Assert.AreEqual(true, nat.values[i] == null);
if (nat.slots[i] != null)
{
Assert.AreEqual(true, nat.slots[i] != null);
nat.values[i] = "notNull";
break;
}
}
Assert.AreEqual("notNull", nat.Get("key"));
}
void RunTest()
{
NativeDictionary <int, int, IntEqual> dict = new NativeDictionary <int, int, IntEqual>(5, Allocator.Temp, new IntEqual());
for (int i = 0; i < 50; ++i)
{
dict.Add(i, i + 5);
}
for (int i = 0; i < 10; ++i)
{
dict.Remove(i);
}
Debug.Log(dict.Length);
for (int i = 0; i < 50; ++i)
{
int value;
if (dict.Get(i, out value))
{
Debug.Log(value);
}
}
}
public void TestA_Get_1()
{
int size = 16;
string key = "one";
NativeDictionary <int> nat = new NativeDictionary <int>(size);
nat.Put(key, 111);
int index = 0;
for (int i = 0; i < size; i++)
{
if (nat.values[i] != 111)
{
continue;
}
index = i;
break;
}
Assert.AreEqual(nat.values[index], nat.Get(key));
}
public void TestA_Put_3()
{
NativeDictionary <int> nat = new NativeDictionary <int>(10);
nat.Put("cat1", 1);
nat.Put("cat2", 3);
nat.Put("cat3", 5);
nat.Put("cat4", 7);
nat.Put("cat5", 9);
nat.Put("cat6", 11);
nat.Put("cat7", 13);
nat.Put("cat8", 15);
nat.Put("cat9", 17);
nat.Put("cat10", 19);
nat.Put("cat11", 21);
Assert.AreEqual(1, nat.Get("cat1"));
Assert.AreEqual(3, nat.Get("cat2"));
Assert.AreEqual(5, nat.Get("cat3"));
Assert.AreEqual(7, nat.Get("cat4"));
Assert.AreEqual(9, nat.Get("cat5"));
Assert.AreEqual(11, nat.Get("cat6"));
Assert.AreEqual(13, nat.Get("cat7"));
Assert.AreEqual(15, nat.Get("cat8"));
Assert.AreEqual(17, nat.Get("cat9"));
Assert.AreEqual(19, nat.Get("cat10"));
Assert.AreEqual(0, nat.Get("cat11"));
}
public void TestB_Put_3()
{
NativeDictionary <string> nat = new NativeDictionary <string>(10);
nat.Put("cat1", "pet");
nat.Put("cat2", "fat");
nat.Put("cat3", "bat");
nat.Put("cat4", "dot");
nat.Put("cat5", "bed");
nat.Put("cat6", "toy");
nat.Put("cat7", "pay");
nat.Put("cat8", "day");
nat.Put("cat9", "say");
nat.Put("cat10", "key");
nat.Put("cat11", "tea");
Assert.AreEqual("pet", nat.Get("cat1"));
Assert.AreEqual("fat", nat.Get("cat2"));
Assert.AreEqual("bat", nat.Get("cat3"));
Assert.AreEqual("dot", nat.Get("cat4"));
Assert.AreEqual("bed", nat.Get("cat5"));
Assert.AreEqual("toy", nat.Get("cat6"));
Assert.AreEqual("pay", nat.Get("cat7"));
Assert.AreEqual("day", nat.Get("cat8"));
Assert.AreEqual("say", nat.Get("cat9"));
Assert.AreEqual("key", nat.Get("cat10"));
Assert.AreEqual(null, nat.Get("cat11"));
}
public void Get_if_Dict_Has_Key()
{
NativeDictionary <string> clients = new NativeDictionary <string>(6);
string[] names = { "Laura", "Patrik", "Stuart", "Leonard", "Delcin" };
string[] categories = { "New", "Regular", "VIP", "Deptor" };
Console.WriteLine("=== LOG ===");
Console.WriteLine("{0}\n{1}\n{2}\n{3}\n{4}",
clients.HashFun(names[0]),
clients.HashFun(names[1]),
clients.HashFun(names[2]),
clients.HashFun(names[3]),
clients.HashFun(names[4]));
clients.Put(names[0], categories[1]);
clients.Put(names[1], categories[0]);
clients.Put(names[2], categories[3]);
clients.Put(names[3], categories[2]);
clients.Put(names[4], categories[1]);
Console.WriteLine("{0}\n{1}\n{2}\n{3}\n{4}",
clients.Get(names[0]),
clients.Get(names[1]),
clients.Get(names[2]),
clients.Get(names[3]),
clients.Get(names[4]));
Console.WriteLine("=== LOG END ===");
string actualValue = clients.Get(names[0]);
string actualValue2 = clients.Get(names[1]);
string actualValue3 = clients.Get(names[2]);
string expectedValue4 = "VIP";
string actualValue4 = clients.Get(names[3]);
string expectedValue5 = "Regular";
string actualValue5 = clients.Get(names[4]);
Assert.IsNull(actualValue);
Assert.IsNull(actualValue2);
Assert.IsNull(actualValue3);
Assert.AreEqual(expectedValue4, actualValue4);
Assert.AreEqual(expectedValue5, actualValue5);
Assert.IsNull(clients.Get("Hue"));
Assert.IsTrue(clients.size == 6);
}