gplib/tests/gp_test.cpp

#include "allocator.hpp"
#include "gp/algorithm/repeat.hpp"
#include "gp/algorithm/rotate.hpp"
#include "gp/algorithm/move.hpp"
#include "gp/allocator/aggregator.hpp"
#include "gp/allocator/arena.hpp"
#include "gp/allocator/buddy.hpp"
#include "gp/allocator/dummy.hpp"
#include "gp/array.hpp"
#include "gp/bitops.hpp"
#include "gp/indexed_array.hpp"
#include "gp/ring_list.hpp"
#include "test_scaffold.h"

#include <algorithm>
#include <chrono>
#include <fstream> 
#include <iomanip>
#include <iostream>
#include <numeric>
#include <random>
#include <set>
#include <stack>
#include <thread>



#ifndef FUZZ_STRENGTH
#define FUZZ_STRENGTH 2048
#endif

#define MACRO_STRGEN(X) #X
#define MACRO_STR(X) MACRO_STRGEN(X)

constexpr bool time_fuzzes = true;


struct arraysum_test : public test_scaffold {
	arraysum_test() {
		name = __FILE__ ":1";
	}

	virtual int run() {
		gp::array<uint32_t, 16> test;

		for(auto& elem : test)
		{
			elem = 12;
		}

		return std::accumulate(test.begin(), test.end(), 0) != 12*test.size();
	}
};

append_test dummy_sd45uisd3(new arraysum_test{});


struct optional_test : public test_scaffold {
	optional_test() {
		name = __FILE__ ":1";
	}

	virtual int run() {
		int res = 0;
		{
			gp::optional<uint32_t> test;

			if(test.has_value())
			{
				res++;
			}

			test = 12;

			if(test.has_value())
			{
				if(test.value()!=12)
				{
					res++;
				}
			}
			else
			{
				res++;
			}
		}
		{
			gp::optional<std::ifstream> test;

			if(test.has_value())
			{
				res++;
			}

			test = std::ifstream("/proc/cpuinfo");

			if(!test.has_value())
			{
				res++;
			}
		}
		return res;
	}
};

append_test dummy_mlyusisd3(new optional_test{});


struct buddy_test : public test_scaffold {
	buddy_test() {
		name = std::string(__FILE__ "seed_") + std::to_string(seed) +  ":3";
		rng.seed(seed);
	}

	std::mt19937 rng{};
	int seed = std::random_device{}();

