Initial commit

This commit is contained in:
2026-04-03 00:22:39 -05:00
commit eca1e8c458
945 changed files with 218160 additions and 0 deletions

View File

@@ -0,0 +1,388 @@
/*
Test-ZHashMap.cpp
Author: James Russell <jcrussell@762studios.com>
Purpose: Unit Test the ZHashMap class.
Changelog:
12/18/2011 - Removed dependency on ZString (crertel)
03/13/2011 - creation (jcrussell)
*/
#include "ZUnitTest.hpp"
#include <ZSTL/ZHashMap.hpp>
#include <ZSTL/ZString.hpp>
static const char* testPutGetSize();
static const char* testBeginEnd();
static const char* testFind();
static const char* testClearEmpty();
static const char* testContainsKey();
static const char* testContainsValue();
static const char* testKeys();
static const char* testValues();
static const char* testMappings();
static const char* testErase();
static const char* testResize();
//List of unit tests
ZUnitTest ZHashMapUnitTests[] =
{
{ "ZHashMap: Put, Get, Size", testPutGetSize },
{ "ZHashMap: Begin, End", testBeginEnd },
{ "ZHashMap: Find", testFind },
{ "ZHashMap: Clear, Empty", testClearEmpty },
{ "ZHashMap: ContainsKey", testContainsKey },
{ "ZHashMap: ContainsValue", testContainsValue },
{ "ZHashMap: Keys", testKeys },
{ "ZHashMap: Values", testValues },
{ "ZHashMap: Mappings", testMappings },
{ "ZHashMap: Erase", testErase },
{ "ZHashMap: Resize", testResize }
};
//Now declare the ZUnitTestBlock associated with this.
DECLARE_ZTESTBLOCK(ZHashMap);
typedef ZHashMap<ZString, int> StringIntMap;
/*************************************************************************/
static const char* testPutGetSize()
{
StringIntMap map;
TASSERT(map.Size() == 0, "Size() returns non-zero value after initialization!");
map.Put("wakka", 24);
map.Put("ooga", 42);
TASSERT(map.Size() == 2, "Size() returned incorrect value after 2 calls to Put()!");
TASSERT(map.Get("wakka") == 24, "Get('wakka') retrieved wrong value after 2 calls to Put()!");
TASSERT(map.Get("ooga") == 42, "Get('ooga') retrieved wrong value after 2 calls to Put()!");
map.Put("booga", 2442);
map.Put("wooga", 4224);
TASSERT(map.Size() == 4, "Size() returned incorrect value after 4 calls to Put()!");
TASSERT(map.Get("wakka") == 24, "Get('wakka') retrieved wrong value after 4 calls to Put()!");
TASSERT(map.Get("ooga") == 42, "Get('ooga') retrieved wrong value after 4 calls to Put()!");
TASSERT(map.Get("booga") == 2442, "Get('booga') retrieved wrong value after 4 calls to Put()!");
TASSERT(map.Get("wooga") == 4224, "Get('wooga') retrieved wrong value after 4 calls to Put()!!");
//TODO - a bit more rigor
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testBeginEnd()
{
StringIntMap map;
bool found[4] = { false, false, false, false };
map.Put("wakka", 24);
map.Put("ooga", 42);
StringIntMap::Iterator itr_begin = map.Begin();
StringIntMap::Iterator itr_end = map.End();
for (; itr_begin != itr_end; itr_begin++)
{
if ((*itr_begin).Key == "wakka")
{
TASSERT((*itr_begin).Value == 24, "'wakka' iterator returned wrong value!");
TASSERT(found[0] == false, "Already found value 'wakka'!");
found[0] = true;
continue;
}
if ((*itr_begin).Key == "ooga")
{
TASSERT((*itr_begin).Value == 42, "'ooga' iterator returned wrong value!");
TASSERT(found[1] == false, "Already found value 'ooga'!");
found[1] = true;
continue;
}
TASSERT_FAIL("Iterator returned invalid value after two calls to Put()!");
}
TASSERT(found[0] && found[1], "Iterator did not find both values!");
found[0] = false;
found[1] = false;
map.Put("booga", 2442);
map.Put("wooga", 4224);
itr_begin = map.Begin();
while (itr_begin.HasCurrent())
{
if ((*itr_begin).Key == "wakka")
{
TASSERT((*itr_begin).Value == 24, "'wakka' iterator returned wrong value!");
TASSERT(found[0] == false, "Already found value 'wakka'!");
found[0] = true;
itr_begin.Next();
continue;
}
if ((*itr_begin).Key == "ooga")
{
TASSERT((*itr_begin).Value == 42, "'ooga' iterator returned wrong value!");
TASSERT(found[1] == false, "Already found value 'ooga'!");
found[1] = true;
itr_begin.Next();
continue;
}
if ((*itr_begin).Key == "booga")
{
TASSERT((*itr_begin).Value == 2442, "'booga' iterator returned wrong value!");
TASSERT(found[2] == false, "Already found value 'wooga'!");
found[2] = true;
itr_begin.Next();
continue;
}
if ((*itr_begin).Key == "wooga")
{
TASSERT((*itr_begin).Value == 4224, "'wooga' iterator returned wrong value!");
TASSERT(found[3] == false, "Already found value 'wooga'!");
found[3] = true;
itr_begin.Next();
continue;
}
TASSERT_FAIL("Iterator returned invalid value after four calls to Put()!");
}
TASSERT(found[0] && found[1] && found[2] && found[3], "Iterator did not find all four values!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testFind()
{
StringIntMap map;
map.Put("wakka", 24);
map.Put("ooga", 42);
StringIntMap::Iterator itr = map.Find("wakka");
TASSERT(itr != map.End(), "Find('wakka') returned End()!");
TASSERT((*itr).Key == "wakka", "Find('wakka') returned incorrect iterator key!");
TASSERT((*itr).Value == 24, "Find('wakka') returned incorrect iterator value!");
itr = map.Find("ooga");
TASSERT(itr != map.End(), "Find('ooga') returned End()!");
TASSERT((*itr).Key == "ooga", "Find('ooga') returned incorrect iterator key!");
TASSERT((*itr).Value == 42, "Find('ooga') returned incorrect iterator value!");
itr = map.Find("woogawakka");
TASSERT(itr == map.End(), "Find('oogawakka') returned a valid iterator!");
//TODO - a bit more rigor
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testClearEmpty()
{
StringIntMap map;
map.Put("wakka", 24);
map.Put("ooga", 42);
map.Put("booga", 2442);
map.Put("wooga", 4224);
TASSERT(map.Size() == 4, "Size() returned incorrect value after 4 calls to Put()!");
TASSERT(!map.Empty(), "Empty() returns true after 4 calls to Put()!");
map.Clear();
TASSERT(map.Size() == 0, "Size() returned non-zero value after call to Clear()!");
TASSERT(map.Empty(), "Empty() returns false after Clear()!");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testContainsKey()
{
StringIntMap map;
TASSERT(map.ContainsKey("wakka") == false, "ContainsKey() returned true when given empty set");
map.Put("oonga",2);
TASSERT(map.ContainsKey("wakka") == false, "ContainsKey() returned true when given set missing key");
map.Put("wakka",1);
TASSERT(map.ContainsKey("wakka"), "ContainsKey() returned false when given set containing key");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testContainsValue()
{
StringIntMap map;
map.Put("wakka", 1);
map.Put("wakkawakka", 2);
TASSERT(map.ContainsValue(3) == false, "ContainsValue() claims to contain a value it doesn't have");
TASSERT(map.ContainsValue(2) == true, "ContainsValue() claims to contain a value it does have");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testKeys()
{
StringIntMap map;
const char* test[3] = {"wakka", "wakkawakka", "wakkawakkawakka"};
map.Put(test[0], 11);
map.Put(test[1], 22);
map.Put(test[2], 33);
ZList<ZString> keys;
map.Keys(keys);
TASSERT(keys.Size() == 3, "Keys() did not return accurate sized list of keys in hashmap.");
int found = 0;
for (ZList<ZString>::Iterator itr = keys.Begin(); itr != keys.End(); ++itr)
{
ZString tofind = *itr;
for (int i = 0; i < 3; i++)
{
if (strcmp(tofind.Data(), test[i]) == 0)
found++;
}
}
TASSERT(found == 3, "Keys() did not return accurate list of keys for values in hashmap.");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testValues()
{
StringIntMap map;
int test[3] = {11, 22, 33};
map.Put("wakka", test[0]);
map.Put("wakkawakka", test[1]);
map.Put("wakkawakkawakka", test[2]);
ZList<int> values;
map.Values(values);
TASSERT(values.Size() == 3, "Values() did not return accurate sized list of values in hashmap.");
int found = 0;
for (ZList<int>::Iterator itr = values.Begin(); itr != values.End(); ++itr)
{
int tofind = *itr;
for (int i = 0; i < 3; i++)
{
if (tofind == test[i])
found++;
}
}
TASSERT(found == 3, "Values() did not return accurate list of values for values in hashmap.");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testMappings()
{
StringIntMap map;
map.Put("wakka", 11);
ZList< ZPair<ZString, int> > mappings;
map.Mappings(mappings);
TASSERT(mappings.Size() == 1, "Mappings() returned list of incorrect size for key/value pairs.n");
TASSERT( strcmp(mappings.Front().First.Data(), "wakka") == 0 && mappings.Front().Second == 11, "Mappings() returned incorrect key/value pair.");
//TODO - more rigor
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testErase()
{
StringIntMap map;
map.Put("wakka", 1);
TASSERT(map.ContainsValue(1) && map.ContainsKey("wakka"), "Map has somehow lost our value.");
map.Erase("wakka");
TASSERT(map.ContainsValue(1) == false && map.ContainsKey("wakka") == false, "Map claims key despite removal.");
return ZTEST_SUCCESS;
}
/*************************************************************************/
static const char* testResize()
{
StringIntMap map(5);
map.Put("wakka", 1);
map.Put("oonga", 2);
size_t wakkaBucket = (*map.Find("wakka")).HashMod;
size_t oongaBucket = (*map.Find("oonga")).HashMod;
StringIntMap::Iterator itr1 = map.Find("wakka");
StringIntMap::Iterator itr2 = map.Find("oonga");
TASSERT(itr1 != map.End(), "Could not find 'wakka' before resize!");
TASSERT(itr2 != map.End(), "Could not find 'oonga' before resize!");
map.Resize(11);
itr1 = map.Find("wakka");
itr2 = map.Find("oonga");
TASSERT(itr1 != map.End(), "Could not find 'wakka' after resize!");
TASSERT(itr2 != map.End(), "Could not find 'oonga' after resize!");
TASSERT((*itr1).HashMod != wakkaBucket, "ZHashMap did not move 'wakka' to another bucket!");
TASSERT((*itr2).HashMod != oongaBucket, "ZHashMap did not move 'oonga' to another bucket!");
//TODO - a bit more rigor
return ZTEST_SUCCESS;
}