mirror of
https://github.com/grumpycoders/pcsx-redux.git
synced 2025-04-02 10:41:54 -04:00
222 lines
7.1 KiB
C++
222 lines
7.1 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (c) Electronic Arts Inc. All rights reserved.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "EASTLTest.h"
|
|
#include <EASTL/utility.h>
|
|
#include <EASTL/bonus/list_map.h>
|
|
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push, 0)
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
|
|
|
|
// We would like to use the generic EASTLTest VerifySequence function, but it's not currently ready to deal
|
|
// with non-POD types. That can probably be solved, but in the meantime we implement a custom function here.
|
|
template <typename T1, typename T2>
|
|
bool VerifyListMapSequence(const char* pName,
|
|
eastl::list_map<T1, T2>& listMap,
|
|
T1 t1End, T2,
|
|
T1 t10 = 0, T2 t20 = 0,
|
|
T1 t11 = 0, T2 t21 = 0,
|
|
T1 t12 = 0, T2 t22 = 0,
|
|
T1 t13 = 0, T2 t23 = 0,
|
|
T1 t14 = 0, T2 t24 = 0,
|
|
T1 t15 = 0, T2 t25 = 0)
|
|
{
|
|
typename eastl::list_map<T1, T2>::iterator it = listMap.begin();
|
|
|
|
if(t10 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t10 || it->second != t20)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 0); return false; }
|
|
++it;
|
|
|
|
if(t11 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t11 || it->second != t21)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 1); return false; }
|
|
++it;
|
|
|
|
if(t12 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t12 || it->second != t22)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 2); return false; }
|
|
++it;
|
|
|
|
if(t13 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t13 || it->second != t23)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 3); return false; }
|
|
++it;
|
|
|
|
if(t14 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t14 || it->second != t24)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 4); return false; }
|
|
++it;
|
|
|
|
if(t15 == t1End)
|
|
return (it == listMap.end());
|
|
if(it->first != t15 || it->second != t25)
|
|
{ EASTLTest_Printf("[%s] Mismatch at index %d\n", pName, 5); return false; }
|
|
++it;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
int TestListMap()
|
|
{
|
|
int nErrorCount = 0;
|
|
|
|
{
|
|
typedef eastl::list_map<uint32_t, uint64_t> TestMapType;
|
|
typedef eastl::pair<uint32_t, uint64_t> ValueType; // We currently can't use TestMapType::value_type because its 'first' is const.
|
|
|
|
TestMapType testMap;
|
|
TestMapType::iterator iter;
|
|
TestMapType::const_iterator c_iter;
|
|
TestMapType::reverse_iterator rIter;
|
|
TestMapType::const_reverse_iterator c_rIter;
|
|
TestMapType::iterator tempIter;
|
|
|
|
EATEST_VERIFY(testMap.empty());
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_front(ValueType(3, 1003));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_back(ValueType(4, 1004));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_back(ValueType(2, 1002));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_front(ValueType(6, 1006));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
EATEST_VERIFY(!testMap.empty());
|
|
EATEST_VERIFY(testMap.size() == 4);
|
|
|
|
EATEST_VERIFY(testMap.find(3) != testMap.end());
|
|
EATEST_VERIFY(testMap.find(5) == testMap.end());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 6, 1006, 3, 1003, 4, 1004, 2, 1002, UINT32_MAX, 0)));
|
|
|
|
iter = testMap.find(3);
|
|
EATEST_VERIFY((iter->first == 3) && ((++iter)->first == 4) && ((++iter)->first == 2));
|
|
|
|
rIter = testMap.rbegin();
|
|
EATEST_VERIFY((rIter->first == 2) && ((++rIter)->first == 4) && ((++rIter)->first == 3) && ((++rIter)->first == 6));
|
|
|
|
TestMapType::const_reference rFront = testMap.front();
|
|
EATEST_VERIFY(rFront.first == 6);
|
|
|
|
TestMapType::reference rBack = testMap.back();
|
|
EATEST_VERIFY(rBack.first == 2);
|
|
|
|
testMap.clear();
|
|
EATEST_VERIFY(testMap.empty());
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
iter = testMap.begin();
|
|
EATEST_VERIFY(iter == testMap.end());
|
|
|
|
testMap.push_back(ValueType(10, 1010));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_front(ValueType(8, 1008));
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_back(7, 1007);
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_front(9, 1009);
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.push_back(11, 1011LL);
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 9, 1009, 8, 1008, 10, 1010, 7, 1007, 11, 1011, UINT32_MAX, 0)));
|
|
|
|
testMap.pop_front();
|
|
EATEST_VERIFY(testMap.validate());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 8, 1008, 10, 1010, 7, 1007, 11, 1011, UINT32_MAX, 0)));
|
|
|
|
rIter = testMap.rbegin();
|
|
EATEST_VERIFY((rIter->first == 11 && ((++rIter)->first == 7) && ((++rIter)->first == 10) && ((++rIter)->first == 8)));
|
|
|
|
testMap.pop_back();
|
|
EATEST_VERIFY(testMap.validate());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 8, 1008, 10, 1010, 7, 1007, UINT32_MAX, 0)));
|
|
|
|
rIter = testMap.rbegin();
|
|
EATEST_VERIFY(((rIter)->first == 7) && ((++rIter)->first == 10) && ((++rIter)->first == 8));
|
|
|
|
tempIter = testMap.find(10);
|
|
EATEST_VERIFY(tempIter != testMap.end());
|
|
|
|
testMap.erase(10);
|
|
EATEST_VERIFY(testMap.validate());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 8, 1008, 7, 1007, UINT32_MAX, 0)));
|
|
|
|
EATEST_VERIFY(testMap.validate_iterator(testMap.find(8)) == (eastl::isf_valid | eastl::isf_current | eastl::isf_can_dereference));
|
|
EATEST_VERIFY(testMap.validate_iterator(testMap.find(30)) == (eastl::isf_valid | eastl::isf_current));
|
|
EATEST_VERIFY(testMap.validate_iterator(tempIter) == eastl::isf_none);
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.erase(20); // erasing an index not in use should still be safe
|
|
EATEST_VERIFY(testMap.validate());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 8, 1008, 7, 1007, UINT32_MAX, 0)));
|
|
|
|
EATEST_VERIFY(testMap.count(7) == 1);
|
|
EATEST_VERIFY(testMap.count(10) == 0);
|
|
EATEST_VERIFY(testMap.validate());
|
|
|
|
testMap.erase(testMap.find(8));
|
|
EATEST_VERIFY(testMap.validate());
|
|
EATEST_VERIFY((VerifyListMapSequence<uint32_t, uint64_t>("list_map::push_back", testMap, UINT32_MAX, 0, 7, 1007, UINT32_MAX, 0)));
|
|
|
|
testMap.erase(testMap.rbegin());
|
|
EATEST_VERIFY(testMap.empty());
|
|
EATEST_VERIFY(testMap.validate());
|
|
}
|
|
|
|
{
|
|
typedef eastl::list_map<eastl::string, uint32_t> TestStringMapType;
|
|
TestStringMapType testStringMap;
|
|
TestStringMapType::iterator strIter;
|
|
|
|
testStringMap.push_back(eastl::string("hello"), 750);
|
|
EATEST_VERIFY(testStringMap.size() == 1);
|
|
|
|
strIter = testStringMap.find_as("hello", eastl::less_2<eastl::string, const char*>());
|
|
EATEST_VERIFY(strIter != testStringMap.end());
|
|
EATEST_VERIFY(strIter->first == "hello");
|
|
EATEST_VERIFY(strIter->second == 750);
|
|
|
|
strIter = testStringMap.find_as("fake_string", eastl::less_2<eastl::string, const char*>());
|
|
EATEST_VERIFY(strIter == testStringMap.end());
|
|
EATEST_VERIFY(testStringMap.validate());
|
|
}
|
|
|
|
return nErrorCount;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|