	virtual int run() {
		int res = 0;
		gp::repeat(10, [&](){
			gp::array<char, 4096> store;
			{
				gp::dummy_allocator dummyall;
				static_assert(gp::math::msb<uint64_t>(8) == 3);
				static_assert(gp::math::msb<uint64_t>(127) == 7);
				static_assert(gp::math::msb<uint64_t>(4096) == 12);
				gp::buddy<gp::math::msb<uint64_t>(4096)> bud{&*store.begin(), store.size()};
				gp::buddy<gp::math::msb<uint64_t>(4096)> dum_bud{store.size(), dummyall};
				{
					gp::buddy<> inner_bud{2048, bud};
					gp_config::assertion(!dummyall.try_reallocate(nullptr, 0), "reallocation works wut?");
					gp_config::assertion(!bud.try_reallocate(nullptr, 0), "reallocation works wut?");
					gp_config::assertion(!inner_bud.try_reallocate(nullptr, 0), "reallocation works wut?");
					std::set<void*> ptr_set;
					for(int i = 0; i < 2048 / 16; i++)
					{
						void* v = inner_bud.allocate(16);
						gp_config::assertion(!inner_bud.empty(), "allocator should have elements");
						if(v == nullptr)
						{
							throw gp::runtime_error("allocation failed");
						}
						ptr_set.insert(v);
					}
					bool wut = ptr_set.count(nullptr)!=0 || ptr_set.size()!=(2048/16);
					if(wut) throw gp::runtime_error("some allocations failed line: " MACRO_STR(__LINE__));
					if(nullptr != inner_bud.allocate(8)) throw gp::runtime_error("allocation succeeded, failure was expected");

					for(auto elem : ptr_set) {
						gp_config::assertion(!inner_bud.empty(), "allocator should have elements");
						if(inner_bud.deallocate(elem) == false)
						{
							res += 1;
						}
					}
					gp_config::assertion(inner_bud.empty(), "allocator should be empty");
				}
				{
					gp_config::assertion(!dummyall.try_reallocate(nullptr, 0), "reallocation works wut?");
					gp_config::assertion(!bud.try_reallocate(nullptr, 0), "reallocation works wut?");
					std::set<void*> ptr_set;
					for(int i = 0; i < 4096 / 16; i++)
					{
						void* v = bud.allocate(16);
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(v == nullptr) throw gp::runtime_error("allocation failed");
						ptr_set.insert(v);
					}
					if(ptr_set.count(nullptr)!=0 || ptr_set.size()!=(4096/16)) throw gp::runtime_error("some allocations failed line: " MACRO_STR(__LINE__));
					if(nullptr != bud.allocate(8)) throw gp::runtime_error("allocation succeeded, failure was expected");

					for(auto elem : ptr_set) {
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(bud.deallocate(elem) == false)
						{
							res += 1;
						}
					}
					gp_config::assertion(bud.empty(), "allocator should be empty");
				}
				{
					std::set<void*> ptr_set;
					for(int i = 0; i < 4096 / 8; i++)
					{
						void* v = bud.allocate(8);
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(v == nullptr) throw gp::runtime_error("allocation failed");
						ptr_set.insert(v);
					}
					if(ptr_set.count(nullptr)!=0 || ptr_set.size()!=(4096/8)) throw gp::runtime_error("some allocations failed line: " MACRO_STR(__LINE__));
					if(nullptr != bud.allocate(8)) throw gp::runtime_error("allocation succeeded, failure was expected");

					for(auto elem : ptr_set) {
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(bud.deallocate(elem) == false)
						{
							res += 1;
						}
					}
					gp_config::assertion(bud.empty(), "allocator should be empty");
				}
				{
					std::set<void*> ptr_set;
					std::vector<size_t> infill;
					std::insert_iterator< std::vector<size_t> > inserter{infill, std::end(infill)};
					std::fill_n(inserter, 4096 / 16 / 4, 16);
					inserter = std::insert_iterator< std::vector<size_t> >{infill, std::end(infill)};
					std::fill_n(inserter, 4096 / 8 / 4, 8);
					std::shuffle(infill.begin(), infill.end(), rng);
					for(auto sz : infill)
					{
						void* v = bud.allocate(sz);
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(v == nullptr) throw gp::runtime_error("allocation failed");
						ptr_set.insert(v);
					}
					if(ptr_set.count(nullptr)!=0) throw gp::runtime_error("some allocations failed line: " MACRO_STR(__LINE__));

					gp_config::assertion(!bud.deallocate((char*)store.begin().data + 1), "misaligned deallocation fails");
					for(auto elem : ptr_set) {
						gp_config::assertion(!bud.empty(), "allocator should have elements");
						if(bud.deallocate(elem) == false)
						{
							res += 1;
						}
					}
					gp_config::assertion(!bud.deallocate(nullptr), "deallocating out of scope returns false");
					gp_config::assertion(bud.empty(), "allocator should be empty");
				}
			}
		});
		return res;
	}
};

append_test dummy_654sisd3(new buddy_test{});



// TODO: should implement a test that tries to wrongly remove pointers as well as to allocate them correctly
struct buddy_fuzz_test : public test_scaffold {
	buddy_fuzz_test() {
		name = std::string(__FILE__ "seed_") + std::to_string(seed) +  ":4";
		rng.seed(seed);
	}

	buddy_fuzz_test(size_t _seed) {
		seed = _seed;
		name = std::string(__FILE__ "seed_") + std::to_string(seed) +  ":4";
		rng.seed(seed);
	}

