Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/WolfireGames/overgrowth.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/Source/UnitTests/block_allocator_tester.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'Source/UnitTests/block_allocator_tester.cpp')
-rw-r--r--Source/UnitTests/block_allocator_tester.cpp357
1 files changed, 165 insertions, 192 deletions
diff --git a/Source/UnitTests/block_allocator_tester.cpp b/Source/UnitTests/block_allocator_tester.cpp
index 1afb7714..c7ca0159 100644
--- a/Source/UnitTests/block_allocator_tester.cpp
+++ b/Source/UnitTests/block_allocator_tester.cpp
@@ -32,222 +32,195 @@
#include <set>
#include <vector>
-namespace tut
+namespace tut {
+struct BlockAllocatorTestData //
{
- struct BlockAllocatorTestData //
- {
- };
-
- typedef test_group<BlockAllocatorTestData> tg;
- tg test_group_i("Block Allocation tests");
-
- typedef tg::object block_allocation_test;
-
- template<>
- template<>
- void block_allocation_test::test<1>()
- {
- const size_t block_count = 2048;
-
- size_t count = 128;
- size_t blocksize = sizeof(uint64_t)*count;
-
- void* mem = malloc( block_count * blocksize );
-
- ensure( "Non null mem", mem != NULL );
-
- BlockAllocator ba;
- ba.Init( mem, block_count, blocksize );
-
- uint64_t* ptrs[block_count];
-
- for(auto & ptr : ptrs)
- {
- ptr = (uint64_t*)ba.Alloc(blocksize);
-
- ensure( "NULL Return", ptr != NULL );
- }
- free(mem);
+};
+
+typedef test_group<BlockAllocatorTestData> tg;
+tg test_group_i("Block Allocation tests");
+
+typedef tg::object block_allocation_test;
+
+template <>
+template <>
+void block_allocation_test::test<1>() {
+ const size_t block_count = 2048;
+
+ size_t count = 128;
+ size_t blocksize = sizeof(uint64_t) * count;
+
+ void* mem = malloc(block_count * blocksize);
+
+ ensure("Non null mem", mem != NULL);
+
+ BlockAllocator ba;
+ ba.Init(mem, block_count, blocksize);
+
+ uint64_t* ptrs[block_count];
+
+ for (auto& ptr : ptrs) {
+ ptr = (uint64_t*)ba.Alloc(blocksize);
+
+ ensure("NULL Return", ptr != NULL);
}
+ free(mem);
+}
- template<>
- template<>
- void block_allocation_test::test<2>()
- {
- const size_t block_count = 2048;
-
- size_t count = 128;
- size_t blocksize = sizeof(uint64_t)*count;
-
- void* mem = malloc( block_count * blocksize );
-
- BlockAllocator ba;
- ba.Init( mem, block_count, blocksize );
-
- uint64_t* ptrs[block_count];
-
- for(uint32_t i = 0; i < block_count; i++ )
- {
- ptrs[i] = (uint64_t*)ba.Alloc(blocksize);
-
- if( i > 0 )
- {
- ensure_equals( "Expected Pointer Distance", (uintptr_t)ptrs[i]-blocksize, (uintptr_t)ptrs[i-1] );
- }
+template <>
+template <>
+void block_allocation_test::test<2>() {
+ const size_t block_count = 2048;
+
+ size_t count = 128;
+ size_t blocksize = sizeof(uint64_t) * count;
+
+ void* mem = malloc(block_count * blocksize);
+
+ BlockAllocator ba;
+ ba.Init(mem, block_count, blocksize);
+
+ uint64_t* ptrs[block_count];
+
+ for (uint32_t i = 0; i < block_count; i++) {
+ ptrs[i] = (uint64_t*)ba.Alloc(blocksize);
+
+ if (i > 0) {
+ ensure_equals("Expected Pointer Distance", (uintptr_t)ptrs[i] - blocksize, (uintptr_t)ptrs[i - 1]);
}
- free(mem);
}
+ free(mem);
+}
- template<>
- template<>
- void block_allocation_test::test<3>()
- {
- const size_t block_count = 2048;
-
- size_t count = 128;
- size_t blocksize = sizeof(uint64_t)*count;
-
- void* mem = malloc( block_count * blocksize );
-
- BlockAllocator ba;
- ba.Init( mem, block_count, blocksize );
-
- uint64_t* ptrs[block_count];
-
- for(uint32_t i = 0; i < block_count; i++ )
- {
- ptrs[i] = (uint64_t*)ba.Alloc(blocksize);
-
- for( uint32_t k = 0; k < i; k++ )
- {
- ensure( "Non-repeating addresse", ptrs[k] != ptrs[i] );
- }
+template <>
+template <>
+void block_allocation_test::test<3>() {
+ const size_t block_count = 2048;
+
+ size_t count = 128;
+ size_t blocksize = sizeof(uint64_t) * count;
+
+ void* mem = malloc(block_count * blocksize);
+
+ BlockAllocator ba;
+ ba.Init(mem, block_count, blocksize);
+
+ uint64_t* ptrs[block_count];
+
+ for (uint32_t i = 0; i < block_count; i++) {
+ ptrs[i] = (uint64_t*)ba.Alloc(blocksize);
+
+ for (uint32_t k = 0; k < i; k++) {
+ ensure("Non-repeating addresse", ptrs[k] != ptrs[i]);
}
- free(mem);
}
+ free(mem);
+}
- template<>
- template<>
- void block_allocation_test::test<4>()
- {
- const size_t block_count = 2048;
-
- size_t count = 128;
- size_t blocksize = sizeof(uint64_t)*count;
-
- void* mem = malloc( block_count * blocksize );
-
- BlockAllocator ba;
- ba.Init( mem, block_count, blocksize );
-
- uint64_t* ptrs[block_count];
-
- for( uint32_t i = 0; i < block_count; i++ )
- {
- ptrs[i] = (uint64_t*)ba.Alloc(1024);
-
- for( uint32_t k = 0; k < count; k++ )
- {
- ptrs[i][k] = i;
- }
+template <>
+template <>
+void block_allocation_test::test<4>() {
+ const size_t block_count = 2048;
+
+ size_t count = 128;
+ size_t blocksize = sizeof(uint64_t) * count;
+
+ void* mem = malloc(block_count * blocksize);
+
+ BlockAllocator ba;
+ ba.Init(mem, block_count, blocksize);
+
+ uint64_t* ptrs[block_count];
+
+ for (uint32_t i = 0; i < block_count; i++) {
+ ptrs[i] = (uint64_t*)ba.Alloc(1024);
+
+ for (uint32_t k = 0; k < count; k++) {
+ ptrs[i][k] = i;
}
+ }
- for( uint32_t i = 0; i < block_count; i++ )
- {
- for( uint32_t k = 0; k < count; k++ )
- {
- ensure_equals( "Linear non-overlap", ptrs[i][k], i );
- }
+ for (uint32_t i = 0; i < block_count; i++) {
+ for (uint32_t k = 0; k < count; k++) {
+ ensure_equals("Linear non-overlap", ptrs[i][k], i);
}
- free(mem);
}
+ free(mem);
+}
+
+struct TestData {
+ std::vector<uint8_t> ref_data;
+ uint8_t* ptr;
+ size_t count;
- struct TestData
- {
- std::vector<uint8_t> ref_data;
- uint8_t *ptr;
- size_t count;
-
- bool VerifyData()
- {
- for( uint32_t i = 0; i < count; i++ )
- {
- if( ptr[i] != ref_data[i] )
- {
- return false;
- }
+ bool VerifyData() {
+ for (uint32_t i = 0; i < count; i++) {
+ if (ptr[i] != ref_data[i]) {
+ return false;
}
- return true;
}
+ return true;
+ }
- void GenerateData()
- {
- ref_data.resize(count);
- for( uint32_t i = 0; i < count; i++ )
- {
- uint8_t v = RangedRandomInt(0,255);
- ptr[i] = v;
- ref_data[i] = v;
- }
+ void GenerateData() {
+ ref_data.resize(count);
+ for (uint32_t i = 0; i < count; i++) {
+ uint8_t v = RangedRandomInt(0, 255);
+ ptr[i] = v;
+ ref_data[i] = v;
}
- };
-
- template<>
- template<>
- void block_allocation_test::test<5>()
- {
- const size_t block_count = 2048;
-
- size_t count = 128;
- size_t blocksize = sizeof(uint64_t)*count;
-
- void* mem = malloc( block_count * blocksize );
-
- BlockAllocator ba;
- ba.Init( mem, block_count, blocksize );
-
- std::vector<TestData> ptrs;
-
- for( uint32_t attempt = 0; attempt < 32; attempt++ )
- {
- while(true)
- {
- size_t size = sizeof(uint8_t)*RangedRandomInt(1,2048*8);
-
- if( ba.CanAlloc(size) )
- {
- uint8_t *ptr = (uint8_t*)ba.Alloc(size);
-
- ensure( "Not NULL", ptr != NULL );
- TestData t;
-
- t.ptr = ptr;
- t.count = size;
- t.GenerateData();
-
- ptrs.push_back(t);
- }
- else
- {
- break;
- }
- }
+ }
+};
+
+template <>
+template <>
+void block_allocation_test::test<5>() {
+ const size_t block_count = 2048;
+
+ size_t count = 128;
+ size_t blocksize = sizeof(uint64_t) * count;
+
+ void* mem = malloc(block_count * blocksize);
+
+ BlockAllocator ba;
+ ba.Init(mem, block_count, blocksize);
+
+ std::vector<TestData> ptrs;
- uint32_t number_of_removes = RangedRandomInt(0,ptrs.size()-1);
+ for (uint32_t attempt = 0; attempt < 32; attempt++) {
+ while (true) {
+ size_t size = sizeof(uint8_t) * RangedRandomInt(1, 2048 * 8);
- for( uint32_t i = 0; i < number_of_removes; i++ )
- {
- int index = RangedRandomInt(0,ptrs.size()-1);
+ if (ba.CanAlloc(size)) {
+ uint8_t* ptr = (uint8_t*)ba.Alloc(size);
- std::vector<TestData>::iterator it = ptrs.begin()+index;
+ ensure("Not NULL", ptr != NULL);
+ TestData t;
- ensure( "Data Overlap Persistance", it->VerifyData() );
+ t.ptr = ptr;
+ t.count = size;
+ t.GenerateData();
- ba.Free(it->ptr);
- it->ptr = NULL;
- ptrs.erase(it);
+ ptrs.push_back(t);
+ } else {
+ break;
}
}
- free(mem);
+
+ uint32_t number_of_removes = RangedRandomInt(0, ptrs.size() - 1);
+
+ for (uint32_t i = 0; i < number_of_removes; i++) {
+ int index = RangedRandomInt(0, ptrs.size() - 1);
+
+ std::vector<TestData>::iterator it = ptrs.begin() + index;
+
+ ensure("Data Overlap Persistance", it->VerifyData());
+
+ ba.Free(it->ptr);
+ it->ptr = NULL;
+ ptrs.erase(it);
+ }
}
+ free(mem);
}
+} // namespace tut
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-02 20:57:15 +0300