Initial

Containers/tests/AvlTest.cpp

@@ -0,0 +1,31 @@
+
+#include "Tests.hpp"
+
+#include "AvlTree.hpp"
+
+#include "Testing.hpp"
+
+#include <iostream>
+
+using namespace tp;
+
+TEST_DEF_STATIC(Simple) {
+  AvlTree<AvlNumericKey<alni>, TestClass, TestAllocator> tree;
+
+  TEST(tree.size() == 0);
+  TEST(tree.head() == nullptr);
+
+  tree.insert(6, TestClass(6));
+  TEST(tree.isValid());
+  TEST(tree.size() == 1);
+  TEST(tree.head()->data == TestClass(6));
+
+  tree.remove(6);
+  TEST(tree.isValid());
+  TEST(tree.size() == 0);
+  TEST(tree.head() == nullptr);
+}
+
+TEST_DEF(Avl) {
+  testSimple();
+}

Containers/tests/ListTest.cpp

@@ -0,0 +1,88 @@
+
+#include "Tests.hpp"
+#include "Testing.hpp"
+
+#include <iostream>
+
+using namespace tp;
+
+TEST_DEF_STATIC(SimpleReference) {
+  tp::List<TestClass, TestAllocator> list = { TestClass(1), TestClass(2), TestClass(3), TestClass(4) };
+
+  list.pushBack(TestClass(5));
+  list.pushFront(TestClass(0));
+
+  ualni i = -1;
+  for (auto iter : list) {
+    i++;
+    TEST_EQUAL(iter->getVal(), i);
+  }
+
+  TEST(i == 5);
+
+  list.removeAll();
+  TEST(list.getAllocator().getAllocationsCount() == 0);
+}
+
+TEST_DEF_STATIC(SimplePointer) {
+  tp::List<TestClass*, TestAllocator> list = { new TestClass(1), new TestClass(2), new TestClass(3), new TestClass(4) };
+
+  list.pushBack(new TestClass(5));
+  list.pushFront(new TestClass(0));
+
+  ualni i = -1;
+  for (auto iter : list) {
+    i++;
+    TEST_EQUAL(iter->getVal(), i);
+  }
+
+  TEST(i == 5);
+
+  list.removeAll();
+
+  TEST(list.getAllocator().getAllocationsCount()  == 0);
+}
+
+TEST_DEF_STATIC(Copy) {
+  tp::List<TestClass, TestAllocator> list = { TestClass(1), TestClass(2), TestClass(3), TestClass(4) };
+  tp::List<TestClass, TestAllocator> list2 = list;
+
+  TEST_EQUAL(list, list2);
+
+  list.removeAll();
+  list2.removeAll();
+
+  TEST(list.getAllocator().getAllocationsCount()  == 0);
+  TEST(list2.getAllocator().getAllocationsCount()  == 0);
+}
+
+TEST_DEF_STATIC(SaveLoad) {
+  tp::List<TestClass, TestAllocator> list = { TestClass(1), TestClass(2), TestClass(3), TestClass(4) };
+
+  TestFile file;
+
+  list.write(file);
+
+  list.removeAll();
+
+  file.setAddress(0);
+
+  list.read(file);
+
+  ualni i = 0;
+  for (auto iter : list) {
+    i++;
+    TEST_EQUAL(iter->getVal(), i);
+  }
+  TEST(i == 4);
+
+  list.removeAll();
+
+  TEST(list.getAllocator().getAllocationsCount()  == 0);
+}
+
+TEST_DEF(List) {
+  testSimplePointer();
+  testSimpleReference();
+  testSaveLoad();
+}

Containers/tests/MapTest.cpp

