bool Test::test9()
{
DoubleLinkedList<int> list;
bool isPassed = false;
std::cerr << "Test 9: find returns false when value not in list: ";
//add values from 0 to TEST_SIZE-1 inclusively
for(int i=0; i<TEST_SIZE; i++)
{
list.pushFront(i);
}
//find value not in list
if( list.find(-1) == nullptr )
{
isPassed = true;
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}
bool Test::test5()
{
bool isPassed = false;
DoubleLinkedList<int> list;
std::cerr << "Test 5: size returns correct value after multiple pushBack:\n";
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
list.pushBack(i);
std::cerr.flush();
}
if( (list.size() == TEST_SIZE))
{
isPassed = true;
std::cerr << "PASSED" << std::endl;
}
else
{
isPassed = false;
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}
bool Test::test25()
{
DoubleLinkedList<int> list;
bool isPassed = false;
std::cerr << "Test 25: insertBehind on empty list throws exception: ";
try
{
list.insertBehind(0, 1);
}
catch(std::exception& e)
{
isPassed = true;
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return(isPassed);
}
void TestFirstAndLast(const DoubleLinkedList<int> & alist)
{
DoubleLinkedList<int> blist;
std::cout << "\n********** First and Last **********" << std::endl;
// Full List
std::cout << alist.First() << std::endl;
std::cout << alist.Last() << std::endl;
// Empty List
try
{
std::cout << blist.First() << std::endl;
}
catch (char * msg)
{
std::cout << msg << std::endl;
}
try
{
std::cout << blist.Last() << std::endl;
}
catch (char * msg)
{
std::cout << msg << std::endl;
}
}
void TestFirstAndLast(const DoubleLinkedList<int> & alist)
{
DoubleLinkedList<int> blist;
std::cout << "\n********** Testing: DoubleLinkedList First and Last **********" << std::endl;
std::cout << "\n********** Testing: First and Last with Full List **********" << std::endl;
std::cout << alist.First() << std::endl;
std::cout << alist.Last() << std::endl;
std::cout << "\n********** Testing: First with Empty List **********" << std::endl;
try
{
std::cout << blist.First() << std::endl;
}
catch (const char * msg)
{
std::cout << msg << std::endl;
}
std::cout << "\n********** Testing: First with Empty List **********" << std::endl;
try
{
std::cout << blist.Last() << std::endl;
}
catch (const char * msg)
{
std::cout << msg << std::endl;
}
}
void TestPurge(DoubleLinkedList<int> alist)
{
DoubleLinkedList<int> blist;
std::cout << "\n********** Testing: DoubleLinkedList Purge with Full List **********" << std::endl;
std::cout << "\n********** Testing: Before Purge Full List **********" << std::endl;
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
alist.Purge();
std::cout << "\n********** Testing: After Purge Full List **********" << std::endl;
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
std::cout << "\n********** Testing: DoubleLinkedList Purge with Empty List **********" << std::endl;
std::cout << "\n********** Testing: Before Purge Empty List **********" << std::endl;
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
alist.Purge();
std::cout << "\n********** Testing: After Purge Empty List **********" << std::endl;
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
}
void main()
{
// Tests Canonical Functions
DoubleLinkedList<int> alist; //ctor
DoubleLinkedList<int> blist(alist); //copy ctor
DoubleLinkedList<int> clist;
clist = blist; //= operator
// Tests Mutators
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
// Tests Methods
TestAppend(alist);
TestFirstAndLast(alist);
TestPrepend(alist);
TestPurge(alist);
TestInsertBefore();
TestInsertAfter();
TestExtract();
std::cout << "\n********** List Integrity **********" << std::endl;
alist.PrintForwards();
alist.PrintBackwards();
//The memory leak tool detects leaks because alist isn't being destroyed before it is called
//by calling the destructor or the following line of code, the list is destroyed and
//there are no leaks:
//alist.Purge();
_CrtDumpMemoryLeaks();
}
DoubleLinkedList<GraphNode *> Dijkstra(GraphNode *Start, GraphNode * End)
{
Map<GraphNode *, DijkstraHelperNode *> NodeHelperMap;
DoubleLinkedList<DijkstraHelperNode *> Visited;
MinHeap<DijkstraHelperNode *> OpenHeap;
DijkstraHelperNode *NewHelper = new DijkstraHelperNode();
NewHelper->m_Node = Start;
NewHelper->m_Cost = 0;
NodeHelperMap.Insert(Start, NewHelper);
OpenHeap.Insert(NewHelper);
while(!OpenHeap.IsEmpty())
{
DijkstraHelperNode *CurrentHelperNode = OpenHeap.PopTop();
assert(CurrentHelperNode != NULL);
GraphNode *CurrentGraphNode = CurrentHelperNode->m_Node;
assert(CurrentGraphNode != NULL);
DoubleLinkedList<GraphEdge *> *CurrendEdges = CurrentGraphNode->GetEdges();
DoubleListNode<GraphEdge *> *CurrentEdge = CurrentEdges.GetHead();
while(CurrentEdge != NULL)
{
GraphNode *OtherNode = CurrentEdge->m_End;
if(OtherNode == CurrentGraphNode)
{
OtherNode = CurrentEdge->m_Start;
}
assert(OtherNode != CurrentGraphNode);
DijkstraHelperNode *NodeHelper = NodeHelperMap.GetValue(OtherNode);
if(NodeHelper == NULL)
{
NodeHelper = new DijkstraHelperNode();
NodeHelper->m_Node = OtherNode;
NodeHelperMap.Insert(OtherNode, NodeHelper);
OpenHeap.Insert(NodeHelper);
}
int CostToNode = CurrentHelperNode->m_Cost + CurrentEdge->m_Cost;
if(CostToNode < NodeHelper->m_Cost)
{
NodeHelper->m_Cost = CostToNode;
NodeHelper->m_Previous = CurrentGraphNode;
OpenHeap.Update(NodeHelper);
}
if(OtherNode == End)
{
break;
}
}
}
DoubleLinkedList<GraphNode *> Path;
DijkstraHelperNode *EndHelper = NodeHelperMap.GetValue(End);
if(EndHelper != NULL)
{
DijkstraHelperNode *CurrentHelper = EndHelper;
while(CurrentHelper != NULL)
{
Path.AddFront(CurrentHelper->m_Node);
CurrentHelper = CurrentHelper->m_Previous;
}
}
}
bool Test::test11()
{
DoubleLinkedList<int> list;
bool isPassed = false;
redirectOS();
ss_redirect.clear();
list.printList();
restoreOS();
std::cerr << "Test 10: printList prints empty string for empty list: ";
//Convert captured output to string and check length
if(ss_redirect.str().length() == 0)
{
isPassed = true;
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return(isPassed);
}
void main()
{
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
// Tests Canonical Functions
DoubleLinkedList<int> alist; //ctor
DoubleLinkedList<int> blist(alist); //copy ctor
DoubleLinkedList<int> clist;
clist = blist; //= operator
// Tests Mutators
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
// Tests Methods
TestAppend(alist);
TestFirstAndLast(alist);
TestPrepend(alist);
TestPurge(alist);
TestInsertBefore();
TestInsertAfter();
TestExtract();
std::cout << "\n********** List Integrity **********" << std::endl;
alist.PrintForwards();
alist.PrintBackwards();
}
bool Test::test27()
{
DoubleLinkedList<int> list;
bool isPassed = false;
std::cerr << "Test 27: insertBehind of value not in list throws exception:\n";
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
list.pushBack(i);
std::cerr.flush();
}
try
{
list.insertBehind(-1, 1);
}
catch(std::exception& e)
{
isPassed = true;
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return(isPassed);
}
bool Test::test21()
{
DoubleLinkedList<int> list;
bool isPassed = false;
std::cerr << "Test 21: remove(value) where value is not in large list returns false\n";
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
list.pushBack(i);
std::cerr.flush();
}
if( !list.remove(-1) )
{
isPassed = true;
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return(isPassed);
}
bool Test::test17()
{
DoubleLinkedList<int> list;
bool isPassed = false;
int trackedSize = 0;
std::cerr << "Test 17: size preserved by remove(value) on populated list: ";
//Remove front on every 3rd iteration, add otherwise.
for(int i=0; i<TEST_SIZE; i++)
{
list.pushBack(i);
trackedSize++;
}
//remove every third value, track the size
for(int i=0; i<TEST_SIZE; i+=3)
{
list.remove(i);
trackedSize--;
}
if(trackedSize == list.size())
{
isPassed = true;
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}
void main()
{
// Tests Canonical Functions
DoubleLinkedList<int> alist; //ctor
DoubleLinkedList<int> blist(alist); //copy ctor
DoubleLinkedList<int> clist;
clist = blist; //= operator
// Tests Mutators
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
// Tests Methods
TestAppend(alist);
TestFirstAndLast(alist);
TestPrepend(alist);
TestPurge(alist);
TestInsertBefore();
TestInsertAfter();
TestExtract();
std::cout << "\n********** List Integrity **********" << std::endl;
alist.PrintForwards();
alist.PrintBackwards();
_asm nop;//added as a break point location;
}
inline void print(DoubleLinkedList &dll1, DoubleLinkedList &dll2,
DoubleLinkedList &dll3, DoubleLinkedList &dll4)
{
cout << "Size of the list1: " << dll1.getNumberElements() << endl;
cout << "Size of the list2: " << dll2.getNumberElements() << endl;
cout << "Size of the modList1: " << dll3.getNumberElements() << endl;
cout << "Size of the modList2: " << dll4.getNumberElements() << endl << endl;
}
void TestAppend(DoubleLinkedList<int> & alist)
{
std::cout << "\n********** Append **********" << std::endl;
alist.Append(5);
alist.Append(15);
alist.Append(25);
alist.Append(35);
}
void TestPurge(DoubleLinkedList<int> alist)
{
std::cout << "\n********** Purge **********" << std::endl;
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
alist.Purge();
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
}
void TestAppend(DoubleLinkedList<int> & alist)
{
std::cout << "\n********** Testing: DoubleLinkedList Append **********" << std::endl;
alist.Append(5);
alist.Append(15);
alist.Append(25);
alist.Append(35);
std::cout << alist.First() << std::endl;
std::cout << alist.Last() << std::endl;
}
bool Test::test1()
{
DoubleLinkedList<int> list;
std::cerr << "Test 1: size of empty list is zero: ";
if(list.size() == 0)
std::cerr << "PASSED" << std::endl;
else
std::cerr << "FAILED" << std::endl;
return (list.size() == 0);
}
bool Test::test19()
{
DoubleLinkedList<int> list;
bool isPassed = true;
int num=0;
std::cerr << "Test 19: order preserved by removeBack on populated list\n ";
//Add values 0-(TEST_SIZE-1)
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
list.pushBack(i);
std::cerr.flush();
}
//Remove half of the node
for(int i=0; i<TEST_SIZE/2; i++)
{
list.removeBack();
}
redirectOS();
ss_redirect.clear();
list.printList();
restoreOS();
//Check the order of the printed list
for(int i=0; i<TEST_SIZE/2; i++)
{
ss_redirect >> num;
if( i!=num )
{
isPassed = false;
}
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}
bool Test::test3()
{
DoubleLinkedList<int> list;
std::cerr << "Test 3: size returns correct value after 1 pushBack: ";
list.pushBack(5);
if(list.size() == 1)
std::cerr << "PASSED" << std::endl;
else
std::cerr << "FAILED" << std::endl;
return(list.size() == 1);
}
bool Test::test10()
{
DoubleLinkedList<int> list;
bool isPassed = true;
std::cerr << "Test 10: find returns point to node when value is in large list: \n";
//Add values 0-(TEST_SIZE-1)
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
//Add every other node using pushBack
if( i%2 == 0)
{
list.pushBack(i);
}
else
{
list.pushFront(i);
}
std::cerr.flush();
}
//find for all added values. Set flag if any value is not found
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tfinding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
Node<int>* temp = list.find(i);
if( temp == nullptr || temp->getValue() != i)
{
isPassed = false;
}
std::cerr.flush();
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}
bool Test::test2()
{
DoubleLinkedList<int> list;
list.pushFront(1);
std::cerr << "Test 2: size returns correct value after 1 add : ";
if(list.size() == 1)
std::cerr << "PASSED" << std::endl;
else
std::cerr << "FAILED" << std::endl;
return (list.size() == 1);
}
void set(int key, int value) {
// key found, update the data, and take to the front
if (cacheMap.find(key) != cacheMap.end() ){
Node *p = cacheMap[key];
p->value = value;
cacheList.TakeToBegin(cacheMap[key]);
}else{
// key not found, new a node to store data
cacheMap[key] = cacheList.NewAtBegin(key, value);
// if the capacity exceed, remove the last one.
if( cacheList.Size() > capacity) {
int key = cacheList.GetTailNode()->key;
cacheMap.erase(key);
cacheList.DeleteLast();
}
}
}
void UIAssetController::onButtonClick(BasicButton* pSrc)
{
// stop-command for units
if(pSrc == m_pStopButton) {
DoubleLinkedList<Unit*>* pUnitList = m_pUnitCommandDispatcher->getUnits();
ListNode<Unit*>* node = pUnitList->headNode();
while(node) {
if(node->item->getMovingLogic())
node->item->getMovingLogic()->clearTargets();
node = node->next;
}
return;
}
if (pSrc->getId() == 666)
{
// launch nuke
m_pSelector->setState(Selector::SELECTOR_NUKE);
changeState(STATE_NUKE);
return;
}
// build button
// check for insufficient funds
/*
AssetDef* def = (AssetDef*)pSrc->getRandomObject();
if(!def)
def = DefManager::getInstance()->getAssetDef(pSrc->getId());
*/
AssetDef* def = DefManager::getInstance()->getAssetDef(pSrc->getId());
if(m_pCurrentPlayer->getOre() < def->constructionCostOre) {
Console::error("Cannot build: not enough ore");
return;
}
if(def->constructionRequires && !m_pCurrentPlayer->hasAsset(def->constructionRequires)) {
Console::error("Cannot build: requirements not met");
return;
}
// take the ore first to prefent the situation where there is no funds when placed
m_CurrentBuildOreTaken = def->constructionCostOre;
m_pCurrentPlayer->modifyOre(-m_CurrentBuildOreTaken);
// start building
m_pCurrentBuildAssetDef = def;
m_pCurrentBuildButton = pSrc;
changeState(STATE_BUILDING_PLACEMENT);
}
bool Test::test14()
{
DoubleLinkedList<int> list;
bool isPassed = false;
std::cerr << "Test 14: removeBack returns false on empty list: ";
if( !list.removeBack() )
isPassed = true;
if(isPassed)
std::cerr << "PASSED" << std::endl;
else
std::cerr << "FAILED" << std::endl;
return (isPassed);
}
int main()
{
// Please put in every lab and assignment this term for ease of testing for memory leaks
//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
cout << "\n********** Testing: DoubleLinkedList default ctor **********\n";
DoubleLinkedList<int> alist; //ctor
cout << "\n********** Testing: DoubleLinkedList copy ctor with empty list **********\n";
DoubleLinkedList<int> blist(alist); //copy ctor
DoubleLinkedList<int> clist;
cout << "\n********** Testing: DoubleLinkedList op = **********\n";
clist = blist; //= operator
// Note that these functions are only available for testing.
// Will be removed from the list before going into production.
cout << "\n********** Testing: DoubleLinkedList getters **********\n";
std::cout << alist.getHead() << std::endl;
std::cout << alist.getTail() << std::endl;
//// Tests Methods
TestAppend(alist);
TestFirstAndLast(alist);
TestPrepend(alist);
std::cout << "\n********** Testing: DoubleLinkedList Copy ctor with Full List **********" << std::endl;
TestPurge(alist);
TestInsertBefore();
TestInsertAfter();
TestExtract();
std::cout << "\n********** Testing: List Integrity **********" << std::endl;
// Note these are also only for testing
alist.PrintForwards();
alist.PrintBackwards();
// OK NOW MAKE SURE IT WORKS THE SAME FOR COMPLEX DATA TYPES
// USE THE string CLASS
// Please put in every lab and assignment this term for ease of testing for memory leaks
system("pause");
return 0;
}
int get(int key) {
// The accessed node must be up-to-time -- take to the front
if (cacheMap.find(key) != cacheMap.end() ){
cacheList.TakeToBegin(cacheMap[key]);
return cacheMap[key]->value;
}
return -1;
}
bool Test::test28()
{
DoubleLinkedList<int> list;
bool isPassed = false;
int num1=0, num2=0;
std::cerr << "Test 28: insertAhead of list size 1 retains list order:";
list.pushBack(1);
try
{
list.insertAhead(1,0);
redirectOS();
ss_redirect.clear();
list.printList();
restoreOS();
ss_redirect >> num1;
ss_redirect >> num2;
if(num1 == 0 && num2 == 1)
{
isPassed = true;
}
}
catch(std::exception& e)
{
std::cerr << "\nException thrown! ";
isPassed = false;
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return(isPassed);
}
bool Test::test12()
{
DoubleLinkedList<int> list;
bool isPassed = true;
int num=0;
std::cerr << "Test 12: printList prints the contents of large list correctly \n";
//Add values 0-(TEST_SIZE-1)
for(int i=0; i<TEST_SIZE; i++)
{
std::cerr << '\r' << "\tAdding " << (i+1) << "/" << TEST_SIZE << " nodes. ";
list.pushBack(i);
std::cerr.flush();
}
redirectOS();
ss_redirect.clear();
list.printList();
restoreOS();
//Check the order of the numbers produced by the printList call
for(int i=0; i<TEST_SIZE; i++)
{
ss_redirect >> num;
if( i!=num )
{
isPassed = false;
}
}
if(isPassed)
{
std::cerr << "PASSED" << std::endl;
}
else
{
std::cerr << "FAILED" << std::endl;
}
return (isPassed);
}