mirror of
https://github.com/EQEmu/Server.git
synced 2026-05-17 03:08:26 +00:00
Change space indentation to tabs
This commit is contained in:
j883376
+14
-14
@@ -3,14 +3,14 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
|
||||
ADD_SUBDIRECTORY(cppunit)
|
||||
|
||||
SET(tests_sources
|
||||
main.cpp
|
||||
main.cpp
|
||||
)
|
||||
|
||||
SET(tests_headers
|
||||
fixed_memory_test.h
|
||||
fixed_memory_variable_test.h
|
||||
ipc_mutex_test.h
|
||||
memory_mapped_file_test.h
|
||||
fixed_memory_test.h
|
||||
fixed_memory_variable_test.h
|
||||
ipc_mutex_test.h
|
||||
memory_mapped_file_test.h
|
||||
)
|
||||
|
||||
ADD_EXECUTABLE(tests ${tests_sources} ${tests_headers})
|
||||
@@ -18,21 +18,21 @@ ADD_EXECUTABLE(tests ${tests_sources} ${tests_headers})
|
||||
TARGET_LINK_LIBRARIES(tests Common cppunit)
|
||||
|
||||
IF(MSVC)
|
||||
SET_TARGET_PROPERTIES(tests PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
|
||||
TARGET_LINK_LIBRARIES(tests "Ws2_32.lib")
|
||||
SET_TARGET_PROPERTIES(tests PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
|
||||
TARGET_LINK_LIBRARIES(tests "Ws2_32.lib")
|
||||
ENDIF(MSVC)
|
||||
|
||||
IF(MINGW)
|
||||
TARGET_LINK_LIBRARIES(tests "WS2_32")
|
||||
TARGET_LINK_LIBRARIES(tests "WS2_32")
|
||||
ENDIF(MINGW)
|
||||
|
||||
IF(UNIX)
|
||||
TARGET_LINK_LIBRARIES(tests "dl")
|
||||
TARGET_LINK_LIBRARIES(tests "z")
|
||||
TARGET_LINK_LIBRARIES(tests "m")
|
||||
TARGET_LINK_LIBRARIES(tests "rt")
|
||||
TARGET_LINK_LIBRARIES(tests "pthread")
|
||||
ADD_DEFINITIONS(-fPIC)
|
||||
TARGET_LINK_LIBRARIES(tests "dl")
|
||||
TARGET_LINK_LIBRARIES(tests "z")
|
||||
TARGET_LINK_LIBRARIES(tests "m")
|
||||
TARGET_LINK_LIBRARIES(tests "rt")
|
||||
TARGET_LINK_LIBRARIES(tests "pthread")
|
||||
ADD_DEFINITIONS(-fPIC)
|
||||
ENDIF(UNIX)
|
||||
|
||||
SET(EXECUTABLE_OUTPUT_PATH ../Bin)
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
|
||||
|
||||
SET(cppunit_sources
|
||||
collectoroutput.cpp
|
||||
collectoroutput.cpp
|
||||
compileroutput.cpp
|
||||
htmloutput.cpp
|
||||
missing.cpp
|
||||
@@ -13,7 +13,7 @@ SET(cppunit_sources
|
||||
)
|
||||
|
||||
SET(cppunit_headers
|
||||
cpptest-assert.h
|
||||
cpptest-assert.h
|
||||
cpptest-collectoroutput.h
|
||||
cpptest-compileroutput.h
|
||||
cpptest-htmloutput.h
|
||||
@@ -23,16 +23,16 @@ SET(cppunit_headers
|
||||
cpptest-textoutput.h
|
||||
cpptest-time.h
|
||||
cpptest.h
|
||||
missing.h
|
||||
missing.h
|
||||
utils.h
|
||||
winconfig.h
|
||||
winconfig.h
|
||||
)
|
||||
|
||||
ADD_LIBRARY(cppunit ${cppunit_sources} ${cppunit_headers})
|
||||
|
||||
|
||||
IF(UNIX)
|
||||
ADD_DEFINITIONS(-fPIC)
|
||||
ADD_DEFINITIONS(-fPIC)
|
||||
ENDIF(UNIX)
|
||||
|
||||
SET(LIBRARY_OUTPUT_PATH ../../Bin)
|
||||
|
||||
+189
-189
@@ -1,19 +1,19 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
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; version 2 of the License.
|
||||
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; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __EQEMU_TESTS_FIXED_MEMORY_H
|
||||
@@ -24,214 +24,214 @@
|
||||
#include "../common/Item.h"
|
||||
|
||||
class FixedMemoryHashTest : public Test::Suite {
|
||||
typedef void(FixedMemoryHashTest::*TestFunction)(void);
|
||||
typedef void(FixedMemoryHashTest::*TestFunction)(void);
|
||||
public:
|
||||
FixedMemoryHashTest() {
|
||||
size_ = EQEmu::FixedMemoryHashSet<Item_Struct>::estimated_size(72000, 190000);
|
||||
data_ = new uint8[size_];
|
||||
memset(data_, 0, size_);
|
||||
TEST_ADD(FixedMemoryHashTest::InitTest);
|
||||
TEST_ADD(FixedMemoryHashTest::LoadTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveTest);
|
||||
TEST_ADD(FixedMemoryHashTest::OverwriteTest);
|
||||
TEST_ADD(FixedMemoryHashTest::OverwriteRetrieveTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertAgainTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveAgainTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertBeginTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveBeginTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertEndTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveEndTest);
|
||||
}
|
||||
~FixedMemoryHashTest() {
|
||||
delete[] data_;
|
||||
}
|
||||
FixedMemoryHashTest() {
|
||||
size_ = EQEmu::FixedMemoryHashSet<Item_Struct>::estimated_size(72000, 190000);
|
||||
data_ = new uint8[size_];
|
||||
memset(data_, 0, size_);
|
||||
TEST_ADD(FixedMemoryHashTest::InitTest);
|
||||
TEST_ADD(FixedMemoryHashTest::LoadTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveTest);
|
||||
TEST_ADD(FixedMemoryHashTest::OverwriteTest);
|
||||
TEST_ADD(FixedMemoryHashTest::OverwriteRetrieveTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertAgainTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveAgainTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertBeginTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveBeginTest);
|
||||
TEST_ADD(FixedMemoryHashTest::InsertEndTest);
|
||||
TEST_ADD(FixedMemoryHashTest::RetrieveEndTest);
|
||||
}
|
||||
~FixedMemoryHashTest() {
|
||||
delete[] data_;
|
||||
}
|
||||
|
||||
private:
|
||||
void InitTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_, 72000, 190000);
|
||||
TEST_ASSERT(!hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 0);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(hash.empty());
|
||||
}
|
||||
private:
|
||||
void InitTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_, 72000, 190000);
|
||||
TEST_ASSERT(!hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 0);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(hash.empty());
|
||||
}
|
||||
|
||||
void LoadTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(!hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 0);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(hash.empty());
|
||||
}
|
||||
void LoadTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(!hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 0);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(hash.empty());
|
||||
}
|
||||
|
||||
void InsertTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Iron Sword");
|
||||
item.ID = 1001;
|
||||
hash.insert(1001, item);
|
||||
void InsertTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Iron Sword");
|
||||
item.ID = 1001;
|
||||
hash.insert(1001, item);
|
||||
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
|
||||
void RetrieveTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
void RetrieveTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
|
||||
Item_Struct item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
Item_Struct item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
|
||||
void OverwriteTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Steel Sword");
|
||||
item.ID = 1001;
|
||||
hash.insert(1001, item);
|
||||
void OverwriteTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Steel Sword");
|
||||
item.ID = 1001;
|
||||
hash.insert(1001, item);
|
||||
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
|
||||
void OverwriteRetrieveTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT((hash.max_size() == 72000));
|
||||
TEST_ASSERT(!hash.empty());
|
||||
void OverwriteRetrieveTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 1);
|
||||
TEST_ASSERT((hash.max_size() == 72000));
|
||||
TEST_ASSERT(!hash.empty());
|
||||
|
||||
Item_Struct item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
Item_Struct item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
|
||||
void InsertAgainTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Iron Sword");
|
||||
item.ID = 1000;
|
||||
hash.insert(1000, item);
|
||||
void InsertAgainTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Iron Sword");
|
||||
item.ID = 1000;
|
||||
hash.insert(1000, item);
|
||||
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 2);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 2);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
|
||||
void RetrieveAgainTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 2);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
void RetrieveAgainTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.size() == 2);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
}
|
||||
|
||||
void InsertBeginTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Bronze Sword");
|
||||
item.ID = 0;
|
||||
hash.insert(0, item);
|
||||
void InsertBeginTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Bronze Sword");
|
||||
item.ID = 0;
|
||||
hash.insert(0, item);
|
||||
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.size() == 3);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.size() == 3);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
|
||||
void RetrieveBeginTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.size() == 3);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
void RetrieveBeginTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.size() == 3);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
|
||||
item = hash[0];
|
||||
TEST_ASSERT(strcmp(item.Name, "Bronze Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 0);
|
||||
}
|
||||
item = hash[0];
|
||||
TEST_ASSERT(strcmp(item.Name, "Bronze Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 0);
|
||||
}
|
||||
|
||||
void InsertEndTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Jade Sword");
|
||||
item.ID = 190000;
|
||||
hash.insert(190000, item);
|
||||
void InsertEndTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
Item_Struct item;
|
||||
memset(&item, 0, sizeof(item));
|
||||
strcpy(item.Name, "Jade Sword");
|
||||
item.ID = 190000;
|
||||
hash.insert(190000, item);
|
||||
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(190000));
|
||||
TEST_ASSERT(hash.size() == 4);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(190000));
|
||||
TEST_ASSERT(hash.size() == 4);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
}
|
||||
|
||||
void RetrieveEndTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(190000));
|
||||
TEST_ASSERT(hash.size() == 4);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
void RetrieveEndTest() {
|
||||
EQEmu::FixedMemoryHashSet<Item_Struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(1000));
|
||||
TEST_ASSERT(hash.exists(1001));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(190000));
|
||||
TEST_ASSERT(hash.size() == 4);
|
||||
TEST_ASSERT(hash.max_size() == 72000);
|
||||
TEST_ASSERT(!hash.empty());
|
||||
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
Item_Struct item = hash[1000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Iron Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1000);
|
||||
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
item = hash[1001];
|
||||
TEST_ASSERT(strcmp(item.Name, "Steel Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 1001);
|
||||
|
||||
item = hash[0];
|
||||
TEST_ASSERT(strcmp(item.Name, "Bronze Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 0);
|
||||
item = hash[0];
|
||||
TEST_ASSERT(strcmp(item.Name, "Bronze Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 0);
|
||||
|
||||
item = hash[190000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Jade Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 190000);
|
||||
}
|
||||
item = hash[190000];
|
||||
TEST_ASSERT(strcmp(item.Name, "Jade Sword") == 0);
|
||||
TEST_ASSERT(item.ID == 190000);
|
||||
}
|
||||
private:
|
||||
uint8 *data_;
|
||||
size_t size_;
|
||||
uint8 *data_;
|
||||
size_t size_;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
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; version 2 of the License.
|
||||
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; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __EQEMU_TESTS_FIXED_MEMORY_VARIABLE_H
|
||||
@@ -23,111 +23,111 @@
|
||||
#include "../common/fixed_memory_variable_hash_set.h"
|
||||
|
||||
struct test_struct {
|
||||
char name[512];
|
||||
char name[512];
|
||||
};
|
||||
|
||||
class FixedMemoryVariableHashTest : public Test::Suite {
|
||||
typedef void(FixedMemoryVariableHashTest::*TestFunction)(void);
|
||||
typedef void(FixedMemoryVariableHashTest::*TestFunction)(void);
|
||||
public:
|
||||
FixedMemoryVariableHashTest() {
|
||||
size_ = 1024 + 12 + 2008;
|
||||
data_ = new uint8[size_];
|
||||
memset(data_, 0, size_);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InitTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::LoadTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertAgainTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveAgainTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertAgainFailTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveAgainFailTest);
|
||||
}
|
||||
~FixedMemoryVariableHashTest() {
|
||||
delete[] data_;
|
||||
}
|
||||
FixedMemoryVariableHashTest() {
|
||||
size_ = 1024 + 12 + 2008;
|
||||
data_ = new uint8[size_];
|
||||
memset(data_, 0, size_);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InitTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::LoadTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertAgainTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveAgainTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::InsertAgainFailTest);
|
||||
TEST_ADD(FixedMemoryVariableHashTest::RetrieveAgainFailTest);
|
||||
}
|
||||
~FixedMemoryVariableHashTest() {
|
||||
delete[] data_;
|
||||
}
|
||||
|
||||
private:
|
||||
void InitTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_, 501);
|
||||
TEST_ASSERT(!hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
private:
|
||||
void InitTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_, 501);
|
||||
TEST_ASSERT(!hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
|
||||
void LoadTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(!hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
void LoadTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(!hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
|
||||
void InsertTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Bill D.");
|
||||
void InsertTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Bill D.");
|
||||
|
||||
hash.insert(0, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
hash.insert(0, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
}
|
||||
|
||||
void RetrieveTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
void RetrieveTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(!hash.exists(501));
|
||||
|
||||
test_struct test = hash[0];
|
||||
TEST_ASSERT(strcmp(test.name, "Bill D.") == 0);
|
||||
}
|
||||
test_struct test = hash[0];
|
||||
TEST_ASSERT(strcmp(test.name, "Bill D.") == 0);
|
||||
}
|
||||
|
||||
void InsertAgainTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Jimmy P.");
|
||||
void InsertAgainTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Jimmy P.");
|
||||
|
||||
hash.insert(501, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
}
|
||||
hash.insert(501, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
}
|
||||
|
||||
void RetrieveAgainTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
void RetrieveAgainTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
|
||||
test_struct test = hash[501];
|
||||
TEST_ASSERT(strcmp(test.name, "Jimmy P.") == 0);
|
||||
}
|
||||
test_struct test = hash[501];
|
||||
TEST_ASSERT(strcmp(test.name, "Jimmy P.") == 0);
|
||||
}
|
||||
|
||||
void InsertAgainFailTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Tommy M.");
|
||||
void InsertAgainFailTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
test_struct test;
|
||||
memset(&test, 0, sizeof(test));
|
||||
strcpy(test.name, "Tommy M.");
|
||||
|
||||
try {
|
||||
hash.insert(500, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
} catch(std::exception&) { }
|
||||
try {
|
||||
hash.insert(500, reinterpret_cast<byte*>(&test), sizeof(test));
|
||||
} catch(std::exception&) { }
|
||||
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
TEST_ASSERT(!hash.exists(500));
|
||||
}
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
TEST_ASSERT(!hash.exists(500));
|
||||
}
|
||||
|
||||
void RetrieveAgainFailTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
TEST_ASSERT(!hash.exists(500));
|
||||
void RetrieveAgainFailTest() {
|
||||
EQEmu::FixedMemoryVariableHashSet<test_struct> hash(data_, size_);
|
||||
TEST_ASSERT(hash.exists(0));
|
||||
TEST_ASSERT(hash.exists(501));
|
||||
TEST_ASSERT(!hash.exists(500));
|
||||
|
||||
try {
|
||||
test_struct test = hash[500];
|
||||
TEST_ASSERT(false);
|
||||
} catch(std::exception&) { }
|
||||
}
|
||||
try {
|
||||
test_struct test = hash[500];
|
||||
TEST_ASSERT(false);
|
||||
} catch(std::exception&) { }
|
||||
}
|
||||
private:
|
||||
uint8 *data_;
|
||||
uint32 size_;
|
||||
uint8 *data_;
|
||||
uint32 size_;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
+41
-41
@@ -1,19 +1,19 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
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; version 2 of the License.
|
||||
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; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __EQEMU_TESTS_IPC_MUTEX_H
|
||||
@@ -23,42 +23,42 @@
|
||||
#include "../common/ipc_mutex.h"
|
||||
|
||||
class IPCMutexTest : public Test::Suite {
|
||||
typedef void(IPCMutexTest::*TestFunction)(void);
|
||||
typedef void(IPCMutexTest::*TestFunction)(void);
|
||||
public:
|
||||
IPCMutexTest() {
|
||||
TEST_ADD(IPCMutexTest::LockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::UnlockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::DoubleLockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::DoubleUnlockMutexTest);
|
||||
}
|
||||
IPCMutexTest() {
|
||||
TEST_ADD(IPCMutexTest::LockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::UnlockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::DoubleLockMutexTest);
|
||||
TEST_ADD(IPCMutexTest::DoubleUnlockMutexTest);
|
||||
}
|
||||
|
||||
~IPCMutexTest() {
|
||||
}
|
||||
~IPCMutexTest() {
|
||||
}
|
||||
|
||||
private:
|
||||
void LockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex1");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(mutex.Unlock());
|
||||
}
|
||||
private:
|
||||
void LockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex1");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(mutex.Unlock());
|
||||
}
|
||||
|
||||
void UnlockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex2");
|
||||
TEST_ASSERT(!mutex.Unlock());
|
||||
}
|
||||
void UnlockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex2");
|
||||
TEST_ASSERT(!mutex.Unlock());
|
||||
}
|
||||
|
||||
void DoubleLockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex3");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(!mutex.Lock());
|
||||
}
|
||||
void DoubleLockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex3");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(!mutex.Lock());
|
||||
}
|
||||
|
||||
void DoubleUnlockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex4");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(mutex.Unlock());
|
||||
TEST_ASSERT(!mutex.Unlock());
|
||||
}
|
||||
void DoubleUnlockMutexTest() {
|
||||
EQEmu::IPCMutex mutex("TestMutex4");
|
||||
TEST_ASSERT(mutex.Lock());
|
||||
TEST_ASSERT(mutex.Unlock());
|
||||
TEST_ASSERT(!mutex.Unlock());
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
+24
-24
@@ -1,19 +1,19 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
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; version 2 of the License.
|
||||
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; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
@@ -26,17 +26,17 @@
|
||||
#include "fixed_memory_variable_test.h"
|
||||
|
||||
int main() {
|
||||
try {
|
||||
std::ofstream outfile("test_output.txt");
|
||||
std::unique_ptr<Test::Output> output(new Test::TextOutput(Test::TextOutput::Verbose, outfile));
|
||||
Test::Suite tests;
|
||||
tests.add(new MemoryMappedFileTest());
|
||||
tests.add(new IPCMutexTest());
|
||||
tests.add(new FixedMemoryHashTest());
|
||||
tests.add(new FixedMemoryVariableHashTest());
|
||||
tests.run(*output, true);
|
||||
} catch(...) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
try {
|
||||
std::ofstream outfile("test_output.txt");
|
||||
std::unique_ptr<Test::Output> output(new Test::TextOutput(Test::TextOutput::Verbose, outfile));
|
||||
Test::Suite tests;
|
||||
tests.add(new MemoryMappedFileTest());
|
||||
tests.add(new IPCMutexTest());
|
||||
tests.add(new FixedMemoryHashTest());
|
||||
tests.add(new FixedMemoryVariableHashTest());
|
||||
tests.run(*output, true);
|
||||
} catch(...) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1,19 +1,19 @@
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
/* EQEMu: Everquest Server Emulator
|
||||
Copyright (C) 2001-2013 EQEMu Development Team (http://eqemulator.net)
|
||||
|
||||
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; version 2 of the License.
|
||||
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; version 2 of the License.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY except by those people which sell it, which
|
||||
are required to give you total support for your newly bought product;
|
||||
without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||||
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
||||
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, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef __EQEMU_TESTS_MEMORY_MAPPED_FILE_H
|
||||
@@ -23,38 +23,38 @@
|
||||
#include "../common/memory_mapped_file.h"
|
||||
|
||||
class MemoryMappedFileTest : public Test::Suite {
|
||||
typedef void(MemoryMappedFileTest::*TestFunction)(void);
|
||||
typedef void(MemoryMappedFileTest::*TestFunction)(void);
|
||||
public:
|
||||
MemoryMappedFileTest() {
|
||||
TEST_ADD(MemoryMappedFileTest::LoadAndZeroMMF)
|
||||
TEST_ADD(MemoryMappedFileTest::LoadExistingMMF)
|
||||
}
|
||||
MemoryMappedFileTest() {
|
||||
TEST_ADD(MemoryMappedFileTest::LoadAndZeroMMF)
|
||||
TEST_ADD(MemoryMappedFileTest::LoadExistingMMF)
|
||||
}
|
||||
|
||||
~MemoryMappedFileTest() {
|
||||
}
|
||||
~MemoryMappedFileTest() {
|
||||
}
|
||||
|
||||
private:
|
||||
void LoadAndZeroMMF() {
|
||||
EQEmu::MemoryMappedFile mmf("testfile.txt", 512);
|
||||
mmf.ZeroFile();
|
||||
TEST_ASSERT(mmf.Size() == 512);
|
||||
private:
|
||||
void LoadAndZeroMMF() {
|
||||
EQEmu::MemoryMappedFile mmf("testfile.txt", 512);
|
||||
mmf.ZeroFile();
|
||||
TEST_ASSERT(mmf.Size() == 512);
|
||||
|
||||
unsigned char *data = reinterpret_cast<unsigned char*>(mmf.Get());
|
||||
TEST_ASSERT(data != nullptr);
|
||||
unsigned char *data = reinterpret_cast<unsigned char*>(mmf.Get());
|
||||
TEST_ASSERT(data != nullptr);
|
||||
|
||||
*reinterpret_cast<uint32*>(data) = 562;
|
||||
}
|
||||
*reinterpret_cast<uint32*>(data) = 562;
|
||||
}
|
||||
|
||||
void LoadExistingMMF() {
|
||||
EQEmu::MemoryMappedFile mmf("testfile.txt");
|
||||
TEST_ASSERT(mmf.Size() == 512);
|
||||
void LoadExistingMMF() {
|
||||
EQEmu::MemoryMappedFile mmf("testfile.txt");
|
||||
TEST_ASSERT(mmf.Size() == 512);
|
||||
|
||||
unsigned char *data = reinterpret_cast<unsigned char*>(mmf.Get());
|
||||
TEST_ASSERT(data != nullptr);
|
||||
unsigned char *data = reinterpret_cast<unsigned char*>(mmf.Get());
|
||||
TEST_ASSERT(data != nullptr);
|
||||
|
||||
uint32 val = *reinterpret_cast<uint32*>(data);
|
||||
TEST_ASSERT(val == 562);
|
||||
}
|
||||
uint32 val = *reinterpret_cast<uint32*>(data);
|
||||
TEST_ASSERT(val == 562);
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user