resource/csdk/connectivity/test/uqueue_test.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "gtest/gtest.h"
  22
  23 #include "uqueue.h"
  24
  25 class UQueueF : public testing::Test {
  26 public:
  27     UQueueF() :
  28       testing::Test(),
  29       queue(NULL)
  30   {
  31   }
  32
  33 protected:
  34     virtual void SetUp()
  35     {
  36         queue = u_queue_create();
  37         ASSERT_TRUE(queue != NULL);
  38     }
  39
  40     virtual void TearDown()
  41     {
  42         EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  43     }
  44
  45     u_queue_t *queue;
  46 };
  47
  48 u_queue_message_t *CreateQueueMessage(void *data, uint32_t size)
  49 {
  50     u_queue_message_t *message = (u_queue_message_t *) malloc(sizeof(u_queue_message_t));
  51     if (NULL == message)
  52     {
  53         return NULL;
  54     }
  55
  56     message->msg = data;
  57     message->size = size;
  58
  59     return message;
  60 }
  61
  62 TEST(UQueue, Base)
  63 {
  64     u_queue_t *queue = u_queue_create();
  65     ASSERT_TRUE(queue != NULL);
  66
  67     EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  68 }
  69
  70 TEST(UQueue, CreateMany)
  71 {
  72     for (int i = 0; i < 100; ++i)
  73     {
  74         u_queue_t *queue = u_queue_create();
  75         ASSERT_TRUE(queue != NULL);
  76
  77         EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  78     }
  79 }
  80
  81 TEST(UQueue, FreeNull)
  82 {
  83     EXPECT_EQ(CA_STATUS_FAILED, u_queue_delete(NULL));
  84 }
  85
  86 TEST_F(UQueueF, Length)
  87 {
  88     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
  89
  90     int dummy = 0;
  91     u_queue_message_t *message = CreateQueueMessage(&dummy, sizeof(dummy));
  92     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
  93
  94     ASSERT_EQ(static_cast<uint32_t>(1), u_queue_get_size(queue));
  95
  96     // Add a few times without checking, just in case checking has side-effects
  97     dummy++;
  98     message = CreateQueueMessage(&dummy, sizeof(dummy));
  99     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 100
 101     dummy++;
 102     message = CreateQueueMessage(&dummy, sizeof(dummy));
 103     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 104
 105     dummy++;
 106     message = CreateQueueMessage(&dummy, sizeof(dummy));
 107     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 108
 109     ASSERT_EQ(static_cast<uint32_t>(4), u_queue_get_size(queue));
 110 }
 111
 112 TEST_F(UQueueF, LengthMulti)
 113 {
 114     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 115
 116     for (int i = 0; i < 1000; ++i)
 117     {
 118         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 119         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 120     }
 121
 122     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 123 }
 124
 125 TEST_F(UQueueF, GetHead)
 126 {
 127     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 128
 129     for (size_t i = 0; i < 1000; ++i)
 130     {
 131         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 132         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 133     }
 134     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 135
 136     for (size_t i = 0; i < 1000; ++i)
 137     {
 138         u_queue_message_t *value = u_queue_get_head(queue);
 139         ASSERT_TRUE(value != NULL);
 140     }
 141 }
 142
 143 TEST_F(UQueueF, Get)
 144 {
 145     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 146
 147     for (size_t i = 0; i < 1000; ++i)
 148     {
 149         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 150         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 151     }
 152     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 153
 154     for (size_t i = 0; i < 1000; ++i)
 155     {
 156         u_queue_message_t *value = u_queue_get_element(queue);
 157         ASSERT_TRUE(value != NULL);
 158     }
 159 }
 160
 161 TEST_F(UQueueF, Remove)
 162 {
 163     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 164
 165     for (size_t i = 0; i < 1000; ++i)
 166     {
 167         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 168         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 169     }
 170     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 171
 172     for (size_t i = 0; i < 1000; ++i)
 173     {
 174         EXPECT_EQ(CA_STATUS_OK, u_queue_remove_element(queue));
 175     }
 176 }
 177
 178 TEST_F(UQueueF, Reset)
 179 {
 180     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 181
 182     for (size_t i = 0; i < 1000; ++i)
 183     {
 184         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 185         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 186     }
 187     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 188
 189     EXPECT_EQ(CA_STATUS_OK, u_queue_reset(queue));
 190
 191     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 192 }