1 /* 2 * Copyright (c) 2025 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 <cstdint> 17 #include <fcntl.h> 18 #include <functional> 19 #include <iostream> 20 #include <memory> 21 #include <optional> 22 #include <stdlib.h> 23 #include <utility> 24 #include <vector> 25 26 #include "gtest/gtest.h" 27 28 #define protected public 29 #define private public 30 #include "base/container/list.h" 31 #include "base/container/map.h" 32 33 using namespace testing; 34 using namespace testing::ext; 35 36 namespace OHOS::Ace { 37 class SafeContainerTest : public testing::Test {}; 38 39 /** 40 * @tc.name: SafeListTest001 41 * @tc.desc: Test SafeList construction and basic iterator operations 42 * @tc.type: FUNC 43 */ 44 HWTEST_F(SafeContainerTest, SafeListTest001, TestSize.Level1) 45 { 46 SafeList<int> emptyContainer; 47 EXPECT_EQ(emptyContainer.begin(), emptyContainer.end()); 48 SafeList<int> list = { 1, 2, 3 }; 49 auto endIt = list.end(); 50 --endIt; 51 EXPECT_EQ(*endIt, 3); 52 auto it1 = list.begin(); 53 auto it2 = it1; 54 EXPECT_EQ(it1, it2); 55 EXPECT_EQ(*it1, *it2); 56 } 57 58 /** 59 * @tc.name: SafeListTest002 60 * @tc.desc: Test SafeList emplace_back and push_back 61 * @tc.type: FUNC 62 */ 63 HWTEST_F(SafeContainerTest, SafeListTest002, TestSize.Level1) 64 { 65 SafeList<int> list = { 1, 2, 3 }; 66 auto originalEnd = --list.end(); 67 list.emplace_back(4); 68 EXPECT_EQ(*originalEnd, 3); 69 EXPECT_EQ(list.back(), 4); 70 list.push_back(5); 71 EXPECT_EQ(list.back(), 5); 72 } 73 74 /** 75 * @tc.name: SafeListTest003 76 * @tc.desc: Test SafeList iterator boundary and movement 77 * @tc.type: FUNC 78 */ 79 HWTEST_F(SafeContainerTest, SafeListTest003, TestSize.Level1) 80 { 81 SafeList<int> list = { 1, 2, 3 }; 82 auto endIt = list.end(); 83 ++endIt; 84 EXPECT_EQ(*endIt, 1); 85 --endIt; 86 EXPECT_EQ(endIt, list.end()); 87 --endIt; 88 EXPECT_EQ(*endIt, 3); 89 ++endIt; 90 EXPECT_EQ(endIt, list.end()); 91 } 92 93 /** 94 * @tc.name: SafeListTest004 95 * @tc.desc: Test SafeList element modification and assignment 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(SafeContainerTest, SafeListTest004, TestSize.Level1) 99 { 100 SafeList<int> list = { 1, 2, 3 }; 101 auto it = list.begin(); 102 *it = 10; 103 EXPECT_EQ(*list.begin(), 10); 104 auto originalIt = it; 105 ++it; 106 EXPECT_NE(originalIt, it); 107 } 108 109 /** 110 * @tc.name: SafeListTest005 111 * @tc.desc: Test SafeList reverse iterators 112 * @tc.type: FUNC 113 */ 114 HWTEST_F(SafeContainerTest, SafeListTest005, TestSize.Level1) 115 { 116 SafeList<int> list = { 1, 2, 3, 4, 5 }; 117 std::vector<int> reversed; 118 for (auto rit = list.rbegin(); rit != list.rend(); ++rit) { 119 reversed.push_back(*rit); 120 } 121 EXPECT_EQ(reversed, (std::vector<int> { 5, 4, 3, 2, 1 })); 122 auto rit = list.rbegin(); 123 EXPECT_EQ(*rit, 5); 124 ++rit; 125 EXPECT_EQ(*rit, 4); 126 } 127 128 /** 129 * @tc.name: SafeListTest006 130 * @tc.desc: Test SafeList modification operations (insert/erase) 131 * @tc.type: FUNC 132 */ 133 HWTEST_F(SafeContainerTest, SafeListTest006, TestSize.Level1) 134 { 135 SafeList<int> list = { 1, 2, 3 }; 136 auto it = list.insert(list.begin(), 0); 137 EXPECT_EQ(list.front(), 0); 138 EXPECT_EQ(*it, 0); 139 it = list.erase(it); 140 EXPECT_EQ(list.front(), 1); 141 EXPECT_EQ(*it, 1); 142 } 143 144 /** 145 * @tc.name: SafeListTest007 146 * @tc.desc: Test SafeList sort and unique operations 147 * @tc.type: FUNC 148 */ 149 HWTEST_F(SafeContainerTest, SafeListTest007, TestSize.Level1) 150 { 151 SafeList<int> list = { 3, 1, 5, 1, 4 }; 152 list.sort(); 153 EXPECT_EQ(list.front(), 1); 154 EXPECT_EQ(list.back(), 5); 155 list.unique(); 156 EXPECT_EQ(list.size(), 4); 157 EXPECT_EQ(*(++list.begin()), 3); 158 } 159 160 /** 161 * @tc.name: SafeListTest008 162 * @tc.desc: Test SafeList merge and splice operations 163 * @tc.type: FUNC 164 */ 165 HWTEST_F(SafeContainerTest, SafeListTest008, TestSize.Level1) 166 { 167 SafeList<int> list1 = { 1, 3, 5 }; 168 SafeList<int> list2 = { 2, 4, 6 }; 169 list1.merge(list2); 170 EXPECT_EQ(list1.size(), 6); 171 EXPECT_EQ(list1.back(), 6); 172 EXPECT_TRUE(list2.empty()); 173 SafeList<int> list3 = { 7, 8 }; 174 list1.splice(list1.end(), list3); 175 EXPECT_EQ(list1.back(), 8); 176 } 177 178 /** 179 * @tc.name: SafeListTest009 180 * @tc.desc: Test SafeList special operations (swap/resize) 181 * @tc.type: FUNC 182 */ 183 HWTEST_F(SafeContainerTest, SafeListTest009, TestSize.Level1) 184 { 185 SafeList<int> list1 = { 1, 2, 3 }; 186 SafeList<int> list2 = { 4, 5 }; 187 list1.swap(list2); 188 EXPECT_EQ(list1.front(), 4); 189 EXPECT_EQ(list2.front(), 1); 190 list1.resize(5); 191 EXPECT_EQ(list1.size(), 5); 192 EXPECT_EQ(list1.back(), 0); 193 } 194 195 /** 196 * @tc.name: SafeListTest010 197 * @tc.desc: Test SafeList complex type operations 198 * @tc.type: FUNC 199 */ 200 HWTEST_F(SafeContainerTest, SafeListTest010, TestSize.Level1) 201 { 202 struct Point { 203 int x, y; operator <OHOS::Ace::Point204 bool operator<(const Point& other) const 205 { 206 return x < other.x; 207 } 208 }; 209 210 SafeList<Point> points { { 2, 3 }, { 1, 2 }, { 3, 4 } }; 211 points.sort(); 212 EXPECT_EQ(points.front().x, 1); 213 points.insert(points.end(), { 4, 5 }); 214 EXPECT_EQ(points.back().x, 4); 215 } 216 217 /** 218 * @tc.name: SafeListTest011 219 * @tc.desc: Test SafeList push_front pop_front pop_back 220 * @tc.type: FUNC 221 */ 222 HWTEST_F(SafeContainerTest, SafeListTest011, TestSize.Level1) 223 { 224 SafeList<int> list { 1, 2, 3 }; 225 list.pop_front(); 226 EXPECT_EQ(list.front(), 2); 227 list.push_front(4); 228 EXPECT_EQ(list.front(), 4); 229 int temp = 5; 230 list.push_front(temp); 231 EXPECT_EQ(list.front(), 5); 232 list.pop_back(); 233 EXPECT_EQ(list.back(), 2); 234 list.push_back(5); 235 EXPECT_EQ(list.back(), 5); 236 } 237 238 /** 239 * @tc.name: SafeMapTest001 240 * @tc.desc: Test basic map operations and element access 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(SafeContainerTest, SafeMapTest001, TestSize.Level1) 244 { 245 SafeMap<int, std::string> m; 246 m[1] = "one"; 247 EXPECT_EQ(m[1], "one"); 248 m[1] = "new_one"; 249 EXPECT_EQ(m[1], "new_one"); 250 m.try_emplace(4, "four"); 251 EXPECT_EQ(m.at(4), "four"); 252 auto it = m.begin(); 253 it->second = "modified"; 254 EXPECT_EQ(m[1], "modified"); 255 } 256 257 /** 258 * @tc.name: SafeMapTest002 259 * @tc.desc: Test map insertion methods 260 * @tc.type: FUNC 261 */ 262 HWTEST_F(SafeContainerTest, SafeMapTest002, TestSize.Level1) 263 { 264 SafeMap<int, std::string> m; 265 auto [it1, inserted1] = m.try_emplace(1, "one"); 266 EXPECT_TRUE(inserted1); 267 auto [it2, inserted2] = m.try_emplace(1, "duplicate"); 268 EXPECT_FALSE(inserted2); 269 auto hint = m.find(1); 270 m.insert(hint, { 2, "two" }); 271 EXPECT_EQ(m[2], "two"); 272 std::vector<std::pair<int, std::string>> data { { 3, "three" }, { 4, "four" } }; 273 m.insert(data.begin(), data.end()); 274 EXPECT_EQ(m.size(), 4); 275 } 276 277 /** 278 * @tc.name: SafeMapTest003 279 * @tc.desc: Test map erase operations 280 * @tc.type: FUNC 281 */ 282 HWTEST_F(SafeContainerTest, SafeMapTest003, TestSize.Level1) 283 { 284 SafeMap<int, std::string> m { { 1, "one" }, { 2, "two" }, { 3, "three" } }; 285 auto it = m.find(2); 286 m.erase(it); 287 EXPECT_EQ(m.size(), 2); 288 size_t removed = m.erase(3); 289 EXPECT_EQ(removed, 1); 290 m.erase(m.begin(), m.end()); 291 EXPECT_TRUE(m.empty()); 292 } 293 294 /** 295 * @tc.name: SafeMapTest004 296 * @tc.desc: Test map iteration and traversal 297 * @tc.type: FUNC 298 */ 299 HWTEST_F(SafeContainerTest, SafeMapTest004, TestSize.Level1) 300 { 301 SafeMap<int, std::string> m { { 1, "one" }, { 2, "two" }, { 3, "three" } }; 302 std::vector<int> keys; 303 for (auto& pair : m) { 304 keys.push_back(pair.first); 305 } 306 EXPECT_EQ(keys, (std::vector<int> { 1, 2, 3 })); 307 std::vector<int> reverse_keys; 308 for (auto rit = m.rbegin(); rit != m.rend(); ++rit) { 309 reverse_keys.push_back(rit->first); 310 } 311 EXPECT_EQ(reverse_keys, (std::vector<int> { 3, 2, 1 })); 312 } 313 314 /** 315 * @tc.name: SafeMapTest005 316 * @tc.desc: Test map merge and swap operations 317 * @tc.type: FUNC 318 */ 319 HWTEST_F(SafeContainerTest, SafeMapTest005, TestSize.Level1) 320 { 321 SafeMap<int, std::string> m1 { { 1, "one" }, { 3, "three" } }; 322 SafeMap<int, std::string> m2 { { 2, "two" }, { 3, "new_three" } }; 323 m1.merge(m2); 324 EXPECT_EQ(m1.size(), 3); 325 EXPECT_EQ(m1[3], "three"); 326 m1.swap(m2); 327 EXPECT_EQ(m2.size(), 3); 328 EXPECT_EQ(m1.size(), 1); 329 } 330 331 /** 332 * @tc.name: SafeMapTest006 333 * @tc.desc: Test map special operations 334 * @tc.type: FUNC 335 */ 336 HWTEST_F(SafeContainerTest, SafeMapTest006, TestSize.Level1) 337 { 338 SafeMap<int, std::string> m { { 1, "one" }, { 2, "two" } }; 339 auto lb_it = m.lower_bound(1); 340 EXPECT_EQ(lb_it->first, 1); 341 auto ub_it = m.upper_bound(1); 342 EXPECT_EQ(ub_it->first, 2); 343 auto node = m.extract(1); 344 EXPECT_TRUE(node); 345 EXPECT_EQ(node.key(), 1); 346 } 347 348 /** 349 * @tc.name: SafeMapTest007 350 * @tc.desc: Test map copy/move operations 351 * @tc.type: FUNC 352 */ 353 HWTEST_F(SafeContainerTest, SafeMapTest007, TestSize.Level1) 354 { 355 SafeMap<int, std::string> original { { 1, "one" }, { 2, "two" } }; 356 SafeMap<int, std::string> copy(original); 357 EXPECT_EQ(copy.size(), 2); 358 EXPECT_EQ(copy[1], "one"); 359 SafeMap<int, std::string> moved(std::move(original)); 360 EXPECT_TRUE(original.empty()); 361 EXPECT_EQ(moved.size(), 2); 362 } 363 364 /** 365 * @tc.name: SafeMapTest008 366 * @tc.desc: Test map capacity methods 367 * @tc.type: FUNC 368 */ 369 HWTEST_F(SafeContainerTest, SafeMapTest008, TestSize.Level1) 370 { 371 SafeMap<int, std::string> m; 372 EXPECT_TRUE(m.empty()); 373 EXPECT_EQ(m.size(), 0); 374 m.emplace(1, "one"); 375 EXPECT_FALSE(m.empty()); 376 EXPECT_EQ(m.size(), 1); 377 } 378 379 /** 380 * @tc.name: SafeMapTest009 381 * @tc.desc: Test map lookup operations 382 * @tc.type: FUNC 383 */ 384 HWTEST_F(SafeContainerTest, SafeMapTest009, TestSize.Level1) 385 { 386 SafeMap<int, std::string> m { { 1, "one" }, { 2, "two" } }; 387 EXPECT_EQ(m.count(1), 1); 388 EXPECT_EQ(m.count(3), 0); 389 auto it1 = m.find(3); 390 EXPECT_EQ(it1, m.end()); 391 auto it2 = m.find(2); 392 EXPECT_NE(it2, m.end()); 393 } 394 } // namespace OHOS::Ace