Line data Source code
1 : /*
2 : * array.c
3 : * Patater GUI Kit
4 : *
5 : * Created by Jaeden Amero on 2020-04-21.
6 : * Copyright 2021. SPDX-License-Identifier: AGPL-3.0-or-later
7 : */
8 :
9 : #include "guikit/array.h"
10 : #include "ptest/test.h"
11 :
12 1 : static int test_null_array_len_0(void)
13 : {
14 1 : long *a = NULL;
15 :
16 1 : TEST_EQ(array_len(a), 0);
17 :
18 1 : return 0;
19 : }
20 :
21 1 : static int test_null_array_cap_0(void)
22 : {
23 1 : long *a = NULL;
24 :
25 1 : TEST_EQ(array_cap(a), 0);
26 :
27 1 : return 0;
28 : }
29 :
30 1 : static int test_grow_1(void)
31 : {
32 1 : long *a = NULL;
33 :
34 1 : array_grow(a, 1);
35 :
36 1 : TEST_NEP(a, NULL);
37 1 : TEST_EQ(array_len(a), 0);
38 1 : TEST_GT(array_cap(a), 0);
39 :
40 1 : array_free(a);
41 :
42 1 : return 0;
43 : }
44 :
45 1 : static int test_push_1(void)
46 : {
47 1 : long *a = NULL;
48 1 : long val = 1234;
49 :
50 1 : array_push(a, val);
51 :
52 1 : TEST_EQ(a[0], val);
53 1 : TEST_EQ(array_len(a), 1);
54 1 : TEST_GT(array_cap(a), 0);
55 :
56 1 : array_free(a);
57 :
58 1 : return 0;
59 : }
60 :
61 1 : static int test_pop_1(void)
62 : {
63 1 : long *a = NULL;
64 1 : long val = 1234;
65 : long got;
66 :
67 1 : array_push(a, val);
68 1 : got = array_pop(a);
69 :
70 1 : TEST_EQ(got, val);
71 1 : TEST_EQ(array_len(a), 0);
72 1 : TEST_GT(array_cap(a), 0);
73 :
74 1 : array_free(a);
75 :
76 1 : return 0;
77 : }
78 :
79 1 : static int test_grow_2(void)
80 : {
81 1 : long *a = NULL;
82 :
83 1 : array_grow(a, 2);
84 :
85 1 : TEST_NEP(a, NULL);
86 1 : TEST_EQ(array_len(a), 0);
87 1 : TEST_GE(array_cap(a), 2);
88 :
89 1 : array_free(a);
90 :
91 1 : return 0;
92 : }
93 :
94 1 : static int test_push_2(void)
95 : {
96 1 : long *a = NULL;
97 1 : long val[] = { 1234, 5678 };
98 :
99 1 : array_push(a, val[0]);
100 1 : array_push(a, val[1]);
101 :
102 1 : TEST_EQ(a[0], val[0]);
103 1 : TEST_EQ(a[1], val[1]);
104 1 : TEST_EQ(array_len(a), 2);
105 1 : TEST_GE(array_cap(a), 2);
106 :
107 1 : array_free(a);
108 :
109 1 : return 0;
110 : }
111 :
112 1 : static int test_pop_2(void)
113 : {
114 1 : long *a = NULL;
115 1 : long val[] = { 1234, 5678 };
116 : long got;
117 :
118 1 : array_push(a, val[0]);
119 1 : array_push(a, val[1]);
120 :
121 1 : got = array_pop(a);
122 1 : TEST_EQ(got, val[1]);
123 :
124 1 : got = array_pop(a);
125 1 : TEST_EQ(got, val[0]);
126 :
127 1 : TEST_EQ(array_len(a), 0);
128 1 : TEST_GT(array_cap(a), 0);
129 :
130 1 : array_free(a);
131 :
132 1 : return 0;
133 : }
134 :
135 1 : static int test_amortized_constant_growth(void)
136 : {
137 : /* Test that allocation are amortized constant time. To do this, we have to
138 : * expect the method to accomplish this is to double the array size when
139 : * more space is needed. If the method to accomplish amortized constant
140 : * time allocation changes, this test will need changing as well. */
141 1 : long *a = NULL;
142 1 : long val = 1234;
143 :
144 1 : array_push(a, val);
145 1 : array_push(a, val);
146 1 : array_push(a, val);
147 :
148 1 : TEST_EQ(array_len(a), 3);
149 1 : TEST_EQ(array_cap(a), 4);
150 :
151 1 : array_free(a);
152 :
153 1 : return 0;
154 : }
155 :
156 1 : static int test_null_array_free(void)
157 : {
158 1 : long *a = NULL;
159 :
160 1 : array_free(a);
161 :
162 1 : TEST_EQP(a, NULL);
163 :
164 1 : return 0;
165 : }
166 :
167 1 : static int test_free(void)
168 : {
169 1 : long *a = NULL;
170 1 : long val = 1234;
171 :
172 1 : array_push(a, val);
173 :
174 1 : TEST_NEP(a, NULL);
175 :
176 1 : array_free(a);
177 :
178 1 : TEST_EQP(a, NULL);
179 :
180 1 : return 0;
181 : }
182 :
183 : const test_fn tests[] =
184 : {
185 : test_null_array_len_0,
186 : test_null_array_cap_0,
187 : test_grow_1,
188 : test_push_1,
189 : test_pop_1,
190 : test_grow_2,
191 : test_push_2,
192 : test_pop_2,
193 : test_amortized_constant_growth,
194 : test_null_array_free,
195 : test_free,
196 : 0
197 : };
|
