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 }