Nemcio/CyberPanel
1
0
Fork 0
mirror of https://github.com/usmannasir/cyberpanel.git synced 2026-01-22 15:32:05 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
f7afeeeaab58a024d8bae1dca00a753fcb97a804
CyberPanel/install/openlitespeed-1.4.28/test/util/ghashtest.cpp
usmannasir a1ddb114bb suExec, Filemanager and bug Fixes.
2017-12-09 22:30:10 +05:00

368 lines
12 KiB
C++
Raw Blame History

/*****************************************************************************
* Open LiteSpeed is an open source HTTP server. *
* Copyright (C) 2013 - 2015 LiteSpeed Technologies, Inc. *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see http://www.gnu.org/licenses/. *
*****************************************************************************/
#ifdef RUN_TEST
#include "ghashtest.h"
#include <lsr/ls_xpool.h>
#include <util/ghash.h>
#include "unittest-cpp/UnitTest++.h"
static int plus_int(const void *pKey, void *pData, void *pUData)
{
((GHash *)pUData)->update(pKey, (void *)((char *)pData + (long)10));
return 0;
}
TEST(GHashTest_test)
{
GHash hash(10, NULL, NULL);
CHECK(hash.size() == 0);
CHECK(hash.capacity() == 13);
GHash::iterator iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK((long)iter->getKey() == 0);
CHECK((long)iter->getData() == 0);
CHECK(iter->getHKey() == 0);
CHECK(iter->getNext() == NULL);
CHECK(hash.size() == 1);
GHash::iterator iter1 = hash.insert((void *)13, (void *)13);
CHECK(iter1 != hash.end());
CHECK((long)iter1->getKey() == 13);
CHECK((long)iter1->getData() == 13);
CHECK(iter1->getHKey() == 13);
CHECK(iter1->getNext() == iter);
CHECK(hash.size() == 2);
GHash::iterator iter4 = hash.insert((void *)26, (void *)26);
CHECK(iter4 != hash.end());
CHECK((long)iter4->getKey() == 26);
CHECK((long)iter4->getData() == 26);
CHECK(iter4->getHKey() == 26);
CHECK(iter4->getNext() == iter1);
CHECK(hash.size() == 3);
GHash::iterator iter2 = hash.insert((void *)15, (void *)15);
CHECK(iter2 != hash.end());
CHECK((long)iter2->getKey() == 15);
CHECK((long)iter2->getData() == 15);
CHECK(iter2->getHKey() == 15);
CHECK(iter2->getNext() == NULL);
CHECK(hash.size() == 4);
GHash::iterator iter3;
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)15);
CHECK(iter3 == iter2);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)39);
CHECK(iter3 == NULL);
iter3 = hash.find((void *)28);
CHECK(iter3 == NULL);
iter3 = hash.begin();
CHECK(iter3 == iter4);
iter3 = hash.next(iter3);
CHECK(iter3 == iter1);
iter3 = hash.next(iter3);
CHECK(iter3 == iter);
iter3 = hash.next(iter3);
CHECK(iter3 == iter2);
iter3 = hash.next(iter3);
CHECK(iter3 == hash.end());
int n = hash.for_each2(hash.begin(), hash.end(), plus_int, &hash);
CHECK(n == 4);
CHECK((long)iter->getData() == 10);
CHECK((long)iter1->getData() == 23);
CHECK((long)iter2->getData() == 25);
CHECK((long)iter4->getData() == 36);
hash.erase(iter);
CHECK(hash.size() == 3);
CHECK(iter1->getNext() == NULL);
CHECK(iter4->getNext() == iter1);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == NULL);
iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK(hash.size() == 4);
CHECK(iter->getNext() == iter4);
CHECK(iter4->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
hash.erase(iter);
CHECK(hash.size() == 3);
CHECK(iter1->getNext() == NULL);
CHECK(iter4->getNext() == iter1);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == NULL);
iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK(hash.size() == 4);
CHECK(iter->getNext() == iter4);
CHECK(iter4->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
hash.erase(iter4);
CHECK(hash.size() == 3);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == NULL);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
CHECK(iter->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter4 = hash.insert((void *)26, (void *)26);
CHECK(iter4 != hash.end());
CHECK(iter4->getNext() == iter);
CHECK(iter->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
CHECK(hash.size() == 4);
GHash::iterator iter5 = hash.insert((void *)5, (void *)5);
CHECK(hash.capacity() == 13);
GHash::iterator iter6 = hash.insert((void *)6, (void *)6);
CHECK(hash.capacity() == 13);
GHash::iterator iter7 = hash.insert((void *)7, (void *)7);
CHECK(hash.capacity() == 13);
GHash::iterator iter8 = hash.insert((void *)8, (void *)8);
CHECK(hash.capacity() == 53);
CHECK(iter->getNext() == NULL);
CHECK(iter1->getNext() == NULL);
CHECK(iter2->getNext() == NULL);
CHECK(iter4->getNext() == NULL);
CHECK(iter5->getNext() == NULL);
CHECK(iter6->getNext() == NULL);
CHECK(iter7->getNext() == NULL);
CHECK(iter8->getNext() == NULL);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)15);
CHECK(iter3 == iter2);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)28);
CHECK(iter3 == NULL);
}
TEST(GHashPoolTest_test)
{
ls_xpool_t *pool = ls_xpool_new();
{
GHash hash(10, NULL, NULL, pool);
CHECK(hash.size() == 0);
CHECK(hash.capacity() == 13);
GHash::iterator iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK((long)iter->getKey() == 0);
CHECK((long)iter->getData() == 0);
CHECK(iter->getHKey() == 0);
CHECK(iter->getNext() == NULL);
CHECK(hash.size() == 1);
GHash::iterator iter1 = hash.insert((void *)13, (void *)13);
CHECK(iter1 != hash.end());
CHECK((long)iter1->getKey() == 13);
CHECK((long)iter1->getData() == 13);
CHECK(iter1->getHKey() == 13);
CHECK(iter1->getNext() == iter);
CHECK(hash.size() == 2);
GHash::iterator iter4 = hash.insert((void *)26, (void *)26);
CHECK(iter4 != hash.end());
CHECK((long)iter4->getKey() == 26);
CHECK((long)iter4->getData() == 26);
CHECK(iter4->getHKey() == 26);
CHECK(iter4->getNext() == iter1);
CHECK(hash.size() == 3);
GHash::iterator iter2 = hash.insert((void *)15, (void *)15);
CHECK(iter2 != hash.end());
CHECK((long)iter2->getKey() == 15);
CHECK((long)iter2->getData() == 15);
CHECK(iter2->getHKey() == 15);
CHECK(iter2->getNext() == NULL);
CHECK(hash.size() == 4);
GHash::iterator iter3;
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)15);
CHECK(iter3 == iter2);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)39);
CHECK(iter3 == NULL);
iter3 = hash.find((void *)28);
CHECK(iter3 == NULL);
iter3 = hash.begin();
CHECK(iter3 == iter4);
iter3 = hash.next(iter3);
CHECK(iter3 == iter1);
iter3 = hash.next(iter3);
CHECK(iter3 == iter);
iter3 = hash.next(iter3);
CHECK(iter3 == iter2);
iter3 = hash.next(iter3);
CHECK(iter3 == hash.end());
int n = hash.for_each2(hash.begin(), hash.end(), plus_int, &hash);
CHECK(n == 4);
CHECK((long)iter->getData() == 10);
CHECK((long)iter1->getData() == 23);
CHECK((long)iter2->getData() == 25);
CHECK((long)iter4->getData() == 36);
hash.erase(iter);
CHECK(hash.size() == 3);
CHECK(iter1->getNext() == NULL);
CHECK(iter4->getNext() == iter1);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == NULL);
iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK(hash.size() == 4);
CHECK(iter->getNext() == iter4);
CHECK(iter4->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
hash.erase(iter);
CHECK(hash.size() == 3);
CHECK(iter1->getNext() == NULL);
CHECK(iter4->getNext() == iter1);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == NULL);
iter = hash.insert((void *)0, (void *)0);
CHECK(iter != hash.end());
CHECK(hash.size() == 4);
CHECK(iter->getNext() == iter4);
CHECK(iter4->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
hash.erase(iter4);
CHECK(hash.size() == 3);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)26);
CHECK(iter3 == NULL);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
CHECK(iter->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
iter4 = hash.insert((void *)26, (void *)26);
CHECK(iter4 != hash.end());
CHECK(iter4->getNext() == iter);
CHECK(iter->getNext() == iter1);
CHECK(iter1->getNext() == NULL);
CHECK(hash.size() == 4);
GHash::iterator iter5 = hash.insert((void *)5, (void *)5);
CHECK(hash.capacity() == 13);
GHash::iterator iter6 = hash.insert((void *)6, (void *)6);
CHECK(hash.capacity() == 13);
GHash::iterator iter7 = hash.insert((void *)7, (void *)7);
CHECK(hash.capacity() == 13);
GHash::iterator iter8 = hash.insert((void *)8, (void *)8);
CHECK(hash.capacity() == 53);
CHECK(iter->getNext() == NULL);
CHECK(iter1->getNext() == NULL);
CHECK(iter2->getNext() == NULL);
CHECK(iter4->getNext() == NULL);
CHECK(iter5->getNext() == NULL);
CHECK(iter6->getNext() == NULL);
CHECK(iter7->getNext() == NULL);
CHECK(iter8->getNext() == NULL);
iter3 = hash.find((void *)0);
CHECK(iter3 == iter);
iter3 = hash.find((void *)13);
CHECK(iter3 == iter1);
iter3 = hash.find((void *)15);
CHECK(iter3 == iter2);
iter3 = hash.find((void *)26);
CHECK(iter3 == iter4);
iter3 = hash.find((void *)28);
CHECK(iter3 == NULL);
}
ls_xpool_delete(pool);
}
#endif
Reference in New Issue View Git Blame Copy Permalink