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 <stdint.h> 18 #include <stdbool.h> 19 #include "hash_table.h" 20 21 using namespace testing::ext; 22 23 class HashTableTest : public testing::Test { 24 public: SetUpTestCase()25 static void SetUpTestCase() 26 {} TearDownTestCase()27 static void TearDownTestCase() 28 {} SetUp()29 virtual void SetUp() 30 { 31 if (CreateHashTable(&table, sizeof(uint32_t), sizeof(uint32_t), HASH_MINI_CAPACITY) != HASH_SUCCESS) { 32 printf("failed to create hash table.\n"); 33 } 34 } TearDown()35 virtual void TearDown() 36 { 37 if (Initialized(&table)) { 38 DestroyHashTable(&table); 39 } 40 } 41 public: 42 HashTable table; 43 }; 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 = *(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 135 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1)); 136 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key2, (uintptr_t)&val2)); 137 EXPECT_EQ(HASH_INSERTED, Insert(&table, (uintptr_t)&key3, (uintptr_t)&val3)); 138 139 uint32_t testKey = 1002; 140 EXPECT_EQ(1, ContainsKey(&table, (uintptr_t)&testKey)); 141 EXPECT_EQ(HASH_SUCCESS, Remove(&table, (uintptr_t)&testKey)); 142 EXPECT_EQ(0, ContainsKey(&table, (uintptr_t)&testKey)); 143 EXPECT_EQ(HASH_SUCCESS, ClearAll(&table)); 144 EXPECT_TRUE(table.size == 0); 145 } 146 147 HWTEST_F(HashTableTest, EmptyTest, TestSize.Level1) 148 { 149 EXPECT_EQ(HASH_ERROR, Empty(0)); 150 EXPECT_EQ(HASH_SUCCESS, Empty(&table)); 151 uint32_t key1 = 1001; 152 uint32_t val1 = 2001; 153 EXPECT_TRUE(Insert(&table, (uintptr_t)&key1, (uintptr_t)&val1) == HASH_INSERTED); 154 EXPECT_EQ(HASH_NOT_EMPTY, Empty(&table)); 155 } 156 157 HWTEST_F(HashTableTest, ResizeTest, TestSize.Level1) 158 { 159 HashTable testTable; 160 EXPECT_EQ(HASH_SUCCESS, CreateHashTable(&testTable, sizeof(uint32_t), 161 sizeof(uint32_t), HASH_MINI_CAPACITY)); 162 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 163 EXPECT_EQ(HASH_SUCCESS, Resize(&testTable, HASH_MINI_CAPACITY * 2)); 164 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY * 2); 165 EXPECT_EQ(HASH_SUCCESS, DestroyHashTable(&testTable)); 166 } 167 168 extern "C" int CapExtend(HashTable *table, size_t miniCapacity); 169 HWTEST_F(HashTableTest, CapExtendTest, TestSize.Level1) 170 { 171 HashTable testTable; 172 EXPECT_EQ(HASH_SUCCESS, CreateHashTable(&testTable, sizeof(uint32_t), 173 sizeof(uint32_t), HASH_MINI_CAPACITY)); 174 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 175 EXPECT_EQ(HASH_SUCCESS, CapExtend(&testTable, HASH_MINI_CAPACITY * 5)); 176 EXPECT_TRUE(testTable.capacity == HASH_MINI_CAPACITY); 177 EXPECT_EQ(HASH_SUCCESS, DestroyHashTable(&testTable)); 178 } 179