#include "stdafx.h"
#include "tl/ptr.h"
#include <compare>

#include "tl/utest.h"
#include "TestHelpers.h"


struct Counters
{
	auto operator<=>(Counters const& other) const noexcept = default;
	bool operator==(Counters const& other) const noexcept = default;

	size_t ctor = 0;
	size_t dtor = 0;
	size_t copyCtor = 0;
	size_t moveCtor = 0;
	size_t copyAss = 0;
	size_t moveAss = 0;

	void resetCounters()
	{
		ctor = 0;
		dtor = 0;
		copyCtor = 0;
		moveCtor = 0;
		copyAss = 0;
		moveAss = 0;
	}
};

struct Test
{
	Test(size_t data = 0)
		: data(data)
	{
		s_counters.ctor++;
	}

	~Test()
	{
		s_counters.dtor++;
	}

	Test(const Test&)
	{
		s_counters.copyCtor++;
	}

	Test(Test&&)
	{
		s_counters.moveCtor++;
	}

	Test& operator=(const Test&)
	{
		s_counters.copyAss++;
		return *this;
	}

	Test& operator=(Test&&)
	{
		s_counters.moveAss++;
		return *this;
	}

	static void resetCounters()
	{
		s_counters.resetCounters();
	}

	size_t data = 0;
	static Counters s_counters;
};

Counters Test::s_counters;

#define SIMPLE_TEST(x) UTEST(x, ##x)

SIMPLE_TEST(lent_ptr_ctor)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::lent_ptr<Test> lptr;
	ASSERT_EQ(lptr.get(), nullptr);
	ASSERT_EQ(Test::s_counters, Counters{});
}

SIMPLE_TEST(lent_ptr_ctor_ptr)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::lendable<Test> t;
	tl::lent_ptr<Test> lptr(tl::lend(t));
	ASSERT_EQ(lptr.get(), &t.get());
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
}

SIMPLE_TEST(lent_ptr_copy_ctor)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lent_ptr<Test> lptr1;
		tl::lent_ptr<Test> lptr2(lptr1);
		ASSERT_EQ(lptr2.get(), nullptr);
		ASSERT_EQ(Test::s_counters, Counters{});
	}
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ptr<Test> lptr1(tl::lend(t));
		tl::lent_ptr<Test> lptr2(lptr1);
		ASSERT_EQ(lptr1.get(), &t.get());
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ptr_move_ctor)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lent_ptr<Test> lptr1;
		tl::lent_ptr<Test> lptr2(std::move(lptr1));
		ASSERT_EQ(lptr1.get(), nullptr);
		ASSERT_EQ(lptr2.get(), nullptr);
		ASSERT_EQ(Test::s_counters, Counters{});
	}
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ptr<Test> lptr1(tl::lend(t));
		tl::lent_ptr<Test> lptr2(std::move(lptr1));
		ASSERT_EQ(lptr1.get(), nullptr);
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ptr_copy_ass)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lent_ptr<Test> lptr1;
		tl::lent_ptr<Test> lptr2;
		lptr2 = lptr1;
		ASSERT_EQ(lptr2.get(), nullptr);
		ASSERT_EQ(Test::s_counters, Counters{});
	}
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ptr<Test> lptr1(tl::lend(t));
		tl::lent_ptr<Test> lptr2;
		lptr2 = lptr1;
		ASSERT_EQ(lptr1.get(), &t.get());
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ptr_move_ass)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lent_ptr<Test> lptr1;
		tl::lent_ptr<Test> lptr2;
		lptr2 = std::move(lptr1);
		ASSERT_EQ(lptr1.get(), nullptr);
		ASSERT_EQ(lptr2.get(), nullptr);
		ASSERT_EQ(Test::s_counters, Counters{});
	}
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ptr<Test> lptr1(tl::lend(t));
		tl::lent_ptr<Test> lptr2;
		lptr2 = std::move(lptr1);
		ASSERT_EQ(lptr1.get(), nullptr);
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ptr_unique_ptr)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ptr<Test> lptr1 = uptr;
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	ASSERT_EQ(lptr1.get(), uptr.get());
	ASSERT_NE((bool)lptr1, false);
	ASSERT_EQ(lptr1, uptr);
	ASSERT_EQ(lptr1, uptr.get());
	ASSERT_EQ(lptr1.get(), uptr);
	ASSERT_EQ(lptr1->data, 1234);

	lptr1 = nullptr;
	ASSERT_EQ(lptr1.get(), nullptr);
	ASSERT_EQ((bool)lptr1, false);
	ASSERT_EQ(lptr1, nullptr);
}

