resource/csdk/connectivity/test/ulinklist_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 "ulinklist.h"
  24
  25 class ULinkListF : public testing::Test
  26 {
  27 public:
  28     ULinkListF() :
  29       testing::Test(),
  30       list(NULL)
  31   {
  32   }
  33
  34 protected:
  35     virtual void SetUp()
  36     {
  37         list = u_linklist_create();
  38         ASSERT_TRUE(list != NULL);
  39     }
  40
  41     virtual void TearDown()
  42     {
  43         u_linklist_free(&list);
  44         ASSERT_EQ(NULL, list);
  45     }
  46
  47     u_linklist_t *list;
  48 };
  49
  50 TEST(ULinkList, Base)
  51 {
  52     u_linklist_t *list = u_linklist_create();
  53     ASSERT_TRUE(list != NULL);
  54
  55     u_linklist_free(&list);
  56     ASSERT_EQ(NULL, list);
  57 }
  58
  59 TEST(ULinkList, CreateMany)
  60 {
  61     for (int i = 0; i < 100; ++i)
  62     {
  63         u_linklist_t *list = u_linklist_create();
  64         ASSERT_TRUE(list != NULL);
  65
  66         u_linklist_free(&list);
  67         ASSERT_EQ(NULL, list);
  68     }
  69 }
  70
  71 TEST(ULinkList, FreeNull)
  72 {
  73     u_linklist_free(NULL);
  74 }
  75
  76 TEST_F(ULinkListF, AddHead)
  77 {
  78     ASSERT_EQ(static_cast<uint32_t>(0), u_linklist_length(list));
  79
  80     int dummy = 0;
  81     EXPECT_EQ(CA_STATUS_OK, u_linklist_add_head(list, &dummy));
  82
  83     ASSERT_EQ(static_cast<uint32_t>(1), u_linklist_length(list));
  84
  85     // Add a few times without checking, just in case checking has side-effects
  86     dummy++;
  87     EXPECT_EQ(CA_STATUS_OK, u_linklist_add_head(list, &dummy));
  88     dummy++;
  89     EXPECT_EQ(CA_STATUS_OK, u_linklist_add_head(list, &dummy));
  90     dummy++;
  91     EXPECT_EQ(CA_STATUS_OK, u_linklist_add_head(list, &dummy));
  92
  93     ASSERT_EQ(static_cast<uint32_t>(4), u_linklist_length(list));
  94 }
  95
  96 TEST_F(ULinkListF, Length)
  97 {
  98     ASSERT_EQ(static_cast<uint32_t>(0), u_linklist_length(list));
  99
 100     int dummy = 0;
 101     EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy));
 102
 103     ASSERT_EQ(static_cast<uint32_t>(1), u_linklist_length(list));
 104
 105     // Add a few times without checking, just in case checking has side-effects
 106     dummy++;
 107     EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy));
 108     dummy++;
 109     EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy));
 110     dummy++;
 111     EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy));
 112
 113     ASSERT_EQ(static_cast<uint32_t>(4), u_linklist_length(list));
 114 }
 115
 116 TEST_F(ULinkListF, LengthMulti)
 117 {
 118     ASSERT_EQ(static_cast<uint32_t>(0), u_linklist_length(list));
 119
 120     int dummy[1000] = {0};
 121     size_t cap = sizeof(dummy) / sizeof(dummy[0]);
 122
 123     for (size_t i = 0; i < cap; ++i)
 124     {
 125         dummy[i] = i;
 126         EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy[i]));
 127     }
 128
 129     ASSERT_EQ(static_cast<uint32_t>(1000), u_linklist_length(list));
 130 }
 131
 132 TEST_F(ULinkListF, Get)
 133 {
 134     ASSERT_EQ(static_cast<uint32_t>(0), u_linklist_length(list));
 135
 136     int dummy[1000] = {0};
 137     size_t cap = sizeof(dummy) / sizeof(dummy[0]);
 138
 139     for (size_t i = 0; i < cap; ++i)
 140     {
 141         dummy[i] = i;
 142         EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy[i]));
 143     }
 144     ASSERT_EQ(static_cast<uint32_t>(1000), u_linklist_length(list));
 145
 146     u_linklist_iterator_t *iterTable = NULL;
 147     u_linklist_init_iterator(list, &iterTable);
 148
 149     while (NULL != iterTable)
 150     {
 151         void *value = u_linklist_get_data(iterTable);
 152         ASSERT_TRUE(value != NULL);
 153         u_linklist_get_next(&iterTable);
 154     }
 155 }
 156
 157 TEST_F(ULinkListF, Remove)
 158 {
 159     ASSERT_EQ(static_cast<uint32_t>(0), u_linklist_length(list));
 160
 161     int dummy[1000] = {0};
 162     size_t cap = sizeof(dummy) / sizeof(dummy[0]);
 163
 164     for (size_t i = 0; i < cap; ++i)
 165     {
 166         dummy[i] = i;
 167         EXPECT_EQ(CA_STATUS_OK, u_linklist_add(list, &dummy[i]));
 168     }
 169     ASSERT_EQ(static_cast<uint32_t>(1000), u_linklist_length(list));
 170
 171     u_linklist_iterator_t *iterTable = NULL;
 172     u_linklist_init_iterator(list, &iterTable);
 173
 174     while (NULL != iterTable)
 175     {
 176         EXPECT_EQ(CA_STATUS_OK, u_linklist_remove(list, &iterTable));
 177         u_linklist_get_next(&iterTable);
 178     }
 179 }