	std::mt19937 rng{};
	int seed = std::random_device{}();

	virtual int run() {
		int res = 0;
		alignas(8) gp::array<char, 4096> store;
		gp::buddy<gp::math::msb<uint64_t>(4096)> bud{&*store.begin(), store.size()};
		std::vector<void*> ptr_set;
		auto get_random_mem_qt = [&]() -> size_t {
			return 1+rng()%(store.size()-1);
		};

		auto start = std::chrono::steady_clock::now();
		{
			gp::repeat(FUZZ_STRENGTH, [&](){
				void* ptr;
				auto sz = get_random_mem_qt();
				size_t tries = 0;
				std::shuffle(
					ptr_set.begin(), 
					ptr_set.end(),
					rng
				);
				while(!(ptr = bud.allocate(sz)))
				{
					void* free_ptr = ptr_set.back();
					ptr_set.pop_back();
					gp_config::assertion(bud.deallocate(free_ptr), "could not free sample");
					gp_config::assertion(++tries <= store.size(), "infinite fuzzing");
				}
				ptr_set.emplace_back(ptr);
			});
			for(auto ptr : ptr_set)
			{
				bud.deallocate(ptr);
			}
			ptr_set.resize(0);
		}
		auto duration = std::chrono::steady_clock::now() - start;

		start = std::chrono::steady_clock::now();
		{
			size_t acc = 0;
			gp::repeat(FUZZ_STRENGTH, [&](){
				void* ptr;
				auto sz = get_random_mem_qt();
				size_t tries = 0;
				std::shuffle(
					ptr_set.begin(), 
					ptr_set.end(),
					rng
				);
				ptr = malloc(sz);
				acc+=1;
				while(acc > 20)
				{
					void* free_ptr = ptr_set.back();
					free(free_ptr);
					acc -= 1;
					ptr_set.pop_back();
					gp_config::assertion(++tries <= store.size(), "infinite fuzzing");
				}
				ptr_set.emplace_back(ptr);
			});
			for(auto ptr : ptr_set)
			{
				free(ptr);
			}
		}
		auto reference = std::chrono::steady_clock::now() - start;

		if(do_bench){
			std::cout 
			<< "Fuzzing timed at " 
			<< std::chrono::duration_cast<std::chrono::microseconds>(duration).count() 
			<< "µs for " 
			<< FUZZ_STRENGTH 
			<< " (reference: "
			<< std::chrono::duration_cast<std::chrono::microseconds>(reference).count() 
			<< "µs)"
			<< std::endl;
		}

		return res;
	}
};

append_test dummy_df987sd3(new buddy_fuzz_test{781017366});
append_test dummy_df4sisd3(new buddy_fuzz_test{});

struct ring_list_test : public test_scaffold {
	ring_list_test() {
		name = __FILE__ ":5";
	}

	virtual int run() {
		int res = 0;
		alignas(8) gp::array<char, 4096> store;
		using local_allocator = gp::buddy<gp::math::msb<uint64_t>(4096)>;
		local_allocator bud{&*store.begin(), store.size()};
		{
			using string_ring = gp::ring_list<std::string>;
			auto p = new(bud.allocate(sizeof(std::string))) std::string("Hello");
			auto orig = new(bud.allocate(sizeof(string_ring::node))) string_ring::node(p);
			string_ring ring{orig, bud};
			ring.insert("World");
			auto it = ring.explore();
			std::string test = "";
			do{
				test += *it;
				++it;
			}while(it != ring.explore());
			res += (test != "HelloWorld");
		}
		return res;
	}
};

append_test dummy_867fdrgsd3(new ring_list_test{});


struct aggregator_test : public test_scaffold {
	aggregator_test() {
		name = std::string(__FILE__ "seed_") + std::to_string(seed) +  ":6";
		rng.seed(seed);
	}

	std::mt19937 rng{};
	int seed = std::random_device{}();