SIMPLE_TEST(lent_ptr_unique_ref)
{
	Test::resetCounters();
	tl::unique_ref<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ptr<Test> lptr1 = uptr;
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	ASSERT_EQ(lptr1.get(), uptr.get());
	ASSERT_EQ(lptr1, uptr);
	ASSERT_EQ(lptr1, uptr.get());
	ASSERT_EQ(lptr1.get(), uptr);
	ASSERT_EQ(lptr1->data, 1234);

	lptr1 = nullptr;
	ASSERT_EQ(lptr1.get(), nullptr);
	ASSERT_EQ((bool)lptr1, false);
	ASSERT_EQ(lptr1, nullptr);
}

SIMPLE_TEST(lent_ptr_unique_ptr_no_dangling)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ptr<Test> lptr = uptr;
	lptr = nullptr;

	uptr = nullptr; //no dangling here!

	lptr = uptr; //no dangling here!
}

SIMPLE_TEST(lent_ptr_unique_ptr_move_no_dangling)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	tl::unique_ptr<Test> uptr2;
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ptr<Test> lptr = uptr;

	uptr2 = std::move(uptr); //no dangling here!

	lptr = uptr2; //no dangling here!
}

SIMPLE_TEST(lent_ptr_unique_ptr_assign_nullptr_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uptr;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = nullptr; //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uptr;
		tl::lent_ptr<Test> lptr2 = uptr;
		tl::lent_ptr<Test> lptr3 = uptr;
		tl::lent_ptr<Test> lptr4 = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uptr;
		tl::lent_ptr<Test> lptr2 = std::move(lptr1);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
		{
			NO_ASSERT_GUARD;
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ptr_unique_ptr_assign_new_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uptr;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = {}; //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uptr;
		tl::lent_ptr<Test> lptr2 = uptr;
		tl::lent_ptr<Test> lptr3 = uptr;
		tl::lent_ptr<Test> lptr4 = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ptr_unique_ptr_reset_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uptr;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr.reset(); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uptr;
		tl::lent_ptr<Test> lptr2 = uptr;
		tl::lent_ptr<Test> lptr3 = uptr;
		tl::lent_ptr<Test> lptr4 = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ptr_unique_ptr_assign_move_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uptr;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uptr;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = std::move(uptr2); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		tl::unique_ptr<Test> uptr3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = std::move(uptr3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		tl::unique_ptr<Test> uptr3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ptr<Test> lptr1 = uptr1;
		tl::lent_ptr<Test> lptr2 = uptr2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = std::move(uptr3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uptr;
		tl::lent_ptr<Test> lptr2 = uptr;
		tl::lent_ptr<Test> lptr3 = uptr;
		tl::lent_ptr<Test> lptr4 = uptr;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


SIMPLE_TEST(lent_ptr_unique_ref_no_dangling)
{
	NO_ASSERT_GUARD;

	tl::lent_ptr<Test> lptr;

	{
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		lptr = uref;
		lptr = nullptr;
	}

	lptr = {}; //no dangling here!
}

SIMPLE_TEST(lent_ptr_unique_ref_move_no_dangling)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ref<Test> uref(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ptr<Test> lptr = uref;

	tl::unique_ref<Test> uref2 = std::move(uref); //no dangling here!

	lptr = uref2; //no dangling here!
	lptr = nullptr; //to avoid a legit dangling when the uref2 goes out of scope
}

SIMPLE_TEST(lent_ptr_unique_ref_assign_nullptr_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uref;
		tl::lent_ptr<Test> lptr2 = uref;
		tl::lent_ptr<Test> lptr3 = uref;
		tl::lent_ptr<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}


SIMPLE_TEST(lent_ptr_unique_ref_reset_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref.reset(new Test(1234)); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lent_ptr<Test> lptr1 = uref;
		tl::lent_ptr<Test> lptr2 = uref;
		tl::lent_ptr<Test> lptr3 = uref;
		tl::lent_ptr<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ptr_unique_ref_assign_move_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ptr<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref = std::move(uref2); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = {}; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		tl::unique_ref<Test> uref3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = std::move(uref3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		tl::unique_ref<Test> uref3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ptr<Test> lptr1 = uref1;
		tl::lent_ptr<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = std::move(uref3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ptr<Test> lptr1 = uref;
		tl::lent_ptr<Test> lptr2 = uref;
		tl::lent_ptr<Test> lptr3 = uref;
		tl::lent_ptr<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = {}; //dangling here!
		}
	}
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

SIMPLE_TEST(lent_ref_ctor_ptr)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::lendable<Test> t;
	tl::lent_ref<Test> lptr(tl::lend(t));
	ASSERT_EQ(lptr.get(), &t.get());
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
}

SIMPLE_TEST(lent_ref_copy_ctor)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ref<Test> lptr1(tl::lend(t));
		tl::lent_ref<Test> lptr2(lptr1);
		ASSERT_EQ(lptr1.get(), &t.get());
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ref_move_ctor)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::lent_ref<Test> lptr1(tl::lend(t));
		tl::lent_ref<Test> lptr2(std::move(lptr1));
		{
			EXPECTED_CRASH_GUARD("nullptr");
			ASSERT_EQ(lptr1.get(), nullptr);
		}
		ASSERT_EQ(lptr2.get(), &t.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	}
}

SIMPLE_TEST(lent_ref_copy_ass)
{
	NO_ASSERT_GUARD;

	{
		Test::resetCounters();
		tl::lendable<Test> t1;
		tl::lendable<Test> t2;
		tl::lent_ref<Test> lptr1(tl::lend(t1));
		tl::lent_ref<Test> lptr2(tl::lend(t2));
		lptr2 = lptr1;
		ASSERT_EQ(lptr1.get(), &t1.get());
		ASSERT_EQ(lptr2.get(), &t1.get());
		ASSERT_EQ(t1->s_counters, Counters{.ctor = 2});
	}
}

SIMPLE_TEST(lent_ref_move_ass)
{
	NO_ASSERT_GUARD;
	
	{
		Test::resetCounters();
		tl::lendable<Test> t1;
		tl::lendable<Test> t2;
		tl::lent_ref<Test> lptr1(tl::lend(t1));
		tl::lent_ref<Test> lptr2(tl::lend(t2));
		lptr2 = std::move(lptr1);
		{
			EXPECTED_CRASH_GUARD("nullptr");
			ASSERT_EQ(lptr1.get(), nullptr);
		}
		ASSERT_EQ(lptr2.get(), &t1.get());
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});
	}
}

