src/test/unit/circular_queue_unittest.cc

   1 #include "unittest_macros.h"
   2 #include "gtest/gtest.h"
   3 #include <stdint.h>
   4
   5 #include <stdlib.h>
   6 #include <time.h>
   7
   8 extern "C" {
   9     #include "common/circular_queue.h"
  10 }
  11 #include <queue>
  12 #include <climits>
  13
  14
  15 TEST(CircularQueue, ElementsAreCorrect){
  16     srand (time(NULL));
  17
  18     circularBuffer_t buffer;
  19
  20     const size_t bufferSize = 16;
  21     uint8_t buff[bufferSize];
  22
  23     circularBufferInit(&buffer, buff, bufferSize, sizeof(char));
  24
  25     const uint8_t testBurst = 3;
  26
  27     const uint8_t dataToInsertSize[testBurst] = {5, 10, 3};
  28     const uint8_t dataToRemoveSize[testBurst] = {3, 7, 2};
  29
  30     std::queue <uint8_t>queue;
  31
  32     for(uint8_t j=0; j<testBurst; j++){
  33
  34         for(uint8_t i = 0;i < dataToInsertSize[j]; i++)
  35         {
  36             uint8_t value = rand() % 255;
  37             queue.push(value);
  38             circularBufferPushElement(&buffer, &value);
  39         }
  40         for(uint8_t i = 0;i < dataToRemoveSize[j]; i++)
  41         {
  42             uint8_t value;
  43             circularBufferPopHead(&buffer, &value);
  44             EXPECT_EQ(queue.front(),value);
  45             queue.pop();
  46         }
  47         EXPECT_EQ(circularBufferCountElements(&buffer),queue.size());
  48     }
  49
  50     EXPECT_EQ(circularBufferIsEmpty(&buffer),queue.empty());
  51
  52 }
  53
  54 TEST(CircularQueue, CheckIsEmptyAndIsFull16){ //check with uint16_t
  55     srand (time(NULL));
  56
  57     circularBuffer_t buffer;
  58
  59     typedef uint16_t tested_type;
  60
  61     const size_t bufferSize = 16 * sizeof(tested_type);
  62     uint8_t buff[bufferSize];
  63
  64     circularBufferInit(&buffer, buff, bufferSize, sizeof(tested_type));
  65
  66     const int testBurst = 3;
  67
  68     const int dataToInsertSize[testBurst] = {10, 8, 4};
  69     const int dataToRemoveSize[testBurst] = {3, 3, 0};
  70     //At the end we have 0 elements
  71
  72     std::queue <tested_type>queue;
  73
  74     EXPECT_EQ(circularBufferIsEmpty(&buffer),true);
  75     EXPECT_EQ(circularBufferIsFull(&buffer),false);
  76
  77     for(uint8_t j=0; j<testBurst; j++){
  78
  79         for(uint8_t i = 0;i < dataToInsertSize[j]; i++)
  80         {
  81             tested_type value = rand() % SHRT_MAX;
  82             queue.push(value);
  83             circularBufferPushElement(&buffer, (uint8_t*)&value);
  84         }
  85         for(uint8_t i = 0;i < dataToRemoveSize[j]; i++)
  86         {
  87             tested_type value;
  88             circularBufferPopHead(&buffer, (uint8_t*)&value);
  89             EXPECT_EQ(queue.front(),value);
  90             queue.pop();
  91         }
  92         EXPECT_EQ(circularBufferCountElements(&buffer),queue.size());
  93     }
  94
  95     EXPECT_EQ(circularBufferIsFull(&buffer),true);
  96
  97     //Remove all elements
  98     while(!circularBufferIsEmpty(&buffer))
  99     {
 100         tested_type value;
 101         circularBufferPopHead(&buffer, (uint8_t*)&value);
 102         EXPECT_EQ(queue.front(),value);
 103         queue.pop();
 104     }
 105
 106     EXPECT_EQ(circularBufferIsFull(&buffer),false);
 107     EXPECT_EQ(circularBufferIsEmpty(&buffer),true);
 108     EXPECT_EQ(circularBufferIsEmpty(&buffer),queue.empty());
 109 }
 110
 111 TEST(CircularQueue, CheckIsEmptyAndIsFull32){  //check with uint32_t
 112     srand (time(NULL));
 113
 114     circularBuffer_t buffer;
 115
 116     typedef uint32_t tested_type;
 117
 118     const size_t bufferSize =  16 * sizeof(tested_type);
 119     uint8_t buff[bufferSize];
 120
 121     circularBufferInit(&buffer, buff, bufferSize, sizeof(tested_type));
 122
 123     const int testBurst = 3;
 124
 125     const int dataToInsertSize[testBurst] = {10, 8, 4};
 126     const int dataToRemoveSize[testBurst] = {3, 3, 0};
 127     //At the end we have 0 elements
 128
 129     std::queue <tested_type>queue;
 130
 131     EXPECT_EQ(circularBufferIsEmpty(&buffer),true);
 132     EXPECT_EQ(circularBufferIsFull(&buffer),false);
 133
 134     for(uint8_t j=0; j<testBurst; j++){
 135
 136         for(uint8_t i = 0;i < dataToInsertSize[j]; i++)
 137         {
 138             tested_type value = rand() % INT_MAX;
 139             queue.push(value);
 140             circularBufferPushElement(&buffer, (uint8_t*)&value);
 141         }
 142         for(uint8_t i = 0;i < dataToRemoveSize[j]; i++)
 143         {
 144             tested_type value;
 145             circularBufferPopHead(&buffer, (uint8_t*)&value);
 146             EXPECT_EQ(queue.front(),value);
 147             queue.pop();
 148         }
 149     EXPECT_EQ(circularBufferCountElements(&buffer),queue.size());
 150     }
 151
 152     EXPECT_EQ(circularBufferIsFull(&buffer),true);
 153
 154     //Remove all elements
 155     while(!circularBufferIsEmpty(&buffer))
 156     {
 157         tested_type value;
 158         circularBufferPopHead(&buffer, (uint8_t*)&value);
 159         EXPECT_EQ(queue.front(),value);
 160         queue.pop();
 161     }
 162
 163     EXPECT_EQ(circularBufferIsFull(&buffer),false);
 164     EXPECT_EQ(circularBufferIsEmpty(&buffer),true);
 165     EXPECT_EQ(circularBufferIsEmpty(&buffer),queue.empty());
 166 }