	virtual int run() {
		int res = 0;
		alignas(8) gp::array<char, 4096> store;
		using local_allocator = gp::buddy<gp::math::msb<uint64_t>(4096)>;
		local_allocator bud{&*store.begin(), store.size()};
		alignas(8) gp::array<char, 4096> store2;
		local_allocator bud2{&*store2.begin(), store2.size()};

		gp::aggregator allocator(bud);
		allocator.insert(bud2);
		{
			std::vector<void*> ptr_set;
			auto get_random_mem_qt = [&]() -> size_t {
				return 1+rng()%(store.size()-1);
			};

			auto start = std::chrono::steady_clock::now();
			{
				gp::repeat(FUZZ_STRENGTH, [&](){
					void* ptr;
					auto sz = get_random_mem_qt();
					size_t tries = 0;
					std::shuffle(
						ptr_set.begin(), 
						ptr_set.end(),
						rng
					);
					while(!(ptr = allocator.allocate(sz)))
					{
						void* free_ptr = ptr_set.back();
						ptr_set.pop_back();
						gp_config::assertion(allocator.deallocate(free_ptr), "could not free sample");
						gp_config::assertion(++tries <= store.size(), "infinite fuzzing");
					}
					ptr_set.emplace_back(ptr);
				});
				for(auto ptr : ptr_set)
				{
					bud.deallocate(ptr);
				}
				ptr_set.resize(0);
			}
			auto duration = std::chrono::steady_clock::now() - start;
		}
		void* a = allocator.allocate(8);
		gp_config::assertion(allocator.try_reallocate(a, 16) == false, "could reallocate? was it implemented?");
		gp_config::assertion(allocator.deallocate(nullptr) == false, "error, could free an invalid pointer");
		allocator.deallocate(a);
		{
			gp::ring_list<int> list{allocator};
			list.insert(8);
			list.insert(16);
			list.insert(32);
		}
		{
			gp::array<char, 256> work_array;
			gp::arena alloc_work(work_array.begin().data, work_array.size());
			gp::ring_list<int> list{alloc_work};
			gp_config::assertion(list.insert(8) == true, "could allocate in list with good enough allocator");
			gp_config::assertion(list.insert(8) == true, "could allocate in list with good enough allocator");
			gp_config::assertion(list.insert(8) == true, "could allocate in list with good enough allocator");
		}
		{
			gp::array<char, sizeof(int)> once_array;
			gp::arena alloc_once(once_array.begin().data, once_array.size());
			gp::ring_list<int> list{alloc_once};
			gp_config::assertion(list.insert(8) == false, "could allocate in list with insufficient allocator");
		}
		{
			gp::arena alloc_none(nullptr, 0);
			gp::ring_list<int> list{alloc_none};
			gp_config::assertion(list.insert(8) == false, "could allocate in list with fake allocator");
		}
		return res;
	}
};

append_test dummy_8ijfsd658(new aggregator_test{});


struct array_test : public test_scaffold {
	array_test() {
		name = __FILE__ ":7";
	}

	virtual int run() {
		int res = 0;
		gp::array<int, 8> store;
		{
			int i = 0;
			for(auto& p : store)
			{
				p = i++;
			}
			for(auto it = store.rbegin(); it != store.rend(); ++it)
			{
				gp_config::assertion(*it == --i, "array error");
			}
			for(const auto& p : store)
			{
				gp_config::assertion(p == i++, "array error");
			}
			for(auto it = store.crbegin(); it != store.crend(); ++it)
			{
				gp_config::assertion(*it == --i, "array error");
			}
			size_t cnt = 0;
			for(const auto& p : store)
			{
				cnt++;
			}
			gp_config::assertion(cnt == store.size(), "array error");
			cnt = 0;
			for(auto& p : store)
			{
				cnt++;
			}
			gp_config::assertion(cnt == store.size(), "array error");
			cnt = 0;
			for(auto it = store.crbegin(); it != store.crend(); ++it)
			{
				cnt++;
			}
			gp_config::assertion(cnt == store.size(), "array error");
			cnt = 0;
			for(auto it = store.rbegin(); it != store.rend(); ++it)
			{
				cnt++;
			}
			gp_config::assertion(cnt == store.size(), "array error");
			gp::rotate(store.begin(), store.begin()+1, store.end());
			gp::array<int, 8> rotated({1,2,3,4,5,6,7,0});
			gp_config::assertion(store == rotated, "rotate error");
			gp::rotate(store.begin(), store.end()-1, store.end());
			gp_config::assertion(store[0] == 0, "rotate error");

		}
		return res;
	}
};

