1 #include <assert.h>
2 #include "test_helper.h"
3 #include "../src/stack.h"
4
test_stack_init()5 void test_stack_init() {
6 struct stack *stack;
7
8 stack_malloc(&stack);
9 stack_init(stack);
10
11 assert(stack->card->value == NO_VALUE);
12 assert(!stack->next);
13
14 stack_free(stack);
15 }
16
test_stack_dup()17 void test_stack_dup() {
18 struct stack *stack_0, *stack_1;
19 struct card *card[5];
20 const int begin_y = 5, begin_x = 10;
21
22 stack_malloc(&stack_0);
23 stack_init(stack_0);
24 for (int i = 0; i < 5; i++) {
25 card_malloc(&card[i]);
26 card_set(card[i], i, SPADES, EXPOSED, begin_y, begin_x);
27 stack_push(&stack_0, card[i]);
28 }
29 stack_1 = stack_dup(stack_0);
30
31 assert(stack_0 != stack_1);
32 assert(stacks_equal(stack_0, stack_1));
33
34 stack_free(stack_0);
35 stack_free(stack_1);
36 }
37
test_stack_empty_on_stack_empty_stack()38 void test_stack_empty_on_stack_empty_stack() {
39 struct stack *stack;
40
41 stack_malloc(&stack);
42 stack_init(stack);
43
44 assert(stack_empty(stack));
45
46 stack_free(stack);
47 }
48
test_stack_empty_on_non_stack_empty_stack()49 void test_stack_empty_on_non_stack_empty_stack() {
50 struct stack *stack;
51 struct card *card;
52
53 card_malloc(&card);
54 card_init(card);
55 card_set(card, ACE, SPADES, EXPOSED, 0, 0);
56
57 stack_malloc(&stack);
58 stack_init(stack);
59 stack_push(&stack, card);
60
61 assert(!stack_empty(stack));
62
63 stack_free(stack);
64 }
65
test_stack_length()66 void test_stack_length() {
67 struct stack *stack;
68 struct card *card[4];
69
70 stack_malloc(&stack);
71 stack_init(stack);
72
73 assert(stack_length(stack) == 0);
74
75 for (int i = 0; i < 4; i++) {
76 card_malloc(&card[i]);
77 card_init(card[i]);
78 card_set(card[i], i, SPADES, EXPOSED, 0, 0);
79 stack_push(&stack, card[i]);
80 assert(stack_length(stack) == i + 1);
81 }
82
83 stack_free(stack);
84 }
85
test_stack_push_on_stack_empty_stack()86 void test_stack_push_on_stack_empty_stack() {
87 struct stack *stack;
88 struct card *card;
89
90 card_malloc(&card);
91 card_init(card);
92 card_set(card, ACE, SPADES, EXPOSED, 0, 0);
93
94 stack_malloc(&stack);
95 stack_init(stack);
96 stack_push(&stack, card);
97
98 assert(cards_equal(stack->card, card));
99 assert(!stack->next);
100
101 stack_free(stack);
102 }
103
test_stack_push_on_non_stack_empty_stack()104 void test_stack_push_on_non_stack_empty_stack() {
105 struct stack *stack;
106 struct card *card_0, *card_1;
107
108 card_malloc(&card_0);
109 card_malloc(&card_1);
110 card_init(card_0);
111 card_init(card_1);
112 card_set(card_0, ACE, SPADES, EXPOSED, 0, 0);
113 card_set(card_1, ACE, HEARTS, EXPOSED, 0, 0);
114
115 stack_malloc(&stack);
116 stack_init(stack);
117 stack_push(&stack, card_0);
118 stack_push(&stack, card_1);
119
120 assert(cards_equal(stack->card, card_1));
121 assert(cards_equal(stack->next->card, card_0));
122 assert(!stack->next->next);
123
124 stack_free(stack);
125 }
126
test_stack_push_null_on_stack_empty_stack()127 void test_stack_push_null_on_stack_empty_stack() {
128 struct stack *stack, *old_stack;
129
130 stack_malloc(&stack);
131 stack_init(stack);
132 old_stack = stack;
133 stack_push(&stack, NULL);
134
135 assert(cards_equal(stack->card, old_stack->card));
136 assert(!stack->next);
137
138 stack_free(stack);
139 }
140
test_stack_push_null_on_non_stack_empty_stack()141 void test_stack_push_null_on_non_stack_empty_stack() {
142 struct stack *stack, *old_stack;
143 struct card *card;
144
145 card_malloc(&card);
146 card_init(card);
147 card_set(card, ACE, SPADES, EXPOSED, 0, 0);
148
149 stack_malloc(&stack);
150 stack_init(stack);
151 old_stack = stack_dup(stack);
152 stack_push(&stack, NULL);
153
154 assert(cards_equal(stack->card, old_stack->card));
155 assert(stacks_equal(stack->next, old_stack->next));
156
157 stack_free(stack);
158 }
159
test_stack_pop_on_stack_empty_stack()160 void test_stack_pop_on_stack_empty_stack() {
161 struct stack *stack;
162 struct card *stack_popped_card;
163
164 stack_malloc(&stack);
165 stack_init(stack);
166 stack_popped_card = stack_pop(&stack);
167
168 assert(stack_empty(stack));
169 assert(!stack_popped_card);
170
171 stack_free(stack);
172 }
173
test_stack_pop_on_stack_with_one_element()174 void test_stack_pop_on_stack_with_one_element() {
175 struct stack *stack;
176 struct card *card, *stack_popped_card;
177
178 card_malloc(&card);
179 card_init(card);
180 card_set(card, ACE, SPADES, EXPOSED, 0, 0);
181
182 stack_malloc(&stack);
183 stack_init(stack);
184 stack_push(&stack, card);
185 stack_popped_card = stack_pop(&stack);
186
187 assert(stack_empty(stack));
188 assert(stack_popped_card == card);
189
190 stack_free(stack);
191 card_free(stack_popped_card);
192 }
193
test_stack_pop_on_stack_with_more_than_one_element()194 void test_stack_pop_on_stack_with_more_than_one_element() {
195 struct stack *stack, *old_stack_next;
196 struct card *card[3], *stack_popped_card;
197
198 stack_malloc(&stack);
199 stack_init(stack);
200 for (int i = 0; i < 3; i++) {
201 card_malloc(&card[i]);
202 card_init(card[i]);
203 card_set(card[i], ACE, SPADES, EXPOSED, 0, 0);
204 stack_push(&stack, card[i]);
205 }
206 old_stack_next = stack->next;
207 stack_popped_card = stack_pop(&stack);
208
209 assert(stack_length(stack) == 2);
210 assert(stack == old_stack_next);
211 assert(stack_popped_card == card[2]);
212
213 stack_free(stack);
214 card_free(stack_popped_card);
215 }
216
test_stack_reverse_on_stack_empty_stack()217 void test_stack_reverse_on_stack_empty_stack() {
218 struct stack *stack, *old_stack, *stack_reversed_stack;
219
220 stack_malloc(&stack);
221 stack_init(stack);
222 old_stack = stack;
223 stack_reversed_stack = stack_reverse(stack);
224
225 assert(stacks_equal(stack_reversed_stack, old_stack));
226
227 stack_free(stack);
228 stack_free(stack_reversed_stack);
229 }
230
test_stack_reverse_on_stack_with_one_element()231 void test_stack_reverse_on_stack_with_one_element() {
232 struct stack *stack, *old_stack, *stack_reversed_stack;
233 struct card *card;
234
235 card_malloc(&card);
236 card_init(card);
237 card_set(card, ACE, SPADES, EXPOSED, 0, 0);
238
239 stack_malloc(&stack);
240 stack_init(stack);
241 stack_push(&stack, card);
242 old_stack = stack;
243 stack_reversed_stack = stack_reverse(stack);
244
245 assert(stacks_equal(stack_reversed_stack, old_stack));
246
247 stack_free(stack_reversed_stack);
248 stack_free(stack);
249 }
250
test_stack_reverse_on_stack_with_more_than_one_element()251 void test_stack_reverse_on_stack_with_more_than_one_element() {
252 struct stack *stack, *old_stack, *stack_reversed_stack, *unstack_reversed_stack;
253 struct card *card[3];
254
255 stack_malloc(&stack);
256 stack_init(stack);
257 for (int i = 0; i < 3; i++) {
258 card_malloc(&card[i]);
259 card_init(card[i]);
260 card_set(card[i], TWO + i, DIAMONDS + i, EXPOSED, 0, 0);
261 stack_push(&stack, card[i]);
262 }
263 old_stack = stack_dup(stack);
264 stack_reversed_stack = stack_reverse(stack);
265
266 stack_malloc(&unstack_reversed_stack);
267 stack_init(unstack_reversed_stack);
268 for (int i = 0; i < 3; i++) {
269 stack_push(&unstack_reversed_stack, stack_pop(&stack_reversed_stack));
270 }
271
272 assert(stacks_equal(unstack_reversed_stack, old_stack));
273
274 stack_free(unstack_reversed_stack);
275 stack_free(stack_reversed_stack);
276 stack_free(old_stack);
277 stack_free(stack);
278 }
279
test_stack_reverse_should_not_change_stack()280 void test_stack_reverse_should_not_change_stack() {
281 struct stack *stack, *stack_reversed_stack_0, *stack_reversed_stack_1;
282 struct card *card[3];
283
284 stack_malloc(&stack);
285 stack_init(stack);
286 for (int i = 0; i < 3; i++) {
287 card_malloc(&card[i]);
288 card_init(card[i]);
289 card_set(card[i], TWO + i, DIAMONDS + i, EXPOSED, 0, 0);
290 stack_push(&stack, card[i]);
291 }
292 stack_reversed_stack_0 = stack_reverse(stack);
293 stack_reversed_stack_1 = stack_reverse(stack_reversed_stack_0);
294
295 assert(!stacks_equal(stack, stack_reversed_stack_0));
296 assert(stacks_equal(stack, stack_reversed_stack_1));
297
298 stack_free(stack_reversed_stack_0);
299 stack_free(stack_reversed_stack_1);
300 stack_free(stack);
301 }
302
test_stack()303 void test_stack() {
304 test_stack_init();
305
306 test_stack_dup();
307
308 test_stack_empty_on_stack_empty_stack();
309 test_stack_empty_on_non_stack_empty_stack();
310
311 test_stack_length();
312
313 test_stack_push_on_stack_empty_stack();
314 test_stack_push_on_non_stack_empty_stack();
315 test_stack_push_null_on_stack_empty_stack();
316
317 test_stack_pop_on_stack_empty_stack();
318 test_stack_pop_on_stack_with_one_element();
319 test_stack_pop_on_stack_with_more_than_one_element();
320
321 test_stack_reverse_on_stack_empty_stack();
322 test_stack_reverse_on_stack_with_one_element();
323 test_stack_reverse_on_stack_with_more_than_one_element();
324 test_stack_reverse_should_not_change_stack();
325 }
326