track_ptr/t_ptr_test.cpp at master · FatihBAKIR/track_ptr · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
#include <vector>
#include <cassert>
#include "track_ptr.hpp"

using namespace malt;

struct Widget
	: public tracked
{
	int val;

	Widget() : val(0) {}
	Widget(int v) : val(v) {}
};

void test_1()
{
	std::vector<Widget> comps;
	std::vector<track_ptr<Widget>> ptrs;

	for (int i = 0; i < 1000; ++i)
	{
		comps.emplace_back(i);
		ptrs.emplace_back(get_ptr(comps.back()));

		for (int j = 0; j <= i; ++j)
		{
			assert(ptrs[j]->val == j);
		}
	}

	comps.clear();

	for (auto& ptr : ptrs)
	{
		assert(ptr == nullptr);
	}
}

void test_2()
{
	std::vector<Widget> comps;
	comps.emplace_back(10);

	auto p = get_ptr(comps[0]);
	auto p2 = std::move(p);
	auto p3 = p2;

	comps.resize(100);

	assert (p == nullptr);
	assert (p2.get() == &comps.front());
	assert (p2 == p3);

	comps.clear();

	assert (p2 == nullptr);
	assert (p3 == nullptr);
}

void test_3()
{
	Widget c (10);
	track_ptr<Widget> c_p (get_ptr(c));
	assert (c_p->val == 10);
}

void test_4()
{
	Widget w;
	w.val = 10;
	auto w_p = get_ptr(w);

	Widget w2;
	w2.val = 15;
	w2 = w;

	assert(w_p != nullptr);
	assert(w_p->val == 10);

	w2 = std::move(w);

	assert(w_p != nullptr);
	assert(w_p->val == 10);
}

int main()
{
	Widget c;

	auto p = get_ptr(c);
	track_ptr<tracked> pp = get_ptr(c);
	p->val = 3;

	Widget d = std::move(c);
    c.val = 0;

	p->val = 10;
	std::cout << d.val << '\n';
	std::cout << p->val << '\n';

	std::cout << ((Widget*)pp.get())->val << '\n';

	track_ptr<Widget> wp1 = p;
	track_ptr<Widget> wp = pointer_cast<Widget>(pp);

	test_1();
	test_2();
	test_3();
	test_4();
}