append_test dummy_ajcurgsd3(new array_test{});

struct indexed_array_test : public test_scaffold {
	indexed_array_test() {
		name = __FILE__ ":7";
	}

	virtual int run() {
		int res = 0;
		{
			gp::indexed_array<int, 8> store;
			size_t idx = store.push (112);
			store.push (113);
			store.push (114);
			gp_config::assertion(store[idx] == 112, "Bad value in indexed array");

			store.mark_for_removal(idx);
			store.sweep_removed();
			for(auto& p : store) {
				if(p == 112) res++;
			}

			gp_config::assertion(store.size() == 2, "Bad size of indexed array");
		}
		{
			gp::indexed_array<std::string, 8> store;
			size_t idx = store.push ("112");
			store.push ("113");
			store.push ("114");
			gp_config::assertion(store[idx] == "112", "Bad value in indexed array");

			store.mark_for_removal(idx);
			store.sweep_removed();
			for(auto& p : store) {
				if(p == "112") res++;
			}

			gp_config::assertion(store.size() == 2, "Bad size of indexed array");

			{
				// TODO: write a concrete implementation and test it
				// gp::vfs fs; 
			}
		}
		return res;
	}
};

append_test dummy_khxurgsd3(new indexed_array_test{});



struct move_uninitialized_test : public test_scaffold {
	move_uninitialized_test() {
		name = __FILE__ ":8";
	}

	struct tester {
		size_t* const incremented;

		tester(size_t* ptr)
		: incremented(ptr)
		{}

		tester(tester&& oth)
		: incremented(oth.incremented)
		{
			++*incremented;
		}
	};

	virtual int run() {
		int res = 0;
		{
			size_t counter;
			using src_t = gp::array<tester, 16>;
			src_t *source = reinterpret_cast<src_t*>(malloc(sizeof(src_t)));
			gp::array<char, sizeof(tester)*16> buffer;
			for(auto& a : *source) {
				new(&a) tester(&counter);
			}
			gp::move_uninitialized(*source, buffer.as_buffer().cast<tester>());
			free(source);
		}
		return res;
	}
};

append_test dummy_hkfyr5f5(new move_uninitialized_test{});



struct clamp_test : public test_scaffold {
	clamp_test() {
		name = __FILE__ ":9";
	}

	virtual int run() {
		int res = 0;
		{
			res += gp::clamp<float>(0.0, -1.0, 1.0);
			res += gp::clamp<float>(-1.0, 1.0, 0.0);
			res += gp::max(-1, -2, 0, -3);
		}
		return res;
	}
};

append_test dummy_gsdh25f5(new clamp_test{});

struct buffer_test : public test_scaffold {
	buffer_test() {
		name = __FILE__ ":10";
	}

	virtual int run() {
		int res = 0;
		{
			gp::array<char, 24> data;
			gp::array<char, 24> data_e;
			gp::buffer<char> handle = data.as_buffer();
			handle[12] = '&';
			gp_config::assertion(*(handle.begin()+12) == '&', "Could not assign to the buffer");
			res += 1;
			try {
				handle[24] = 16;
				res += 1;
				handle[-1] = 16;
				res += 1;
				handle[1024] = 16;
			} catch (...) {
				res -= 1;
			}
			res += 1;
			try {
				auto cast = handle.cast<gp::array<char, 32>>();
			} catch (...) {
				res -= 1;
			}
			auto cast = handle.template cast<gp::array<char, 6>>().template cast<gp::array<char, 4>>();
			gp_config::assertion(false == (data == data_e), "Different arrays should return false here");
		}
		return res;
	}
};

