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 #include "oic_malloc.h"
  26
  27 class UQueueF : public testing::Test {
  28 public:
  29     UQueueF() :
  30       testing::Test(),
  31       queue(NULL)
  32   {
  33   }
  34
  35 protected:
  36     virtual void SetUp()
  37     {
  38         queue = u_queue_create();
  39         ASSERT_TRUE(queue != NULL);
  40     }
  41
  42     virtual void TearDown()
  43     {
  44         EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  45     }
  46
  47     u_queue_t *queue;
  48 };
  49
  50 u_queue_message_t *CreateQueueMessage(void *data, uint32_t size)
  51 {
  52     u_queue_message_t *message = (u_queue_message_t *) OICMalloc(sizeof(u_queue_message_t));
  53     if (NULL == message)
  54     {
  55         return NULL;
  56     }
  57
  58     message->msg = data;
  59     message->size = size;
  60
  61     return message;
  62 }
  63
  64 TEST(UQueue, Base)
  65 {
  66     u_queue_t *queue = u_queue_create();
  67     ASSERT_TRUE(queue != NULL);
  68
  69     EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  70 }
  71
  72 TEST(UQueue, CreateMany)
  73 {
  74     for (int i = 0; i < 100; ++i)
  75     {
  76         u_queue_t *queue = u_queue_create();
  77         ASSERT_TRUE(queue != NULL);
  78
  79         EXPECT_EQ(CA_STATUS_OK, u_queue_delete(queue));
  80     }
  81 }
  82
  83 TEST(UQueue, FreeNull)
  84 {
  85     EXPECT_EQ(CA_STATUS_FAILED, u_queue_delete(NULL));
  86 }
  87
  88 TEST_F(UQueueF, Length)
  89 {
  90     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
  91
  92     int dummy = 0;
  93     u_queue_message_t *message = CreateQueueMessage(&dummy, sizeof(dummy));
  94     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
  95
  96     ASSERT_EQ(static_cast<uint32_t>(1), u_queue_get_size(queue));
  97
  98     // Add a few times without checking, just in case checking has side-effects
  99     dummy++;
 100     message = CreateQueueMessage(&dummy, sizeof(dummy));
 101     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 102
 103     dummy++;
 104     message = CreateQueueMessage(&dummy, sizeof(dummy));
 105     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 106
 107     dummy++;
 108     message = CreateQueueMessage(&dummy, sizeof(dummy));
 109     EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 110
 111     ASSERT_EQ(static_cast<uint32_t>(4), u_queue_get_size(queue));
 112 }
 113
 114 TEST_F(UQueueF, LengthMulti)
 115 {
 116     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 117
 118     for (int i = 0; i < 1000; ++i)
 119     {
 120         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 121         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 122     }
 123
 124     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 125 }
 126
 127 TEST_F(UQueueF, GetHead)
 128 {
 129     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 130
 131     for (size_t i = 0; i < 1000; ++i)
 132     {
 133         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 134         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 135     }
 136     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 137
 138     for (size_t i = 0; i < 1000; ++i)
 139     {
 140         u_queue_message_t *value = u_queue_get_head(queue);
 141         ASSERT_TRUE(value != NULL);
 142     }
 143 }
 144
 145 TEST_F(UQueueF, Get)
 146 {
 147     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 148
 149     for (size_t i = 0; i < 1000; ++i)
 150     {
 151         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 152         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 153     }
 154     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 155
 156     for (size_t i = 0; i < 1000; ++i)
 157     {
 158         u_queue_message_t *value = u_queue_get_element(queue);
 159         ASSERT_TRUE(value != NULL);
 160     }
 161 }
 162
 163 TEST_F(UQueueF, Remove)
 164 {
 165     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 166
 167     for (size_t i = 0; i < 1000; ++i)
 168     {
 169         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 170         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 171     }
 172     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 173
 174     for (size_t i = 0; i < 1000; ++i)
 175     {
 176         EXPECT_EQ(CA_STATUS_OK, u_queue_remove_element(queue));
 177     }
 178 }
 179
 180 TEST_F(UQueueF, Reset)
 181 {
 182     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 183
 184     for (size_t i = 0; i < 1000; ++i)
 185     {
 186         u_queue_message_t *message = CreateQueueMessage(&i, sizeof(i));
 187         EXPECT_EQ(CA_STATUS_OK, u_queue_add_element(queue, message));
 188     }
 189     ASSERT_EQ(static_cast<uint32_t>(1000), u_queue_get_size(queue));
 190
 191     EXPECT_EQ(CA_STATUS_OK, u_queue_reset(queue));
 192
 193     ASSERT_EQ(static_cast<uint32_t>(0), u_queue_get_size(queue));
 194 }