1 /* 2 * Copyright (C) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include <cstdint> 18 #include <cstdbool> 19 #include "hash_table.h" 20 21 using namespace testing::ext; 22 namespace OHOS { 23 namespace Wifi { 24 class HashTableTest : public testing::Test { 25 public: SetUpTestCase()26 static void SetUpTestCase() 27 {} TearDownTestCase()28 static void TearDownTestCase() 29 {} SetUp()30 virtual void SetUp() 31 { 32 if (CreateHashTable(&table, sizeof(uint32_t), sizeof(uint32_t), HASH_MINI_CAPACITY) != HASH_SUCCESS) { 33 printf("failed to create hash table.\n"); 34 } 35 } TearDown()36 virtual void TearDown() 37 { 38 if (Initialized(&table)) { 39 DestroyHashTable(&table); 40 } 41 } 42 public: 43 HashTable table; 44 }; 45 46 HWTEST_F(HashTableTest, InitializedTest, TestSize.Level1) 47 { 48 HashTable testTable = {0}; 49 EXPECT_EQ(0, Initialized(&testTable)); 50 EXPECT_EQ(0, Initialized(0)); 51 EXPECT_EQ(1, Initialized(&table)); 52 } 53 54 HWTEST_F(HashTableTest, InsertTest, TestSize.Level1) 55 { 56 uint32_t keyOffset = 100; 57 uint32_t valOffset = 1000; 58 size_t expectSize = 100; 59 60 EXPECT_TRUE(Initialized(&table)); 61 int testRet = 1; 62 for (size_t i = 0; i < expectSize; i++) 63 { 64 uint32_t key = keyOffset + i; 65 uint32_t val = valOffset; 66 if (Insert(&table, (uintptr_t)&key, (uintptr_t)&val) != HASH_INSERTED) { 67 printf("failed to test insert.\n"); 68 testRet = 0; 69 } 70 } 71 uint32_t updateKey = keyOffset; 72 uint32_t updateVal = 1000; 73 EXPECT_TRUE(Insert(&table, (uintptr_t)&updateKey, (uintptr_t)&updateVal) == HASH_UPDATED); 74 EXPECT_TRUE(testRet); 75 EXPECT_TRUE(expectSize == table.size); 76 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 77 EXPECT_TRUE(table.size == 0); 78 } 79 80 HWTEST_F(HashTableTest, ContainsKeyTest, TestSize.Level1) 81 { 82 uint32_t key1 = 1001; 83 uint32_t val1 = 2001; 84 uint32_t key2 = 1002; 85 uint32_t val2 = 2002; 86 uint32_t key3 = 1003; 87 uint32_t val3 = 2003; 88 89 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1)); 90 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key2, (uintptr_t)&val2)); 91 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key3, (uintptr_t)&val3)); 92 EXPECT_EQ(HASH_UPDATED, Insert(&table, (uintptr_t)&key3, (uintptr_t)&val3)); 93 uint32_t testKey = 1002; 94 uint32_t testKey2 = 6002; 95 EXPECT_EQ(1, ContainsKey(&table, (uintptr_t)&testKey)); 96 EXPECT_EQ(0, ContainsKey(&table, (uintptr_t)&testKey2)); 97 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 98 EXPECT_TRUE(table.size == 0); 99 } 100 101 HWTEST_F(HashTableTest, GetAtTest, TestSize.Level1) 102 { 103 uint32_t key1 = 1001; 104 uint32_t val1 = 2001; 105 uint32_t key2 = 1002; 106 uint32_t val2 = 2002; 107 uint32_t key3 = 1003; 108 uint32_t val3 = 2003; 109 110 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1)); 111 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key2, (uintptr_t)&val2)); 112 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key3, (uintptr_t)&val3)); 113 114 uint32_t testKey = 1002; 115 uint32_t expectVal = val2; 116 uintptr_t valPtr = At(&table, (uintptr_t)&testKey); 117 uint32_t rstVal = 0; 118 if (valPtr) { 119 rstVal = *reinterpret_cast<uint32_t*>(valPtr); 120 } 121 EXPECT_EQ(expectVal, rstVal); 122 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 123 EXPECT_TRUE(table.size == 0); 124 } 125 126 HWTEST_F(HashTableTest, RemoveTest, TestSize.Level1) 127 { 128 uint32_t key1 = 1001; 129 uint32_t val1 = 2001; 130 uint32_t key2 = 1002; 131 uint32_t val2 = 2002; 132 uint32_t key3 = 1003; 133 uint32_t val3 = 2003; 134 uint32_t key4 = 0; 135 136 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1)); 137 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key2, (uintptr_t)&val2)); 138 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key3, (uintptr_t)&val3)); 139 EXPECT_EQ(HASH_ERROR, Insert(0, (uintptr_t)&key3, (uintptr_t)&val3)); 140 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key4, (uintptr_t)&val3)); 141 142 143 uint32_t testKey = 1002; 144 EXPECT_EQ(1, ContainsKey(&table, (uintptr_t)&testKey)); 145 EXPECT_EQ(HASH_SUCCESS, Remove(&table, (uintptr_t)&testKey)); 146 EXPECT_EQ(0, ContainsKey(&table, (uintptr_t)&testKey)); 147 EXPECT_EQ(0, ContainsKey(&table, 0)); 148 EXPECT_EQ(0, ContainsKey(0, (uintptr_t)&testKey)); 149 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 150 EXPECT_TRUE(table.size == 0); 151 } 152 153 HWTEST_F(HashTableTest, EmptyTest, TestSize.Level1) 154 { 155 EXPECT_EQ(HASH_ERROR, Empty(0)); 156 EXPECT_EQ(HASH_SUCCESS, Empty(&table)); 157 uint32_t key1 = 1001; 158 uint32_t val1 = 2001; 159 EXPECT_TRUE(Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1) == HASH_INSERTED); 160 EXPECT_EQ(HASH_NOT_EMPTY, Empty(&table)); 161 } 162 163 HWTEST_F(HashTableTest, ResizeTest, TestSize.Level1) 164 { 165 HashTable testTable; 166 EXPECT_EQ(HASH_ERROR, CreateHashTable(0, sizeof(uint32_t), 167 sizeof(uint32_t), HASH_MINI_CAPACITY)); 168 EXPECT_EQ(HASH_SUCCESS, CreateHashTable(&testTable, sizeof(uint32_t), 169 sizeof(uint32_t), HASH_MINI_CAPACITY)); 170 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 171 EXPECT_EQ(HASH_SUCCESS, Resize(&testTable, HASH_MINI_CAPACITY * 2)); 172 testTable.capacity = HASH_MINI_CAPACITY * 2; 173 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY * 2); 174 EXPECT_EQ(HASH_SUCCESS, Resize(&testTable, HASH_MINI_CAPACITY / 2)); 175 EXPECT_EQ(HASH_SUCCESS, DestroyHashTable(&testTable)); 176 } 177 178 extern "C" int CapExtend(HashTable *table, size_t miniCapacity); 179 HWTEST_F(HashTableTest, CapExtendTest, TestSize.Level1) 180 { 181 HashTable testTable; 182 EXPECT_EQ(HASH_SUCCESS, CreateHashTable(&testTable, sizeof(uint32_t), 183 sizeof(uint32_t), HASH_MINI_CAPACITY)); 184 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 185 EXPECT_EQ(HASH_SUCCESS, CapExtend(&testTable, HASH_MINI_CAPACITY * 5)); 186 EXPECT_EQ(HASH_ERROR, CapExtend(0, HASH_MINI_CAPACITY)); 187 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 188 EXPECT_EQ(HASH_SUCCESS, DestroyHashTable(&testTable)); 189 EXPECT_EQ(HASH_ERROR, ClearAll(0)); 190 } 191 /** 192 * @tc.name: AtTest 193 * @tc.desc: At() 194 * @tc.type: FUNC 195 * @tc.require: issue 196 */ 197 HWTEST_F(HashTableTest, AtTest, TestSize.Level1) 198 { 199 uint32_t testKey = 1002; 200 uint32_t expectVal = 0; 201 uintptr_t valPtr; 202 valPtr = At(0, (uintptr_t)&testKey); 203 uint32_t rstVal = 0; 204 if (valPtr) { 205 rstVal = *reinterpret_cast<uint32_t*>(valPtr); 206 } 207 EXPECT_EQ(expectVal, rstVal); 208 209 valPtr = At(&table, (uintptr_t)&expectVal); 210 if (valPtr) { 211 rstVal = *reinterpret_cast<uint32_t*>(valPtr); 212 } 213 EXPECT_EQ(expectVal, rstVal); 214 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 215 EXPECT_TRUE(table.size == 0); 216 } 217 } 218 } 219