test(kernel/std): 🧪 add tests for std::shared_ptr

Kernel/tests/stl/shared_ptr.cpp

@@ -0,0 +1,187 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel 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, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR 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 Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#ifdef DEBUG
+
+#include <functional>
+#include <assert.h>
+#include <memory>
+
+struct Base
+{
+	virtual ~Base() = default;
+	virtual int id() const { return 1; }
+};
+struct Derived : Base
+{
+	int id() const override { return 2; }
+};
+
+struct Deleter
+{
+	bool *flag;
+	Deleter(bool *f) : flag(f) {}
+	void operator()(int *p) const
+	{
+		*flag = true;
+		delete p;
+	}
+};
+
+void test_shared_ptr_bitset()
+{
+	debug("std::shared_ptr  ...");
+
+	/* 1. constructor default */
+
+	std::shared_ptr<int> p1;
+	assert(!p1);
+	assert(p1.use_count() == 0);
+
+	/* 2. constructor from raw ptr, get(), *, use_count(), operator bool */
+
+	auto p2 = std::shared_ptr<int>(new int(5));
+	assert(p2);
+	assert(p2.use_count() == 1);
+	assert(*p2 == 5);
+	assert(p2.get() && *p2 == 5);
+
+	/* 3. copy/move ctor */
+
+	auto p3 = p2;
+	assert(p2.use_count() == 2 && p3.use_count() == 2);
+	auto p4 = std::move(p3);
+	assert(p4.use_count() == 2 && p3.use_count() == 0);
+
+	/* 4. copy/move assign */
+
+	std::shared_ptr<int> p5;
+	p5 = p4;
+	assert(p5.use_count() == 3);
+	std::shared_ptr<int> p6;
+	p6 = std::move(p5);
+	assert(p6.use_count() == 3 && p5.use_count() == 0);
+
+	/* 5. reset() */
+
+	p6.reset();
+	assert(!p6 && p6.use_count() == 0);
+	p4.reset(new int(10));
+	assert(*p4 == 10);
+
+	/* 6. swap() member and std::swap */
+
+	p4.swap(p2);
+	assert(*p2 == 10 && *p4 == 5);
+	std::swap(p2, p4);
+	assert(*p4 == 10 && *p2 == 5);
+
+	/* 7. observers: ->, *, get() already checked */
+
+	struct S
+	{
+		int x;
+	};
+	auto ps = std::make_shared<S>();
+	ps->x = 7;
+	assert((*ps).x == 7 && ps.get()->x == 7);
+
+	/* 8. use_count(), operator bool already checked */
+
+	/* 9. owner_before() */
+
+	auto pa = std::make_shared<int>(1);
+	auto pb = std::make_shared<int>(1);
+	assert(pa.owner_before(pb) || pb.owner_before(pa));
+
+	/* 10. make_shared, allocate_shared */
+
+	auto pm = std::make_shared<int>(42);
+	assert(pm && *pm == 42);
+	std::allocator<int> allo;
+	auto pa2 = std::allocate_shared<int>(allo, 99);
+	assert(*pa2 == 99);
+
+	/* 11. static_pointer_cast, dynamic_pointer_cast, const_pointer_cast, reinterpret_pointer_cast */
+
+	debug("skipping static_pointer_cast, dynamic_pointer_cast, const_pointer_cast, reinterpret_pointer_cast");
+
+	// auto pd = std::make_shared<Derived>();
+	// std::shared_ptr<Base> pb2 = std::static_pointer_cast<Base>(pd);
+	// assert(pb2->id() == 2);
+
+	// std::shared_ptr<Base> base = std::make_shared<Derived>();
+	// auto dyn = std::dynamic_pointer_cast<Derived>(base);
+	// assert(dyn && dyn->id() == 2);
+	// std::shared_ptr<Base> base2 = std::make_shared<Base>();
+	// auto dyn2 = std::dynamic_pointer_cast<Derived>(base2);
+	// assert(!dyn2);
+
+	// auto pc = std::make_shared<const int>(123);
+	// auto pnc = std::const_pointer_cast<int>(pc);
+	// assert(*pnc == 123);
+	// *pnc = 124;
+	// assert(*pnc == 124);
+
+	// auto pint = std::make_shared<int>(65);
+	// auto pchar = std::reinterpret_pointer_cast<char>(pint);
+	// assert(pchar.get() == reinterpret_cast<char *>(pint.get()));
+
+	/* 12. comparison operators ==, !=, <, <=, >, >= */
+
+	debug("skipping comparison operators ==, !=, <, <=, >, >=");
+
+	// auto c1 = std::make_shared<int>(1);
+	// auto c2 = std::make_shared<int>(1);
+	// auto c3 = c1;
+	// assert(c1 == c3);
+	// assert(c1 != c2);
+	// assert((c2 < c1) == (c2.get() < c1.get()));
+	// assert(c1 <= c3);
+	// assert(c1 >= c3);
+
+	/* 13. operator<< */
+
+	debug("skipping operator<<");
+
+	// std::ostringstream oss;
+	// std::shared_ptr<int> pnull;
+	// oss << pnull;
+	// assert(oss.str() == \"0\");
+
+	/* 14. get_deleter */
+
+	debug("skipping get_deleter");
+
+	// bool flag = false;
+	// std::shared_ptr<int> pd1(new int(7), Deleter(&flag));
+	// auto d = std::get_deleter<Deleter>(pd1);
+	// assert(d && d->flag == &flag);
+	// pd1.reset();
+	// assert(flag);
+
+	/* 15. std::hash<shared_ptr> */
+
+	debug("skipping std::hash<shared_ptr>");
+
+	// std::hash<std::shared_ptr<int>> h;
+	// assert(h(c1) == std::hash<int *>()(c1.get()));
+
+	debug("std::shared_ptr  OK");
+}
+
+#endif // DEBUG