append_test dummy_gs87ytf5f5(new buffer_test{});



struct endian_test : public test_scaffold {
	endian_test() {
		name = __FILE__ ":11";
	}

	virtual int run() {
		int res = 0;
		{
			gp::endian_wrapper<uint32_t> a = 0x41424344UL;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfour-char-constants"
#pragma gcc diagnostic push
#pragma gcc diagnostic ignored "-Wfour-char-constants"
			gp_config::assertion(a.value != 'ABCD', "Not a big endian in a big endian wrapper");
#pragma gcc diagnostic pop
#pragma clang diagnostic pop
			gp_config::assertion(gp::swap_endian<uint32_t>(0x41424344UL)==0x44434241UL, "swap_endian doesn't swap endian");
		}
		return res;
	}
};

append_test dummy_45zelotf5f5(new endian_test{});

struct alloc_bench_test : public test_scaffold {
	alloc_bench_test() {
		name = __FILE__ ":12";
	}

	virtual int run() {
		int res = 0;
		if(do_bench) {
			auto store = std::make_unique<std::array<char, 1 << 16>>();
			using buddy_loc = gp::buddy<>;
			using arena_loc = gp::arena;
			buddy_loc bud{&*store->begin(), store->size()};
			arena_loc are{&*store->begin(), store->size()};
			
			std::cout << "Allocator | Operation | Divider | Time (µs)" << std::endl;

			for(size_t divider = 2; divider < 32; ++divider)
			{
				gp::ring_list<int> a{bud};
				gp::ring_list<int> b{are};

				std::cout <<
				"ARE | " << "INS | " << divider << " | " <<
				time_operation([&](){
					for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/divider; i++) {
						b.insert(i);
					}
				}).count() << std::endl;

				std::cout <<
				"ARE | " << "DEL | " << divider << " | " <<
				time_operation([&](){
					for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/divider; i++) {
						gp::ring_list<int>::explorer e = b.explore();
						b.remove(e);
					}
				}).count() << std::endl;

				std::cout <<
				"BUD | " << "INS | " << divider << " | " <<
				time_operation([&](){
					for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/divider; i++) {
						a.insert(i);
					}
				}).count() << std::endl;

				std::cout <<
				"BUD | " << "DEL | " << divider << " | " <<
				time_operation([&](){
					for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/divider; i++) {
						gp::ring_list<int>::explorer e = a.explore();
						a.remove(e);
					}
				}).count() << std::endl;
			}
			{
				gp::ring_list<int> a{bud};
				gp::ring_list<int> b{are};

				for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/2; i++) {
					a.insert(i);
				}

				for(size_t i = 0; i < store->size()/sizeof(gp::ring_list<int>::node)/2; i++) {
					gp::ring_list<int>::explorer e = a.explore();
					a.remove(++e);
				}
			}
		}

		return res;
	}
};

append_test dummy_jhgspo5d5(new alloc_bench_test{});

struct indexed_array_stair_test : public test_scaffold {
	indexed_array_stair_test() {
		name = __FILE__ ":13";
	}

	virtual int run() {
		int res = 0;
		{
			int climb = 0;
			int curr_climb = 0;
			gp::indexed_array<int, 1024> arr;
			while(climb < 1000)
			{
				for(; curr_climb < 10; climb++, curr_climb++ )
				{
					arr.push(climb);
				}

				for(; curr_climb != 0; curr_climb -= 2) {
					arr.pop(arr.size() - curr_climb);
				}

				arr.pop(arr.size() - 1);
			}
		}
		return res;
	}
};

append_test dummy_amf763ld5(new indexed_array_stair_test{});