@@ -0,0 +1,137 @@
+
+#include "Tests.hpp"
+#include "Testing.hpp"
+
+#include "Map.hpp"
+
+#include <iostream>
+
+using namespace tp;
+
+TEST_DEF_STATIC(SimpleReference) {
+  tp::Map<tp::ualni, TestClass, TestAllocator> map;
+
+  for (auto i : Range(1000, 100000)) {
+    map.put(i, TestClass(i));
+  }
+
+  for (auto i : Range(1000, 100000)) {
+    TEST(map.presents(i));
+    TEST_EQUAL(map.get(i).getVal(), i);
+  }
+
+  for (auto i : Range(1000, 100000)) {
+    map.put(i, TestClass(i));
+  }
+
+  for (auto i : Range(1000, 2000)) {
+    TEST(map.presents(i));
+    map.remove(i);
+    TEST(!map.presents(i));
+  }
+
+  for (auto i : Range(2000, 100000)) {
+    TEST(map.presents(i));
+    TEST_EQUAL(map.get(i).getVal(), i);
+  }
+
+  for (auto i : map) {
+    i->val.setVal(3);
+  }
+
+  map.removeAll();
+
+  TEST(map.getAllocator().getAllocationsCount()  == 1);
+}
+
+TEST_DEF_STATIC(SimplePointer) {
+  tp::Map<tp::ualni, TestClass*, TestAllocator> map;
+
+  for (auto i : Range(1000)) {
+    map.put(i, new TestClass(i));
+  }
+
+  for (auto i : Range(1000)) {
+    TEST(map.presents(i));
+    TEST_EQUAL(map.get(i)->getVal(), i);
+  }
+
+  for (auto i : Range(1000)) {
+    map.put(i, new TestClass(i));
+  }
+
+  for (auto i : Range(900, 1000)) {
+    TEST(map.presents(i));
+    map.remove(i);
+    TEST(!map.presents(i));
+  }
+
+  for (auto i : Range(900)) {
+    TEST(map.presents(i));
+    TEST_EQUAL(map.get(i)->getVal(), i);
+  }
+
+  for (auto i : map) {
+    i->val->setVal(3);
+    delete i->val;
+  }
+
+  map.removeAll();
+
+  TEST(map.getAllocator().getAllocationsCount()  == 1);
+}
+
+TEST_DEF_STATIC(Copy) {
+  tp::Map<tp::ualni, TestClass, TestAllocator> map;
+
+  for (auto i : Range(10)) {
+    map.put(i, TestClass(i));
+  }
+
+  tp::Map<tp::ualni, TestClass, TestAllocator> map2 = map;
+
+  TEST_EQUAL(map, map2);
+
+  map.removeAll();
+  map2.removeAll();
+
+  TEST(map.getAllocator().getAllocationsCount()  == 1);
+  TEST(map2.getAllocator().getAllocationsCount()  == 1);
+}
+
+TEST_DEF_STATIC(SaveLoad) {
+  tp::Map<tp::ualni, TestClass, TestAllocator> map;
+
+  for (auto i : Range(10)) {
+    map.put(i, TestClass(i));
+  }
+
+  TestFile file;
+
+  map.write(file);
+
+  map.removeAll();
+
+  TEST(map.getAllocator().getAllocationsCount()  == 1);
+
+  file.setAddress(0);
+
+  map.read(file);
+
+  TEST(map.getAllocator().getAllocationsCount()  == 11);
+
+  for (auto i : Range(10)) {
+    TEST(map.presents(i));
+    TEST_EQUAL(map.get(i).getVal(), i);
+  }
+
+  map.removeAll();
+
+  TEST(map.getAllocator().getAllocationsCount()  == 1);
+}
+
+TEST_DEF(Map) {
+  testSimplePointer();
+  testSimpleReference();
+  testSaveLoad();
+}

Containers/tests/Tests.cpp

@@ -0,0 +1,41 @@
+
+#include "Tests.hpp"
+
+#include "Testing.hpp"
+
+#include <cstdlib>
+
+static bool init(const tp::ModuleManifest* self) {
+  tp::gTesting.setRootName(self->getName());
+  return true;
+}
+
+void* TestAllocator::allocate(tp::ualni size) {
+  nAllocations++;
+  return malloc(size);
+}
+
+void TestAllocator::deallocate(void* p) {
+  nAllocations--;
+  free(p);
+}
+
+tp::ualni TestAllocator::getAllocationsCount() const {
+  return nAllocations;
+}
+
+int main() {
+
+  tp::ModuleManifest* deps[] = { &tp::gModuleUtils, nullptr };
+  tp::ModuleManifest testModule("ContainersTest", init, nullptr, deps);
+
+  if (!testModule.initialize()) {
+    return 1;
+  }
+
+  testList();
+  testMap();
+  testAvl();
+
+  testModule.deinitialize();
+}

Containers/tests/Tests.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "Utils.hpp"
+
+class TestClass {
+  tp::ualni val2 = 0;
+  tp::ualni val1;
+public:
+
+  explicit TestClass(tp::ualni val) : val1(val) {}
+
+  template<class Saver>
+  void write(Saver& file) const {
+    file.write(val1);
+  }
+
+  template<class Loader>
+  void read(Loader& file) {
+    file.read(val1);
+  }
+
+  [[nodiscard]] bool operator==(const TestClass& in) const {
+    return in.val1 == val1;
+  }
+
+  [[nodiscard]] tp::ualni getVal() const { return val1; }
+  void setVal(tp::ualni val) { val1 = val; }
+};
+
+class TestAllocator {
+  tp::ualni nAllocations = 0;
+public:
+  TestAllocator() = default;
+  void* allocate(tp::ualni size);
+  void deallocate(void* p);
+  [[nodiscard]] tp::ualni getAllocationsCount() const;
+};
+
+class TestFile {
+  tp::ualni mem[1024] = { 0 };
+  tp::ualni address = 0;
+
+public:
+  TestFile() = default;
+
+  template<typename Type>
+  void write(const Type& val) {
+    val.write(*this);
+  }
+
+  template<>
+  void write<tp::ualni>(const tp::ualni& val) {
+    mem[address] = val;
+    address++;
+  }
+
+  void setAddress(tp::ualni addr) { address = addr; }
+
+  template<typename Type>
+  void read(Type& val) {
+    val.read(*this);
+  }
+
+  template<>
+  void read<tp::ualni>(tp::ualni& val) {
+    val = mem[address];
+    address++;
+  }
+};
+
+void testList();
+void testMap();
+void testAvl();