8ad4d95781343df3f16655bef7db956caebd522f
[blender.git] / tests / gtests / blenlib / BLI_stack_test.cc
1 /* Apache License, Version 2.0 */
2
3 #include "testing/testing.h"
4 #include <string.h>
5
6 extern "C" {
7 #include "BLI_stack.h"
8 #include "BLI_utildefines.h"
9 #include "BLI_array.h"
10 };
11
12 #define SIZE 1024
13
14 TEST(stack, Empty)
15 {
16         BLI_Stack *stack;
17
18         stack = BLI_stack_new(sizeof(int), __func__);
19         EXPECT_EQ(BLI_stack_is_empty(stack), true);
20         BLI_stack_free(stack);
21 }
22
23 TEST(stack, One)
24 {
25         BLI_Stack *stack;
26         unsigned int in = -1, out = 1;
27
28         stack = BLI_stack_new(sizeof(in), __func__);
29
30         BLI_stack_push(stack, (void *)&in);
31         EXPECT_EQ(BLI_stack_is_empty(stack), false);
32         BLI_stack_pop(stack, (void *)&out);
33         EXPECT_EQ(in, out);
34         EXPECT_EQ(BLI_stack_is_empty(stack), true);
35         BLI_stack_free(stack);
36 }
37
38 TEST(stack, Range)
39 {
40         const int tot = SIZE;
41         BLI_Stack *stack;
42         int in, out;
43
44         stack = BLI_stack_new(sizeof(in), __func__);
45
46         for (in = 0; in < tot; in++) {
47                 BLI_stack_push(stack, (void *)&in);
48         }
49
50         for (in = tot - 1; in >= 0; in--) {
51                 EXPECT_EQ(BLI_stack_is_empty(stack), false);
52                 BLI_stack_pop(stack, (void *)&out);
53                 EXPECT_EQ(in, out);
54
55         }
56         EXPECT_EQ(BLI_stack_is_empty(stack), true);
57
58         BLI_stack_free(stack);
59 }
60
61 TEST(stack, String)
62 {
63         const int tot = SIZE;
64         int i;
65
66         BLI_Stack *stack;
67         char in[] = "hello world!";
68         char out[sizeof(in)];
69
70         stack = BLI_stack_new(sizeof(in), __func__);
71
72         for (i = 0; i < tot; i++) {
73                 *((int *)in) = i;
74                 BLI_stack_push(stack, (void *)in);
75         }
76
77         for (i = tot - 1; i >= 0; i--) {
78                 EXPECT_EQ(BLI_stack_is_empty(stack), false);
79                 *((int *)in) = i;
80                 BLI_stack_pop(stack, (void *)&out);
81                 EXPECT_STREQ(in, out);
82
83         }
84         EXPECT_EQ(BLI_stack_is_empty(stack), true);
85
86         BLI_stack_free(stack);
87 }
88
89 TEST(stack, Reuse)
90 {
91         const int sizes[] = {3, 11, 81, 400, 999, 12, 1, 9721, 7, 99, 5, 0};
92         int sizes_test[ARRAY_SIZE(sizes)];
93         const int *s;
94         int in, out, i;
95         int sum, sum_test;
96
97         BLI_Stack *stack;
98
99         stack = BLI_stack_new(sizeof(in), __func__);
100
101         /* add a bunch of numbers, ensure we get same sum out */
102         sum = 0;
103         for (s = sizes; *s; s++) {
104                 for (i = *s; i != 0; i--) {
105                         BLI_stack_push(stack, (void *)&i);
106                         sum += i;
107                 }
108         }
109         sum_test = 0;
110         while (!BLI_stack_is_empty(stack)) {
111                 BLI_stack_pop(stack, (void *)&out);
112                 sum_test += out;
113         }
114         EXPECT_EQ(sum, sum_test);
115
116         /* add and remove all except last */
117         for (s = sizes; *s; s++) {
118                 for (i = *s; i >= 0; i--) {
119                         BLI_stack_push(stack, (void *)&i);
120                 }
121                 for (i = *s; i > 0; i--) {
122                         BLI_stack_pop(stack, (void *)&out);
123                 }
124         }
125
126         i = ARRAY_SIZE(sizes) - 1;
127         while (!BLI_stack_is_empty(stack)) {
128                 i--;
129                 BLI_stack_pop(stack, (void *)&sizes_test[i]);
130                 EXPECT_EQ(sizes[i], sizes_test[i]);
131                 EXPECT_GT(i, -1);
132         }
133         EXPECT_EQ(i, 0);
134         EXPECT_EQ(memcmp(sizes, sizes_test, sizeof(sizes) - sizeof(int)), 0);
135
136         BLI_stack_free(stack);
137 }