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