SIMPLE_TEST(lent_ref_unique_ptr)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ref<Test> lptr1 = tl::promote(uptr);
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	ASSERT_EQ(lptr1.get(), uptr.get());
	ASSERT_EQ(lptr1, uptr);
	ASSERT_EQ(lptr1, uptr.get());
	ASSERT_EQ(lptr1.get(), uptr);
	ASSERT_EQ(lptr1->data, 1234);
}

SIMPLE_TEST(lent_ref_unique_ref)
{
	Test::resetCounters();
	tl::unique_ref<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ref<Test> lptr1 = uptr;
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});
	ASSERT_EQ(lptr1.get(), uptr.get());
	ASSERT_EQ(lptr1, uptr);
	ASSERT_EQ(lptr1, uptr.get());
	ASSERT_EQ(lptr1.get(), uptr);
	ASSERT_EQ(lptr1->data, 1234);
}

SIMPLE_TEST(lent_ref_unique_ptr_no_dangling)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	{
		tl::lent_ref<Test> lptr = tl::promote(uptr);
	} //no dangling here!

	uptr = nullptr; 
}

SIMPLE_TEST(lent_ref_unique_ptr_move_no_dangling)
{
	NO_ASSERT_GUARD;

	Test::resetCounters();
	tl::unique_ptr<Test> uptr(new Test(1234));
	tl::unique_ptr<Test> uptr2;
	ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

	tl::lent_ref<Test> lptr = tl::promote(uptr);

	uptr2 = std::move(uptr); //no dangling here!

	lptr = tl::promote(uptr2); //no dangling here!
}

