[project] Lose the battle between tabs & spaces
I'm a tabs guy. I like tabs, it's an elegant way to represent indentation instead of brute-forcing it. But I have to admit that the world seems to be going towards spaces, and tooling tends not to play nice with tabs. So here we go, changing the whole repo to spaces since I'm getting tired of all the inconsistent formatting.
This commit is contained in:
F in Chat for Tabs
committed by
Justin C. Miller
Justin C. Miller
parent
d36b2d8057
commit
8f529046a9
@@ -5,17 +5,17 @@ using namespace kutil;
|
||||
|
||||
TEST_CASE( "constexpr hash", "[hash]" )
|
||||
{
|
||||
const unsigned hash1 = static_cast<unsigned>("hash1!"_h);
|
||||
CHECK(hash1 == 210);
|
||||
const unsigned hash1 = static_cast<unsigned>("hash1!"_h);
|
||||
CHECK(hash1 == 210);
|
||||
|
||||
const unsigned hash2 = static_cast<unsigned>("hash1!"_h);
|
||||
CHECK(hash1 == hash2);
|
||||
const unsigned hash2 = static_cast<unsigned>("hash1!"_h);
|
||||
CHECK(hash1 == hash2);
|
||||
|
||||
const unsigned hash3 = static_cast<unsigned>("not hash1!"_h);
|
||||
CHECK(hash1 != hash3);
|
||||
CHECK(hash3 == 37);
|
||||
const unsigned hash3 = static_cast<unsigned>("not hash1!"_h);
|
||||
CHECK(hash1 != hash3);
|
||||
CHECK(hash3 == 37);
|
||||
|
||||
const unsigned hash4 = static_cast<unsigned>("another thing that's longer"_h);
|
||||
CHECK(hash1 != hash4);
|
||||
CHECK(hash4 == 212);
|
||||
const unsigned hash4 = static_cast<unsigned>("another thing that's longer"_h);
|
||||
CHECK(hash1 != hash4);
|
||||
CHECK(hash4 == 212);
|
||||
}
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
#pragma once
|
||||
|
||||
struct unsortableT {
|
||||
int value;
|
||||
int value;
|
||||
};
|
||||
|
||||
struct sortableT {
|
||||
int value;
|
||||
int compare(const sortableT &other) const {
|
||||
return value - other.value;
|
||||
}
|
||||
int value;
|
||||
int compare(const sortableT &other) const {
|
||||
return value - other.value;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -26,169 +26,169 @@ extern bool ASSERT_EXPECTED;
|
||||
extern bool ASSERT_HAPPENED;
|
||||
|
||||
std::vector<size_t> sizes = {
|
||||
16000, 8000, 4000, 4000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 150,
|
||||
150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 48, 48, 48, 13 };
|
||||
16000, 8000, 4000, 4000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 150,
|
||||
150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, 48, 48, 48, 13 };
|
||||
|
||||
void segfault_handler(int signum, siginfo_t *info, void *ctxp)
|
||||
{
|
||||
uintptr_t start = reinterpret_cast<uintptr_t>(mem_base);
|
||||
uintptr_t end = start + mem_size;
|
||||
uintptr_t addr = reinterpret_cast<uintptr_t>(info->si_addr);
|
||||
uintptr_t start = reinterpret_cast<uintptr_t>(mem_base);
|
||||
uintptr_t end = start + mem_size;
|
||||
uintptr_t addr = reinterpret_cast<uintptr_t>(info->si_addr);
|
||||
|
||||
if (addr < start || addr >= end) {
|
||||
CAPTURE( start );
|
||||
CAPTURE( end );
|
||||
CAPTURE( addr );
|
||||
FAIL("Segfaulted outside memory area");
|
||||
}
|
||||
if (addr < start || addr >= end) {
|
||||
CAPTURE( start );
|
||||
CAPTURE( end );
|
||||
CAPTURE( addr );
|
||||
FAIL("Segfaulted outside memory area");
|
||||
}
|
||||
|
||||
signalled_at = info->si_addr;
|
||||
signalled += 1;
|
||||
if (mprotect(signalled_at, max_block, PROT_READ|PROT_WRITE)) {
|
||||
perror("mprotect");
|
||||
exit(100);
|
||||
}
|
||||
signalled_at = info->si_addr;
|
||||
signalled += 1;
|
||||
if (mprotect(signalled_at, max_block, PROT_READ|PROT_WRITE)) {
|
||||
perror("mprotect");
|
||||
exit(100);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "Buddy blocks tests", "[memory buddy]" )
|
||||
{
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
|
||||
mem_base = aligned_alloc(max_block, mem_size);
|
||||
mem_base = aligned_alloc(max_block, mem_size);
|
||||
|
||||
// Catch segfaults so we can track memory access
|
||||
struct sigaction sigact;
|
||||
memset(&sigact, 0, sizeof(sigact));
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigact.sa_flags = SA_NODEFER|SA_SIGINFO;
|
||||
sigact.sa_sigaction = segfault_handler;
|
||||
sigaction(SIGSEGV, &sigact, nullptr);
|
||||
// Catch segfaults so we can track memory access
|
||||
struct sigaction sigact;
|
||||
memset(&sigact, 0, sizeof(sigact));
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigact.sa_flags = SA_NODEFER|SA_SIGINFO;
|
||||
sigact.sa_sigaction = segfault_handler;
|
||||
sigaction(SIGSEGV, &sigact, nullptr);
|
||||
|
||||
// Protect our memory arena so we trigger out fault handler
|
||||
REQUIRE( mprotect(mem_base, max_block*4, PROT_NONE) == 0 );
|
||||
// Protect our memory arena so we trigger out fault handler
|
||||
REQUIRE( mprotect(mem_base, max_block*4, PROT_NONE) == 0 );
|
||||
|
||||
heap_allocator mm(
|
||||
reinterpret_cast<uintptr_t>(mem_base),
|
||||
max_block * 4);
|
||||
heap_allocator mm(
|
||||
reinterpret_cast<uintptr_t>(mem_base),
|
||||
max_block * 4);
|
||||
|
||||
// Initial creation should not have allocated
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
// Initial creation should not have allocated
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
// Allocating too much should assert
|
||||
ASSERT_EXPECTED = true;
|
||||
void *p = mm.allocate(max_block - hs + 1);
|
||||
REQUIRE( ASSERT_HAPPENED );
|
||||
ASSERT_HAPPENED = false;
|
||||
// Allocating too much should assert
|
||||
ASSERT_EXPECTED = true;
|
||||
void *p = mm.allocate(max_block - hs + 1);
|
||||
REQUIRE( ASSERT_HAPPENED );
|
||||
ASSERT_HAPPENED = false;
|
||||
|
||||
// Allocating should signal just at the first page.
|
||||
p = mm.allocate(max_block - hs);
|
||||
CHECK( p == offset_pointer(mem_base, hs) );
|
||||
CHECK( signalled == 1 );
|
||||
CHECK( signalled_at == mem_base );
|
||||
signalled = 0;
|
||||
// Allocating should signal just at the first page.
|
||||
p = mm.allocate(max_block - hs);
|
||||
CHECK( p == offset_pointer(mem_base, hs) );
|
||||
CHECK( signalled == 1 );
|
||||
CHECK( signalled_at == mem_base );
|
||||
signalled = 0;
|
||||
|
||||
// Freeing and allocating should not allocate
|
||||
mm.free(p);
|
||||
p = mm.allocate(max_block - hs);
|
||||
CHECK( p == offset_pointer(mem_base, hs) );
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
// Freeing and allocating should not allocate
|
||||
mm.free(p);
|
||||
p = mm.allocate(max_block - hs);
|
||||
CHECK( p == offset_pointer(mem_base, hs) );
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
mm.free(p);
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
mm.free(p);
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
// Blocks should be:
|
||||
// 22: 0-4M
|
||||
// Blocks should be:
|
||||
// 22: 0-4M
|
||||
|
||||
std::vector<void *> allocs(6);
|
||||
for (int i = 0; i < 6; ++i)
|
||||
allocs[i] = mm.allocate(150); // size 8
|
||||
std::vector<void *> allocs(6);
|
||||
for (int i = 0; i < 6; ++i)
|
||||
allocs[i] = mm.allocate(150); // size 8
|
||||
|
||||
// Should not have grown
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
// Should not have grown
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
// Blocks should be:
|
||||
// 22: [0-4M]
|
||||
// 21: [0-2M], 2-4M
|
||||
// 20: [0-1M], 1-2M
|
||||
// 19: [0-512K], 512K-1M
|
||||
// 18: [0-256K], 256-512K
|
||||
// 17: [0-128K], 128-256K
|
||||
// 16: [0-64K], 64-128K
|
||||
// 15: [0-32K], 32K-64K
|
||||
// 14: [0-16K], 16K-32K
|
||||
// 13: [0-8K], 8K-16K
|
||||
// 12: [0-4K], 4K-8K
|
||||
// 11: [0-2K], 2K-4K
|
||||
// 10: [0-1K, 1-2K]
|
||||
// 9: [0, 512, 1024], 1536
|
||||
// 8: [0, 256, 512, 768, 1024, 1280]
|
||||
// Blocks should be:
|
||||
// 22: [0-4M]
|
||||
// 21: [0-2M], 2-4M
|
||||
// 20: [0-1M], 1-2M
|
||||
// 19: [0-512K], 512K-1M
|
||||
// 18: [0-256K], 256-512K
|
||||
// 17: [0-128K], 128-256K
|
||||
// 16: [0-64K], 64-128K
|
||||
// 15: [0-32K], 32K-64K
|
||||
// 14: [0-16K], 16K-32K
|
||||
// 13: [0-8K], 8K-16K
|
||||
// 12: [0-4K], 4K-8K
|
||||
// 11: [0-2K], 2K-4K
|
||||
// 10: [0-1K, 1-2K]
|
||||
// 9: [0, 512, 1024], 1536
|
||||
// 8: [0, 256, 512, 768, 1024, 1280]
|
||||
|
||||
// We have free memory at 1526 and 2K, but we should get 4K
|
||||
void *big = mm.allocate(4000); // size 12
|
||||
// We have free memory at 1526 and 2K, but we should get 4K
|
||||
void *big = mm.allocate(4000); // size 12
|
||||
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
REQUIRE( big == offset_pointer(mem_base, 4096 + hs) );
|
||||
mm.free(big);
|
||||
REQUIRE( big == offset_pointer(mem_base, 4096 + hs) );
|
||||
mm.free(big);
|
||||
|
||||
// free up 512
|
||||
mm.free(allocs[3]);
|
||||
mm.free(allocs[4]);
|
||||
// free up 512
|
||||
mm.free(allocs[3]);
|
||||
mm.free(allocs[4]);
|
||||
|
||||
// Blocks should be:
|
||||
// ...
|
||||
// 9: [0, 512, 1024], 1536
|
||||
// 8: [0, 256, 512], 768, 1024, [1280]
|
||||
// Blocks should be:
|
||||
// ...
|
||||
// 9: [0, 512, 1024], 1536
|
||||
// 8: [0, 256, 512], 768, 1024, [1280]
|
||||
|
||||
// A request for a 512-block should not cross the buddy divide
|
||||
big = mm.allocate(500); // size 9
|
||||
REQUIRE( big >= offset_pointer(mem_base, 1536 + hs) );
|
||||
mm.free(big);
|
||||
// A request for a 512-block should not cross the buddy divide
|
||||
big = mm.allocate(500); // size 9
|
||||
REQUIRE( big >= offset_pointer(mem_base, 1536 + hs) );
|
||||
mm.free(big);
|
||||
|
||||
mm.free(allocs[0]);
|
||||
mm.free(allocs[1]);
|
||||
mm.free(allocs[2]);
|
||||
mm.free(allocs[5]);
|
||||
allocs.clear();
|
||||
mm.free(allocs[0]);
|
||||
mm.free(allocs[1]);
|
||||
mm.free(allocs[2]);
|
||||
mm.free(allocs[5]);
|
||||
allocs.clear();
|
||||
|
||||
std::shuffle(sizes.begin(), sizes.end(), rng);
|
||||
std::shuffle(sizes.begin(), sizes.end(), rng);
|
||||
|
||||
allocs.reserve(sizes.size());
|
||||
for (size_t size : sizes)
|
||||
allocs.push_back(mm.allocate(size));
|
||||
allocs.reserve(sizes.size());
|
||||
for (size_t size : sizes)
|
||||
allocs.push_back(mm.allocate(size));
|
||||
|
||||
std::shuffle(allocs.begin(), allocs.end(), rng);
|
||||
for (void *p: allocs)
|
||||
mm.free(p);
|
||||
allocs.clear();
|
||||
std::shuffle(allocs.begin(), allocs.end(), rng);
|
||||
for (void *p: allocs)
|
||||
mm.free(p);
|
||||
allocs.clear();
|
||||
|
||||
big = mm.allocate(max_block / 2 + 1);
|
||||
big = mm.allocate(max_block / 2 + 1);
|
||||
|
||||
// If everything was freed / joined correctly, that should not have allocated
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
// If everything was freed / joined correctly, that should not have allocated
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
// And we should have gotten back the start of memory
|
||||
CHECK( big == offset_pointer(mem_base, hs) );
|
||||
// And we should have gotten back the start of memory
|
||||
CHECK( big == offset_pointer(mem_base, hs) );
|
||||
|
||||
// Allocating again should signal at the next page.
|
||||
void *p2 = mm.allocate(max_block - hs);
|
||||
CHECK( p2 == offset_pointer(mem_base, max_block + hs) );
|
||||
CHECK( signalled == 1 );
|
||||
CHECK( signalled_at == offset_pointer(mem_base, max_block) );
|
||||
signalled = 0;
|
||||
// Allocating again should signal at the next page.
|
||||
void *p2 = mm.allocate(max_block - hs);
|
||||
CHECK( p2 == offset_pointer(mem_base, max_block + hs) );
|
||||
CHECK( signalled == 1 );
|
||||
CHECK( signalled_at == offset_pointer(mem_base, max_block) );
|
||||
signalled = 0;
|
||||
|
||||
mm.free(p2);
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
mm.free(p2);
|
||||
CHECK( signalled == 0 );
|
||||
signalled = 0;
|
||||
|
||||
free(mem_base);
|
||||
free(mem_base);
|
||||
}
|
||||
|
||||
|
||||
@@ -13,142 +13,142 @@ const int test_list_size = 100;
|
||||
|
||||
template <typename T>
|
||||
class ListVectorCompare :
|
||||
public Catch::MatcherBase<std::vector<list_node<T>>>
|
||||
public Catch::MatcherBase<std::vector<list_node<T>>>
|
||||
{
|
||||
public:
|
||||
using item = list_node<T>;
|
||||
using vector = std::vector<item>;
|
||||
using item = list_node<T>;
|
||||
using vector = std::vector<item>;
|
||||
|
||||
ListVectorCompare(const linked_list<T> &list, bool reversed) :
|
||||
m_list(list), m_reverse(reversed) {}
|
||||
ListVectorCompare(const linked_list<T> &list, bool reversed) :
|
||||
m_list(list), m_reverse(reversed) {}
|
||||
|
||||
virtual bool match (vector const& vec) const override
|
||||
{
|
||||
size_t index = m_reverse ? vec.size() - 1 : 0;
|
||||
for (const T *i : m_list) {
|
||||
if (i != &vec[index]) return false;
|
||||
index += m_reverse ? -1 : 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
virtual bool match (vector const& vec) const override
|
||||
{
|
||||
size_t index = m_reverse ? vec.size() - 1 : 0;
|
||||
for (const T *i : m_list) {
|
||||
if (i != &vec[index]) return false;
|
||||
index += m_reverse ? -1 : 1;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "is the same as the given linked list";
|
||||
}
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "is the same as the given linked list";
|
||||
}
|
||||
|
||||
private:
|
||||
const linked_list<T> &m_list;
|
||||
bool m_reverse;
|
||||
const linked_list<T> &m_list;
|
||||
bool m_reverse;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class IsSorted :
|
||||
public Catch::MatcherBase<linked_list<T>>
|
||||
public Catch::MatcherBase<linked_list<T>>
|
||||
{
|
||||
public:
|
||||
using item = list_node<T>;
|
||||
using list = linked_list<T>;
|
||||
using item = list_node<T>;
|
||||
using list = linked_list<T>;
|
||||
|
||||
IsSorted() {}
|
||||
IsSorted() {}
|
||||
|
||||
virtual bool match (list const& l) const override
|
||||
{
|
||||
int big = std::numeric_limits<int>::min();
|
||||
for (const T *i : l) {
|
||||
if (i->value < big) return false;
|
||||
big = i->value;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
virtual bool match (list const& l) const override
|
||||
{
|
||||
int big = std::numeric_limits<int>::min();
|
||||
for (const T *i : l) {
|
||||
if (i->value < big) return false;
|
||||
big = i->value;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "is sorted";
|
||||
}
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "is sorted";
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class ListContainsMatcher :
|
||||
public Catch::MatcherBase<linked_list<T>>
|
||||
public Catch::MatcherBase<linked_list<T>>
|
||||
{
|
||||
public:
|
||||
using item = list_node<T>;
|
||||
using list = linked_list<T>;
|
||||
using item = list_node<T>;
|
||||
using list = linked_list<T>;
|
||||
|
||||
ListContainsMatcher(const item &needle) : m_needle(needle) {}
|
||||
ListContainsMatcher(const item &needle) : m_needle(needle) {}
|
||||
|
||||
virtual bool match (list const& l) const override
|
||||
{
|
||||
for (const T *i : l)
|
||||
if (i == &m_needle) return true;
|
||||
return false;
|
||||
}
|
||||
virtual bool match (list const& l) const override
|
||||
{
|
||||
for (const T *i : l)
|
||||
if (i == &m_needle) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "contains the given item";
|
||||
}
|
||||
virtual std::string describe() const override
|
||||
{
|
||||
return "contains the given item";
|
||||
}
|
||||
|
||||
const item &m_needle;
|
||||
const item &m_needle;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
ListVectorCompare<T> IsSameAsList(const linked_list<T> &list, bool reversed = false)
|
||||
{
|
||||
return ListVectorCompare<T>(list, reversed);
|
||||
return ListVectorCompare<T>(list, reversed);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
ListContainsMatcher<T> ListContains(const list_node<T> &item)
|
||||
{
|
||||
return ListContainsMatcher<T>(item);
|
||||
return ListContainsMatcher<T>(item);
|
||||
}
|
||||
|
||||
TEST_CASE( "Linked list tests", "[containers] [list]" )
|
||||
{
|
||||
linked_list<unsortableT> ulist;
|
||||
linked_list<unsortableT> ulist;
|
||||
|
||||
int value = 0;
|
||||
std::vector<list_node<unsortableT>> unsortables(test_list_size);
|
||||
for (auto &i : unsortables) {
|
||||
i.value = value++;
|
||||
ulist.push_back(&i);
|
||||
}
|
||||
CHECK( ulist.length() == test_list_size );
|
||||
CHECK_THAT( unsortables, IsSameAsList(ulist) );
|
||||
int value = 0;
|
||||
std::vector<list_node<unsortableT>> unsortables(test_list_size);
|
||||
for (auto &i : unsortables) {
|
||||
i.value = value++;
|
||||
ulist.push_back(&i);
|
||||
}
|
||||
CHECK( ulist.length() == test_list_size );
|
||||
CHECK_THAT( unsortables, IsSameAsList(ulist) );
|
||||
|
||||
linked_list<unsortableT> ulist_reversed;
|
||||
linked_list<unsortableT> ulist_reversed;
|
||||
|
||||
for (auto &i : unsortables) {
|
||||
ulist.remove(&i);
|
||||
ulist_reversed.push_front(&i);
|
||||
}
|
||||
for (auto &i : unsortables) {
|
||||
ulist.remove(&i);
|
||||
ulist_reversed.push_front(&i);
|
||||
}
|
||||
|
||||
CHECK( ulist_reversed.length() == test_list_size );
|
||||
CHECK_THAT( unsortables, IsSameAsList(ulist_reversed, true) );
|
||||
CHECK( ulist_reversed.length() == test_list_size );
|
||||
CHECK_THAT( unsortables, IsSameAsList(ulist_reversed, true) );
|
||||
|
||||
auto &removed = unsortables[test_list_size / 2];
|
||||
ulist_reversed.remove(&removed);
|
||||
CHECK( ulist_reversed.length() == test_list_size - 1 );
|
||||
CHECK_THAT( ulist_reversed, !ListContains(removed) );
|
||||
auto &removed = unsortables[test_list_size / 2];
|
||||
ulist_reversed.remove(&removed);
|
||||
CHECK( ulist_reversed.length() == test_list_size - 1 );
|
||||
CHECK_THAT( ulist_reversed, !ListContains(removed) );
|
||||
}
|
||||
|
||||
TEST_CASE( "Sorted list tests", "[containers] [list]" )
|
||||
{
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
std::uniform_int_distribution<int> gen(1, 1000);
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
std::uniform_int_distribution<int> gen(1, 1000);
|
||||
|
||||
linked_list<sortableT> slist;
|
||||
CHECK( slist.length() == 0 );
|
||||
linked_list<sortableT> slist;
|
||||
CHECK( slist.length() == 0 );
|
||||
|
||||
std::vector<list_node<sortableT>> sortables(test_list_size);
|
||||
for (auto &i : sortables) {
|
||||
i.value = gen(rng);
|
||||
slist.sorted_insert(&i);
|
||||
}
|
||||
CHECK( slist.length() == test_list_size );
|
||||
CHECK_THAT( slist, IsSorted<sortableT>() );
|
||||
std::vector<list_node<sortableT>> sortables(test_list_size);
|
||||
for (auto &i : sortables) {
|
||||
i.value = gen(rng);
|
||||
slist.sorted_insert(&i);
|
||||
}
|
||||
CHECK( slist.length() == test_list_size );
|
||||
CHECK_THAT( slist, IsSorted<sortableT>() );
|
||||
}
|
||||
|
||||
@@ -14,19 +14,19 @@ log::area_t hash2 = "test_area2"_h;
|
||||
|
||||
TEST_CASE( "logger writing", "[logger]" )
|
||||
{
|
||||
log::logger logger(test_log_buffer, sizeof(test_log_buffer));
|
||||
logger.register_area(hash1, name1, log::level::debug);
|
||||
logger.register_area(hash2, name2, log::level::debug);
|
||||
CHECK( hash1 != hash2 );
|
||||
log::logger logger(test_log_buffer, sizeof(test_log_buffer));
|
||||
logger.register_area(hash1, name1, log::level::debug);
|
||||
logger.register_area(hash2, name2, log::level::debug);
|
||||
CHECK( hash1 != hash2 );
|
||||
|
||||
const char *check1 = logger.area_name(hash1);
|
||||
const char *check2 = logger.area_name(hash2);
|
||||
const char *check1 = logger.area_name(hash1);
|
||||
const char *check2 = logger.area_name(hash2);
|
||||
|
||||
CHECK( check1 == name1 );
|
||||
CHECK( check2 == name2 );
|
||||
CHECK( check1 == name1 );
|
||||
CHECK( check2 == name2 );
|
||||
|
||||
log::debug(hash1, "This is a thing %016lx", 35);
|
||||
log::info(hash2, "This is a string %s", "foo");
|
||||
log::warn(hash1, "This is a thing %016lx", 682);
|
||||
log::error(hash2, "This is a string %s", "bar");
|
||||
log::debug(hash1, "This is a thing %016lx", 35);
|
||||
log::info(hash2, "This is a string %s", "foo");
|
||||
log::warn(hash1, "This is a thing %016lx", 682);
|
||||
log::error(hash2, "This is a string %s", "bar");
|
||||
}
|
||||
|
||||
@@ -7,20 +7,20 @@ bool ASSERT_EXPECTED = false;
|
||||
bool ASSERT_HAPPENED = false;
|
||||
void test_assert(const char *file, unsigned line, const char *message)
|
||||
{
|
||||
CAPTURE( file );
|
||||
CAPTURE( line );
|
||||
INFO( message );
|
||||
REQUIRE( ASSERT_EXPECTED );
|
||||
ASSERT_EXPECTED = false;
|
||||
ASSERT_HAPPENED = true;
|
||||
CAPTURE( file );
|
||||
CAPTURE( line );
|
||||
INFO( message );
|
||||
REQUIRE( ASSERT_EXPECTED );
|
||||
ASSERT_EXPECTED = false;
|
||||
ASSERT_HAPPENED = true;
|
||||
}
|
||||
|
||||
|
||||
int main( int argc, char* argv[] ) {
|
||||
kutil::assert_set_callback(test_assert);
|
||||
kutil::assert_set_callback(test_assert);
|
||||
|
||||
int result = Catch::Session().run( argc, argv );
|
||||
return result;
|
||||
int result = Catch::Session().run( argc, argv );
|
||||
return result;
|
||||
}
|
||||
|
||||
namespace kutil {
|
||||
|
||||
@@ -6,90 +6,90 @@ std::uniform_int_distribution<int> distrib {0, 10000};
|
||||
|
||||
TEST_CASE( "map insertion", "[containers] [map]" )
|
||||
{
|
||||
std::vector<int> ints;
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
ints.push_back(i);
|
||||
std::vector<int> ints;
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
ints.push_back(i);
|
||||
|
||||
size_t sizes[] = {1, 2, 3, 5, 100};
|
||||
for (size_t s : sizes) {
|
||||
kutil::map<int, int> v;
|
||||
std::shuffle(ints.begin(), ints.end(), rng());
|
||||
size_t sizes[] = {1, 2, 3, 5, 100};
|
||||
for (size_t s : sizes) {
|
||||
kutil::map<int, int> v;
|
||||
std::shuffle(ints.begin(), ints.end(), rng());
|
||||
|
||||
for (int i = 0; i < s; ++i) {
|
||||
v.insert(ints[i], ints[i]);
|
||||
}
|
||||
for (int i = 0; i < s; ++i) {
|
||||
v.insert(ints[i], ints[i]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < s; ++i) {
|
||||
int *p = v.find(ints[i]);
|
||||
CAPTURE( s );
|
||||
CAPTURE( i );
|
||||
CAPTURE( ints[i] );
|
||||
CAPTURE( kutil::hash(ints[i]) );
|
||||
CHECK( p );
|
||||
CHECK( *p == ints[i] );
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < s; ++i) {
|
||||
int *p = v.find(ints[i]);
|
||||
CAPTURE( s );
|
||||
CAPTURE( i );
|
||||
CAPTURE( ints[i] );
|
||||
CAPTURE( kutil::hash(ints[i]) );
|
||||
CHECK( p );
|
||||
CHECK( *p == ints[i] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "map deletion", "[containers] [map]" )
|
||||
{
|
||||
std::vector<int> ints;
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
ints.push_back(i);
|
||||
std::vector<int> ints;
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
ints.push_back(i);
|
||||
|
||||
size_t sizes[] = {1, 2, 3, 5, 100};
|
||||
for (size_t s : sizes) {
|
||||
kutil::map<int, int> v;
|
||||
std::shuffle(ints.begin(), ints.end(), rng());
|
||||
size_t sizes[] = {1, 2, 3, 5, 100};
|
||||
for (size_t s : sizes) {
|
||||
kutil::map<int, int> v;
|
||||
std::shuffle(ints.begin(), ints.end(), rng());
|
||||
|
||||
for (int i = 0; i < s; ++i) {
|
||||
v.insert(ints[i], ints[i]);
|
||||
}
|
||||
for (int i = 0; i < s; ++i) {
|
||||
v.insert(ints[i], ints[i]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < s; i += 2) {
|
||||
v.erase(ints[i]);
|
||||
}
|
||||
for (int i = 0; i < s; i += 2) {
|
||||
v.erase(ints[i]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < s; ++i) {
|
||||
int *p = v.find(ints[i]);
|
||||
CAPTURE( s );
|
||||
CAPTURE( i );
|
||||
CAPTURE( ints[i] );
|
||||
CAPTURE( kutil::hash(ints[i]) );
|
||||
if ( i%2 )
|
||||
CHECK( p );
|
||||
else
|
||||
CHECK( !p );
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < s; ++i) {
|
||||
int *p = v.find(ints[i]);
|
||||
CAPTURE( s );
|
||||
CAPTURE( i );
|
||||
CAPTURE( ints[i] );
|
||||
CAPTURE( kutil::hash(ints[i]) );
|
||||
if ( i%2 )
|
||||
CHECK( p );
|
||||
else
|
||||
CHECK( !p );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE( "map with pointer vals", "[containers] [map]" )
|
||||
{
|
||||
kutil::map<int, int*> v;
|
||||
int is[4] = { 0, 0, 0, 0 };
|
||||
for (int i = 0; i < 4; ++i)
|
||||
v.insert(i*7, &is[i]);
|
||||
kutil::map<int, int*> v;
|
||||
int is[4] = { 0, 0, 0, 0 };
|
||||
for (int i = 0; i < 4; ++i)
|
||||
v.insert(i*7, &is[i]);
|
||||
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
int *p = v.find(i*7);
|
||||
CHECK( p == &is[i] );
|
||||
}
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
int *p = v.find(i*7);
|
||||
CHECK( p == &is[i] );
|
||||
}
|
||||
|
||||
CHECK( v.find(3) == nullptr );
|
||||
CHECK( v.find(3) == nullptr );
|
||||
}
|
||||
|
||||
TEST_CASE( "map with uint64_t keys", "[containers] [map]" )
|
||||
{
|
||||
kutil::map<uint64_t, int> v;
|
||||
int is[4] = { 2, 3, 5, 7 };
|
||||
for (uint64_t i = 0; i < 4; ++i)
|
||||
v.insert(i+1, is[i]);
|
||||
kutil::map<uint64_t, int> v;
|
||||
int is[4] = { 2, 3, 5, 7 };
|
||||
for (uint64_t i = 0; i < 4; ++i)
|
||||
v.insert(i+1, is[i]);
|
||||
|
||||
for (uint64_t i = 0; i < 4; ++i) {
|
||||
int *p = v.find(i+1);
|
||||
CHECK( *p == is[i] );
|
||||
}
|
||||
for (uint64_t i = 0; i < 4; ++i) {
|
||||
int *p = v.find(i+1);
|
||||
CHECK( *p == is[i] );
|
||||
}
|
||||
|
||||
CHECK( v.find(30) == nullptr );
|
||||
CHECK( v.find(30) == nullptr );
|
||||
}
|
||||
|
||||
@@ -5,21 +5,21 @@
|
||||
|
||||
TEST_CASE( "sorted vector tests", "[containers] [vector]" )
|
||||
{
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
std::uniform_int_distribution<int> distrib(0,10000);
|
||||
using clock = std::chrono::system_clock;
|
||||
unsigned seed = clock::now().time_since_epoch().count();
|
||||
std::default_random_engine rng(seed);
|
||||
std::uniform_int_distribution<int> distrib(0,10000);
|
||||
|
||||
kutil::vector<sortableT> v;
|
||||
kutil::vector<sortableT> v;
|
||||
|
||||
int sizes[] = {1, 2, 3, 5, 100};
|
||||
for (int s : sizes) {
|
||||
for (int i = 0; i < s; ++i) {
|
||||
sortableT t { distrib(rng) };
|
||||
v.sorted_insert(t);
|
||||
}
|
||||
int sizes[] = {1, 2, 3, 5, 100};
|
||||
for (int s : sizes) {
|
||||
for (int i = 0; i < s; ++i) {
|
||||
sortableT t { distrib(rng) };
|
||||
v.sorted_insert(t);
|
||||
}
|
||||
|
||||
for (int i = 1; i < s; ++i)
|
||||
CHECK( v[i].value >= v[i-1].value );
|
||||
}
|
||||
for (int i = 1; i < s; ++i)
|
||||
CHECK( v[i].value >= v[i-1].value );
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user