BLI_stack: various small additions
[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         EXPECT_EQ(BLI_stack_count(stack), 0);
21         BLI_stack_free(stack);
22 }
23
24 TEST(stack, One)
25 {
26         BLI_Stack *stack;
27         unsigned int in = -1, out = 1;
28
29         stack = BLI_stack_new(sizeof(in), __func__);
30
31         BLI_stack_push(stack, (void *)&in);
32         EXPECT_EQ(BLI_stack_is_empty(stack), false);
33         EXPECT_EQ(BLI_stack_count(stack), 1);
34         BLI_stack_pop(stack, (void *)&out);
35         EXPECT_EQ(in, out);
36         EXPECT_EQ(BLI_stack_is_empty(stack), true);
37         EXPECT_EQ(BLI_stack_count(stack), 0);
38         BLI_stack_free(stack);
39 }
40
41 TEST(stack, Range)
42 {
43         const int tot = SIZE;
44         BLI_Stack *stack;
45         int in, out;
46
47         stack = BLI_stack_new(sizeof(in), __func__);
48
49         for (in = 0; in < tot; in++) {
50                 BLI_stack_push(stack, (void *)&in);
51         }
52
53         for (in = tot - 1; in >= 0; in--) {
54                 EXPECT_EQ(BLI_stack_is_empty(stack), false);
55                 BLI_stack_pop(stack, (void *)&out);
56                 EXPECT_EQ(in, out);
57
58         }
59         EXPECT_EQ(BLI_stack_is_empty(stack), true);
60
61         BLI_stack_free(stack);
62 }
63
64 TEST(stack, String)
65 {
66         const int tot = SIZE;
67         int i;
68
69         BLI_Stack *stack;
70         char in[] = "hello world!";
71         char out[sizeof(in)];
72
73         stack = BLI_stack_new(sizeof(in), __func__);
74
75         for (i = 0; i < tot; i++) {
76                 *((int *)in) = i;
77                 BLI_stack_push(stack, (void *)in);
78         }
79
80         for (i = tot - 1; i >= 0; i--) {
81                 EXPECT_EQ(BLI_stack_is_empty(stack), false);
82                 *((int *)in) = i;
83                 BLI_stack_pop(stack, (void *)&out);
84                 EXPECT_STREQ(in, out);
85         }
86         EXPECT_EQ(BLI_stack_is_empty(stack), true);
87
88         BLI_stack_free(stack);
89 }
90
91 TEST(stack, Reuse)
92 {
93         const int sizes[] = {3, 11, 81, 400, 999, 12, 1, 9721, 7, 99, 5, 0};
94         int sizes_test[ARRAY_SIZE(sizes)];
95         const int *s;
96         int in, out, i;
97         int sum, sum_test;
98
99         BLI_Stack *stack;
100
101         stack = BLI_stack_new(sizeof(in), __func__);
102
103         /* add a bunch of numbers, ensure we get same sum out */
104         sum = 0;
105         for (s = sizes; *s; s++) {
106                 for (i = *s; i != 0; i--) {
107                         BLI_stack_push(stack, (void *)&i);
108                         sum += i;
109                 }
110         }
111         sum_test = 0;
112         while (!BLI_stack_is_empty(stack)) {
113                 BLI_stack_pop(stack, (void *)&out);
114                 sum_test += out;
115         }
116         EXPECT_EQ(sum, sum_test);
117
118         /* add and remove all except last */
119         for (s = sizes; *s; s++) {
120                 for (i = *s; i >= 0; i--) {
121                         BLI_stack_push(stack, (void *)&i);
122                 }
123                 for (i = *s; i > 0; i--) {
124                         BLI_stack_pop(stack, (void *)&out);
125                 }
126         }
127
128         i = ARRAY_SIZE(sizes) - 1;
129         while (!BLI_stack_is_empty(stack)) {
130                 i--;
131                 BLI_stack_pop(stack, (void *)&sizes_test[i]);
132                 EXPECT_EQ(sizes[i], sizes_test[i]);
133                 EXPECT_GT(i, -1);
134         }
135         EXPECT_EQ(i, 0);
136         EXPECT_EQ(memcmp(sizes, sizes_test, sizeof(sizes) - sizeof(int)), 0);
137
138
139         /* finally test BLI_stack_pop_n */
140         for (i = ARRAY_SIZE(sizes); i--; ) {
141                 BLI_stack_push(stack, (void *)&sizes[i]);
142         }
143         EXPECT_EQ(BLI_stack_count(stack), ARRAY_SIZE(sizes));
144         BLI_stack_pop_n(stack, (void *)sizes_test, ARRAY_SIZE(sizes));
145         EXPECT_EQ(memcmp(sizes, sizes_test, sizeof(sizes) - sizeof(int)), 0);
146
147         BLI_stack_free(stack);
148 }