SIMPLE_TEST(lent_ref_unique_ptr_assign_nullptr_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = tl::promote(uptr);
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = nullptr; //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr);
		tl::lent_ref<Test> lptr3 = tl::promote(uptr);
		tl::lent_ref<Test> lptr4 = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = nullptr; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ref_unique_ptr_assign_new_dangling)
{
	{
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		tl::lendable<Test> t;
		tl::lent_ref<Test> lptr = tl::promote(uptr);

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = tl::promote(uptr);
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = {}; //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr);
		tl::lent_ref<Test> lptr3 = tl::promote(uptr);
		tl::lent_ref<Test> lptr4 = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = {}; //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ref_unique_ptr_reset_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = tl::promote(uptr);
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr.reset(); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr);
		tl::lent_ref<Test> lptr3 = tl::promote(uptr);
		tl::lent_ref<Test> lptr4 = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr.reset(); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ref_unique_ptr_assign_move_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = tl::promote(uptr);

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = tl::promote(uptr);
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uptr = std::move(uptr2); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		tl::unique_ptr<Test> uptr3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = std::move(uptr3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ptr<Test> uptr1(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		tl::unique_ptr<Test> uptr3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr1);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr2);
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uptr1 = std::move(uptr3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ptr<Test> uptr(new Test(1234));
		tl::unique_ptr<Test> uptr2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = tl::promote(uptr);
		tl::lent_ref<Test> lptr2 = tl::promote(uptr);
		tl::lent_ref<Test> lptr3 = tl::promote(uptr);
		tl::lent_ref<Test> lptr4 = tl::promote(uptr);
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uptr = std::move(uptr2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


SIMPLE_TEST(lent_ref_unique_ref_assign_nullptr_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref;
		tl::lent_ref<Test> lptr2 = uref;
		tl::lent_ref<Test> lptr3 = uref;
		tl::lent_ref<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref = tl::unique_ref<Test>(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}


SIMPLE_TEST(lent_ref_unique_ref_reset_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 1});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref.reset(new Test(1234)); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		tl::lent_ref<Test> lptr1 = uref;
		tl::lent_ref<Test> lptr2 = uref;
		tl::lent_ref<Test> lptr3 = uref;
		tl::lent_ref<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref.reset(new Test(1234)); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}

SIMPLE_TEST(lent_ref_unique_ref_assign_move_dangling)
{
	{
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = uref;

		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//destructor
		Test::resetCounters();
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 2});

		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			tl::lent_ref<Test> lptr = uref;
			{
				EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
				uref = std::move(uref2); //dangling here!
			}
		} //dangling here!
	}
	{
		//reset
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to empty ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr = tl::lend(t); //dangling here!
		}
	}
	{
		//copy assignment to another valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		tl::unique_ref<Test> uref3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = std::move(uref3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = lptr2; //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::unique_ref<Test> uref1(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		tl::unique_ref<Test> uref3(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = uref1;
		tl::lent_ref<Test> lptr2 = uref2;
		{
			EXPECTED_ASSERT_GUARD("unique: 1 dangling lent ptrs detected");
			uref1 = std::move(uref3); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr1 = std::move(lptr2); //dangling here!
		}
	}
	{
		//move assignment to a valid ptr
		Test::resetCounters();
		tl::lendable<Test> t;
		tl::unique_ref<Test> uref(new Test(1234));
		tl::unique_ref<Test> uref2(new Test(1234));
		ASSERT_EQ(Test::s_counters, Counters{.ctor = 3});

		tl::lent_ref<Test> lptr1 = uref;
		tl::lent_ref<Test> lptr2 = uref;
		tl::lent_ref<Test> lptr3 = uref;
		tl::lent_ref<Test> lptr4 = uref;
		{
			EXPECTED_ASSERT_GUARD("unique: 4 dangling lent ptrs detected");
			uref = std::move(uref2); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 4 dangling lent ptrs detected");
			lptr1 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 3 dangling lent ptrs detected");
			lptr2 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 2 dangling lent ptrs detected");
			lptr3 = tl::lend(t); //dangling here!
		}
		{
			EXPECTED_ASSERT_GUARD("lent: 1 dangling lent ptrs detected");
			lptr4 = tl::lend(t); //dangling here!
		}
	}
}