1 /* 2 * Copyright (c) 2024 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 18 #include <base/containers/array_view.h> 19 #include <base/containers/iterator.h> 20 #include <base/containers/string_view.h> 21 22 using namespace BASE_NS; 23 using namespace testing::ext; 24 25 struct Node { 26 int value = 0; 27 Node* next = nullptr; 28 }; 29 30 class IteratorTest : public testing::Test { 31 public: SetUpTestSuite()32 static void SetUpTestSuite() {} TearDownTestSuite()33 static void TearDownTestSuite() {} SetUp()34 void SetUp() override {} TearDown()35 void TearDown() override {} 36 }; 37 38 HWTEST_F(IteratorTest, ConstIterator001, TestSize.Level1) 39 { 40 int intData[] = { 4, 3, 2, 1, 0 }; 41 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 42 { 43 BASE_NS::const_iterator<array_view<int>> it = intAv.begin(); 44 45 ASSERT_EQ(*it, intData[0]); 46 47 auto vPrefix = ++it; 48 ASSERT_EQ(*it, intData[1]); 49 ASSERT_EQ(*vPrefix, intData[1]); 50 ASSERT_TRUE(vPrefix == it); 51 52 vPrefix = it.operator++(); 53 ASSERT_EQ(*it, intData[2]); 54 ASSERT_EQ(*vPrefix, intData[2]); 55 ASSERT_TRUE(vPrefix == it); 56 57 auto prev = it; 58 auto vPostfix = it.operator++(3); 59 ASSERT_EQ(*it, intData[3]); 60 ASSERT_EQ(*vPostfix, intData[2]); 61 ASSERT_TRUE(vPostfix == prev); 62 63 prev = it; 64 vPostfix = it.operator++(100); 65 ASSERT_EQ(*it, intData[4]); 66 ASSERT_EQ(*vPostfix, intData[3]); 67 ASSERT_TRUE(vPostfix == prev); 68 69 vPrefix = --it; 70 ASSERT_EQ(*it, intData[3]); 71 ASSERT_EQ(*vPrefix, intData[3]); 72 ASSERT_TRUE(vPrefix == it); 73 74 vPrefix = it.operator--(); 75 ASSERT_EQ(*it, intData[2]); 76 ASSERT_EQ(*vPrefix, intData[2]); 77 ASSERT_TRUE(vPrefix == it); 78 79 prev = it; 80 vPostfix = it.operator--(3); 81 ASSERT_EQ(*it, intData[1]); 82 ASSERT_EQ(*vPostfix, intData[2]); 83 ASSERT_TRUE(vPostfix == prev); 84 85 prev = it; 86 vPostfix = it.operator--(100); 87 ASSERT_EQ(*it, intData[0]); 88 ASSERT_EQ(*vPostfix, intData[1]); 89 ASSERT_TRUE(vPostfix == prev); 90 } 91 } 92 93 HWTEST_F(IteratorTest, ConstIterator002, TestSize.Level1) 94 { 95 int intData[] = { 4, 3, 2, 1, 0 }; 96 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 97 98 { 99 BASE_NS::const_iterator<array_view<int>> it = intAv.begin(); 100 101 ASSERT_EQ(*it, intData[0]); 102 103 auto v = it + 3; 104 ASSERT_EQ(v - it, 3); 105 it += 3; 106 ASSERT_EQ(*v, intData[3]); 107 ASSERT_EQ(*it, intData[3]); 108 109 v = it - 2; 110 ASSERT_EQ(v - it, -2); 111 it -= 2; 112 ASSERT_EQ(*v, intData[1]); 113 ASSERT_EQ(*it, intData[1]); 114 } 115 } 116 117 HWTEST_F(IteratorTest, ConstIterator003, TestSize.Level1) 118 { 119 int intData[] = { 4, 3, 2, 1, 0 }; 120 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 121 122 { 123 BASE_NS::const_iterator<array_view<int>> itBegin = intAv.begin(); 124 BASE_NS::const_iterator<array_view<int>> itCbegin = intAv.cbegin(); 125 BASE_NS::const_iterator<array_view<int>> itEnd = intAv.end(); 126 BASE_NS::const_iterator<array_view<int>> itCend = intAv.cend(); 127 128 ASSERT_TRUE(itBegin == itCbegin); 129 ASSERT_TRUE(itBegin != itEnd); 130 ASSERT_TRUE(itBegin != itCend); 131 132 ASSERT_TRUE(itCbegin != itEnd); 133 ASSERT_TRUE(itCbegin != itCend); 134 135 ASSERT_TRUE(itEnd == itCend); 136 137 ASSERT_TRUE(itBegin >= itCbegin); 138 ASSERT_TRUE(itBegin <= itCbegin); 139 ASSERT_TRUE(itBegin <= itEnd); 140 ASSERT_TRUE(itEnd >= itBegin); 141 ASSERT_TRUE(itBegin <= itCend); 142 ASSERT_TRUE(itCend >= itBegin); 143 144 ASSERT_TRUE(itCbegin <= itEnd); 145 ASSERT_TRUE(itEnd >= itCbegin); 146 ASSERT_TRUE(itCbegin <= itCend); 147 ASSERT_TRUE(itCend >= itCbegin); 148 149 ASSERT_TRUE(itEnd <= itCend); 150 ASSERT_TRUE(itEnd >= itCend); 151 152 ASSERT_TRUE(itBegin < itEnd); 153 ASSERT_TRUE(itEnd > itBegin); 154 ASSERT_TRUE(itBegin < itCend); 155 ASSERT_TRUE(itEnd > itBegin); 156 157 ASSERT_TRUE(itCbegin < itEnd); 158 ASSERT_TRUE(itEnd > itCbegin); 159 ASSERT_TRUE(itCbegin < itCend); 160 ASSERT_TRUE(itEnd > itCbegin); 161 } 162 } 163 164 HWTEST_F(IteratorTest, ConstIterator004, TestSize.Level1) 165 { 166 Node nodeArray[5]; 167 nodeArray[0].value = 4; 168 nodeArray[1].value = 3; 169 nodeArray[2].value = 2; 170 nodeArray[3].value = 1; 171 nodeArray[4].value = 0; 172 BASE_NS::array_view<Node> nodeAv = BASE_NS::array_view<Node>(nodeArray); 173 { 174 BASE_NS::const_iterator<array_view<Node>> it = nodeAv.begin(); 175 ASSERT_EQ(it->value, 4); 176 ASSERT_EQ(it->next, nullptr); 177 } 178 } 179 180 HWTEST_F(IteratorTest, Iterator001, TestSize.Level1) 181 { 182 int intData[] = { 4, 3, 2, 1, 0 }; 183 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 184 { 185 BASE_NS::iterator<array_view<int>> it = intAv.begin(); 186 187 ASSERT_EQ(*it, intData[0]); 188 189 auto vPrefix = ++it; 190 ASSERT_EQ(*it, intData[1]); 191 ASSERT_EQ(*vPrefix, intData[1]); 192 ASSERT_TRUE(vPrefix == it); 193 194 vPrefix = it.operator++(); 195 ASSERT_EQ(*it, intData[2]); 196 ASSERT_EQ(*vPrefix, intData[2]); 197 ASSERT_TRUE(vPrefix == it); 198 199 auto prev = it; 200 auto vPostfix = it.operator++(3); 201 ASSERT_EQ(*it, intData[3]); 202 ASSERT_EQ(*vPostfix, intData[2]); 203 ASSERT_TRUE(vPostfix == prev); 204 205 prev = it; 206 vPostfix = it.operator++(100); 207 ASSERT_EQ(*it, intData[4]); 208 ASSERT_EQ(*vPostfix, intData[3]); 209 ASSERT_TRUE(vPostfix == prev); 210 211 vPrefix = --it; 212 ASSERT_EQ(*it, intData[3]); 213 ASSERT_EQ(*vPrefix, intData[3]); 214 ASSERT_TRUE(vPrefix == it); 215 216 vPrefix = it.operator--(); 217 ASSERT_EQ(*it, intData[2]); 218 ASSERT_EQ(*vPrefix, intData[2]); 219 ASSERT_TRUE(vPrefix == it); 220 221 prev = it; 222 vPostfix = it.operator--(3); 223 ASSERT_EQ(*it, intData[1]); 224 ASSERT_EQ(*vPostfix, intData[2]); 225 ASSERT_TRUE(vPostfix == prev); 226 227 prev = it; 228 vPostfix = it.operator--(100); 229 ASSERT_EQ(*it, intData[0]); 230 ASSERT_EQ(*vPostfix, intData[1]); 231 ASSERT_TRUE(vPostfix == prev); 232 } 233 } 234 235 HWTEST_F(IteratorTest, Iterator002, TestSize.Level1) 236 { 237 int intData[] = { 4, 3, 2, 1, 0 }; 238 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 239 { 240 BASE_NS::iterator<array_view<int>> it = intAv.begin(); 241 242 ASSERT_EQ(*it, intData[0]); 243 244 auto v = it + 3; 245 ASSERT_EQ(v - it, 3); 246 it += 3; 247 ASSERT_EQ(*v, intData[3]); 248 ASSERT_EQ(*it, intData[3]); 249 250 v = it - 2; 251 ASSERT_EQ(v - it, -2); 252 it -= 2; 253 ASSERT_EQ(*v, intData[1]); 254 ASSERT_EQ(*it, intData[1]); 255 } 256 } 257 258 HWTEST_F(IteratorTest, Iterator003, TestSize.Level1) 259 { 260 int intData[] = { 4, 3, 2, 1, 0 }; 261 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 262 { 263 BASE_NS::iterator<array_view<int>> itBegin = intAv.begin(); 264 BASE_NS::iterator<array_view<int>> itBegin2 = 265 intAv.end() - static_cast<BASE_NS::iterator<array_view<int>>::difference_type>(intAv.size()); 266 BASE_NS::iterator<array_view<int>> itEnd = intAv.end(); 267 BASE_NS::iterator<array_view<int>> itEnd2 = 268 intAv.begin() + static_cast<BASE_NS::iterator<array_view<int>>::difference_type>(intAv.size()); 269 270 ASSERT_TRUE(itBegin == itBegin2); 271 ASSERT_TRUE(itBegin != itEnd); 272 ASSERT_TRUE(itBegin != itEnd2); 273 274 ASSERT_TRUE(itBegin2 != itEnd); 275 ASSERT_TRUE(itBegin2 != itEnd2); 276 277 ASSERT_TRUE(itEnd == itEnd2); 278 279 ASSERT_TRUE(itBegin >= itBegin2); 280 ASSERT_TRUE(itBegin <= itBegin2); 281 ASSERT_TRUE(itBegin <= itEnd); 282 ASSERT_TRUE(itEnd >= itBegin); 283 ASSERT_TRUE(itBegin <= itEnd2); 284 ASSERT_TRUE(itEnd2 >= itBegin); 285 286 ASSERT_TRUE(itBegin2 <= itEnd); 287 ASSERT_TRUE(itEnd >= itBegin2); 288 ASSERT_TRUE(itBegin2 <= itEnd2); 289 ASSERT_TRUE(itEnd2 >= itBegin2); 290 291 ASSERT_TRUE(itEnd <= itEnd2); 292 ASSERT_TRUE(itEnd >= itEnd2); 293 294 ASSERT_TRUE(itBegin < itEnd); 295 ASSERT_TRUE(itEnd > itBegin); 296 ASSERT_TRUE(itBegin < itEnd2); 297 ASSERT_TRUE(itEnd > itBegin); 298 299 ASSERT_TRUE(itBegin2 < itEnd); 300 ASSERT_TRUE(itEnd > itBegin2); 301 ASSERT_TRUE(itBegin2 < itEnd2); 302 ASSERT_TRUE(itEnd > itBegin2); 303 } 304 } 305 306 HWTEST_F(IteratorTest, Iterator004, TestSize.Level1) 307 { 308 Node nodeArray[5]; 309 nodeArray[0].value = 4; 310 nodeArray[1].value = 3; 311 nodeArray[2].value = 2; 312 nodeArray[3].value = 1; 313 nodeArray[4].value = 0; 314 BASE_NS::array_view<Node> nodeAv = BASE_NS::array_view<Node>(nodeArray); 315 { 316 BASE_NS::iterator<array_view<Node>> it = nodeAv.begin(); 317 ASSERT_EQ(it->value, 4); 318 ASSERT_EQ(it->next, nullptr); 319 } 320 321 { 322 const BASE_NS::iterator<array_view<Node>> it = (nodeAv.end() - 1); 323 ASSERT_EQ(it->value, 0); 324 ASSERT_EQ(it->next, nullptr); 325 } 326 } 327 328 HWTEST_F(IteratorTest, ReverseIterator001, TestSize.Level1) 329 { 330 int intData[] = { 4, 3, 2, 1, 0 }; 331 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 332 { 333 BASE_NS::reverse_iterator<iterator<array_view<int>>> it(intAv.begin()); 334 it--; // to set to [0] 335 336 ASSERT_EQ(*it, intData[0]); 337 338 auto vPrefix = --it; 339 ASSERT_EQ(*it, intData[1]); 340 ASSERT_EQ(*vPrefix, intData[1]); 341 ASSERT_TRUE(vPrefix == it); 342 343 vPrefix = it.operator--(); 344 ASSERT_EQ(*it, intData[2]); 345 ASSERT_EQ(*vPrefix, intData[2]); 346 ASSERT_TRUE(vPrefix == it); 347 348 auto prev = it; 349 auto vPostfix = it.operator--(3); 350 ASSERT_EQ(*it, intData[3]); 351 ASSERT_EQ(*vPostfix, intData[2]); 352 ASSERT_TRUE(vPostfix == prev); 353 354 prev = it; 355 vPostfix = it.operator--(100); 356 ASSERT_EQ(*it, intData[4]); 357 ASSERT_EQ(*vPostfix, intData[3]); 358 ASSERT_TRUE(vPostfix == prev); 359 360 vPrefix = ++it; 361 ASSERT_EQ(*it, intData[3]); 362 ASSERT_EQ(*vPrefix, intData[3]); 363 ASSERT_TRUE(vPrefix == it); 364 365 vPrefix = it.operator++(); 366 ASSERT_EQ(*it, intData[2]); 367 ASSERT_EQ(*vPrefix, intData[2]); 368 ASSERT_TRUE(vPrefix == it); 369 370 prev = it; 371 vPostfix = it.operator++(3); 372 ASSERT_EQ(*it, intData[1]); 373 ASSERT_EQ(*vPostfix, intData[2]); 374 ASSERT_TRUE(vPostfix == prev); 375 376 prev = it; 377 vPostfix = it.operator++(100); 378 ASSERT_EQ(*it, intData[0]); 379 ASSERT_EQ(*vPostfix, intData[1]); 380 ASSERT_TRUE(vPostfix == prev); 381 } 382 } 383 384 HWTEST_F(IteratorTest, ReverseIterator002, TestSize.Level1) 385 { 386 int intData[] = { 4, 3, 2, 1, 0 }; 387 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 388 { 389 BASE_NS::reverse_iterator<iterator<array_view<int>>> it(intAv.begin()); 390 it--; // to set to [0] 391 392 ASSERT_EQ(*it, intData[0]); 393 394 auto v = it - 3; 395 ASSERT_EQ(v - it, -3); 396 it -= 3; 397 ASSERT_EQ(*v, intData[3]); 398 ASSERT_EQ(*it, intData[3]); 399 400 v = it + 2; 401 ASSERT_EQ(v - it, 2); 402 it += 2; 403 ASSERT_EQ(*v, intData[1]); 404 ASSERT_EQ(*it, intData[1]); 405 } 406 } 407 408 HWTEST_F(IteratorTest, ReverseIterator003, TestSize.Level1) 409 { 410 int intData[] = { 4, 3, 2, 1, 0 }; 411 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 412 { 413 BASE_NS::reverse_iterator<iterator<array_view<int>>> itBegin(intAv.begin()); 414 BASE_NS::reverse_iterator<iterator<array_view<int>>> itBegin2( 415 intAv.end() - static_cast<array_view<int>::iterator::difference_type>(intAv.size())); 416 BASE_NS::reverse_iterator<iterator<array_view<int>>> itEnd(intAv.end()); 417 BASE_NS::reverse_iterator<iterator<array_view<int>>> itEnd2( 418 intAv.begin() + static_cast<array_view<int>::iterator::difference_type>(intAv.size())); 419 420 ASSERT_TRUE(itBegin == itBegin2); 421 ASSERT_TRUE(itBegin != itEnd); 422 ASSERT_TRUE(itBegin != itEnd2); 423 424 ASSERT_TRUE(itBegin2 != itEnd); 425 ASSERT_TRUE(itBegin2 != itEnd2); 426 427 ASSERT_TRUE(itEnd == itEnd2); 428 429 ASSERT_TRUE(itBegin >= itBegin2); 430 ASSERT_TRUE(itBegin <= itBegin2); 431 ASSERT_TRUE(itBegin >= itEnd); 432 ASSERT_TRUE(itEnd <= itBegin); 433 ASSERT_TRUE(itBegin >= itEnd2); 434 ASSERT_TRUE(itEnd2 <= itBegin); 435 436 ASSERT_TRUE(itBegin2 >= itEnd); 437 ASSERT_TRUE(itEnd <= itBegin2); 438 ASSERT_TRUE(itBegin2 >= itEnd2); 439 ASSERT_TRUE(itEnd2 <= itBegin2); 440 441 ASSERT_TRUE(itEnd <= itEnd2); 442 ASSERT_TRUE(itEnd >= itEnd2); 443 444 ASSERT_TRUE(itBegin > itEnd); 445 ASSERT_TRUE(itEnd < itBegin); 446 ASSERT_TRUE(itBegin > itEnd2); 447 ASSERT_TRUE(itEnd < itBegin); 448 449 ASSERT_TRUE(itBegin2 > itEnd); 450 ASSERT_TRUE(itEnd < itBegin2); 451 ASSERT_TRUE(itBegin2 > itEnd2); 452 ASSERT_TRUE(itEnd < itBegin2); 453 } 454 } 455 456 HWTEST_F(IteratorTest, ReverseIterator004, TestSize.Level1) 457 { 458 Node nodeArray[5]; 459 nodeArray[0].value = 4; 460 nodeArray[1].value = 3; 461 nodeArray[2].value = 2; 462 nodeArray[3].value = 1; 463 nodeArray[4].value = 0; 464 BASE_NS::array_view<Node> nodeAv = BASE_NS::array_view<Node>(nodeArray); 465 { 466 BASE_NS::reverse_iterator<iterator<array_view<Node>>> it(nodeAv.begin()); 467 it--; 468 ASSERT_EQ(it->value, 4); 469 ASSERT_EQ(it->next, nullptr); 470 } 471 472 { 473 const BASE_NS::reverse_iterator<iterator<array_view<Node>>> it( 474 (nodeAv.end())); //- 1 removed cause iterator is created before original value 475 ASSERT_EQ(it->value, 0); 476 ASSERT_EQ(it->next, nullptr); 477 } 478 } 479 480 HWTEST_F(IteratorTest, ReverseIterator005, TestSize.Level1) 481 { 482 const char* charData = "43210"; 483 BASE_NS::string_view sv(charData); 484 { 485 auto it = sv.rend(); // rend = begin -> needs -- to point to [0] 486 it--; 487 ASSERT_EQ(*it, charData[0]); 488 489 auto vPrefix = --it; 490 ASSERT_EQ(*it, charData[1]); 491 ASSERT_EQ(*vPrefix, charData[1]); 492 ASSERT_TRUE(vPrefix == it); 493 494 vPrefix = it.operator--(); 495 ASSERT_EQ(*it, charData[2]); 496 ASSERT_EQ(*vPrefix, charData[2]); 497 ASSERT_TRUE(vPrefix == it); 498 499 auto prev = it; 500 auto vPostfix = it.operator--(3); 501 ASSERT_EQ(*it, charData[3]); 502 ASSERT_EQ(*vPostfix, charData[2]); 503 ASSERT_TRUE(vPostfix == prev); 504 505 prev = it; 506 vPostfix = it.operator--(100); 507 ASSERT_EQ(*it, charData[4]); 508 ASSERT_EQ(*vPostfix, charData[3]); 509 ASSERT_TRUE(vPostfix == prev); 510 511 vPrefix = ++it; 512 ASSERT_EQ(*it, charData[3]); 513 ASSERT_EQ(*vPrefix, charData[3]); 514 ASSERT_TRUE(vPrefix == it); 515 516 vPrefix = it.operator++(); 517 ASSERT_EQ(*it, charData[2]); 518 ASSERT_EQ(*vPrefix, charData[2]); 519 ASSERT_TRUE(vPrefix == it); 520 521 prev = it; 522 vPostfix = it.operator++(3); 523 ASSERT_EQ(*it, charData[1]); 524 ASSERT_EQ(*vPostfix, charData[2]); 525 ASSERT_TRUE(vPostfix == prev); 526 527 prev = it; 528 vPostfix = it.operator++(100); 529 ASSERT_EQ(*it, charData[0]); 530 ASSERT_EQ(*vPostfix, charData[1]); 531 ASSERT_TRUE(vPostfix == prev); 532 } 533 } 534 535 HWTEST_F(IteratorTest, MoveIterator001, TestSize.Level1) 536 { 537 int intData[] = { 4, 3, 2, 1, 0 }; 538 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 539 typedef BASE_NS::array_view<int>::iterator Iter; 540 { 541 BASE_NS::move_iterator<Iter> it(intAv.begin()); 542 543 ASSERT_EQ(*it, intData[0]); 544 545 auto vPrefix = ++it; 546 ASSERT_EQ(*it, intData[1]); 547 ASSERT_EQ(*vPrefix, intData[1]); 548 ASSERT_TRUE(vPrefix == it); 549 550 vPrefix = it.operator++(); 551 ASSERT_EQ(*it, intData[2]); 552 ASSERT_EQ(*vPrefix, intData[2]); 553 ASSERT_TRUE(vPrefix == it); 554 555 auto prev = it; 556 auto vPostfix = it.operator++(3); 557 ASSERT_EQ(*it, intData[3]); 558 ASSERT_EQ(*vPostfix, intData[2]); 559 ASSERT_TRUE(vPostfix == prev); 560 561 prev = it; 562 vPostfix = it.operator++(100); 563 ASSERT_EQ(*it, intData[4]); 564 ASSERT_EQ(*vPostfix, intData[3]); 565 ASSERT_TRUE(vPostfix == prev); 566 567 vPrefix = --it; 568 ASSERT_EQ(*it, intData[3]); 569 ASSERT_EQ(*vPrefix, intData[3]); 570 ASSERT_TRUE(vPrefix == it); 571 572 vPrefix = it.operator--(); 573 ASSERT_EQ(*it, intData[2]); 574 ASSERT_EQ(*vPrefix, intData[2]); 575 ASSERT_TRUE(vPrefix == it); 576 577 prev = it; 578 vPostfix = it.operator--(3); 579 ASSERT_EQ(*it, intData[1]); 580 ASSERT_EQ(*vPostfix, intData[2]); 581 ASSERT_TRUE(vPostfix == prev); 582 583 prev = it; 584 vPostfix = it.operator--(100); 585 ASSERT_EQ(*it, intData[0]); 586 ASSERT_EQ(*vPostfix, intData[1]); 587 ASSERT_TRUE(vPostfix == prev); 588 } 589 } 590 591 HWTEST_F(IteratorTest, MoveIterator002, TestSize.Level1) 592 { 593 int intData[] = { 4, 3, 2, 1, 0 }; 594 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 595 typedef BASE_NS::array_view<int>::iterator Iter; 596 { 597 BASE_NS::move_iterator<Iter> it(intAv.begin()); 598 599 ASSERT_EQ(*it, intData[0]); 600 601 auto v = it + 3; 602 ASSERT_EQ(v - it, 3); 603 it += 3; 604 ASSERT_EQ(*v, intData[3]); 605 ASSERT_EQ(*it, intData[3]); 606 607 v = it - 2; 608 ASSERT_EQ(v - it, -2); 609 it -= 2; 610 ASSERT_EQ(*v, intData[1]); 611 ASSERT_EQ(*it, intData[1]); 612 613 v = 3 + it; 614 ASSERT_EQ(v - it, 3); 615 it += 3; 616 ASSERT_EQ(*v, intData[4]); 617 ASSERT_EQ(*it, intData[4]); 618 } 619 } 620 621 HWTEST_F(IteratorTest, MoveIterator003, TestSize.Level1) 622 { 623 int intData[] = { 4, 3, 2, 1, 0 }; 624 BASE_NS::array_view<int> intAv = BASE_NS::array_view<int>(intData); 625 typedef BASE_NS::array_view<int>::iterator Iter; 626 { 627 BASE_NS::move_iterator<Iter> itBegin(intAv.begin()); 628 BASE_NS::move_iterator<Iter> itBegin2( 629 intAv.end() - static_cast<array_view<int>::iterator::difference_type>(intAv.size())); 630 BASE_NS::move_iterator<Iter> itEnd(intAv.end()); 631 BASE_NS::move_iterator<Iter> itEnd2( 632 intAv.begin() + static_cast<array_view<int>::iterator::difference_type>(intAv.size())); 633 634 ASSERT_TRUE(itBegin == itBegin2); 635 ASSERT_TRUE(itBegin != itEnd); 636 ASSERT_TRUE(itBegin != itEnd2); 637 638 ASSERT_TRUE(itBegin2 != itEnd); 639 ASSERT_TRUE(itBegin2 != itEnd2); 640 641 ASSERT_TRUE(itEnd == itEnd2); 642 643 ASSERT_TRUE(itBegin >= itBegin2); 644 ASSERT_TRUE(itBegin <= itBegin2); 645 ASSERT_TRUE(itBegin <= itEnd); 646 ASSERT_TRUE(itEnd >= itBegin); 647 ASSERT_TRUE(itBegin <= itEnd2); 648 ASSERT_TRUE(itEnd2 >= itBegin); 649 650 ASSERT_TRUE(itBegin2 <= itEnd); 651 ASSERT_TRUE(itEnd >= itBegin2); 652 ASSERT_TRUE(itBegin2 <= itEnd2); 653 ASSERT_TRUE(itEnd2 >= itBegin2); 654 655 ASSERT_TRUE(itEnd <= itEnd2); 656 ASSERT_TRUE(itEnd >= itEnd2); 657 658 ASSERT_TRUE(itBegin < itEnd); 659 ASSERT_TRUE(itEnd > itBegin); 660 ASSERT_TRUE(itBegin < itEnd2); 661 ASSERT_TRUE(itEnd > itBegin); 662 663 ASSERT_TRUE(itBegin2 < itEnd); 664 ASSERT_TRUE(itEnd > itBegin2); 665 ASSERT_TRUE(itBegin2 < itEnd2); 666 ASSERT_TRUE(itEnd > itBegin2); 667 } 668 } 669 670 HWTEST_F(IteratorTest, MoveIterator004, TestSize.Level1) 671 { 672 Node nodeArray[5]; 673 nodeArray[0].value = 4; 674 nodeArray[1].value = 3; 675 nodeArray[2].value = 2; 676 nodeArray[3].value = 1; 677 nodeArray[4].value = 0; 678 typedef BASE_NS::array_view<Node>::iterator IterNode; 679 BASE_NS::array_view<Node> nodeAv = BASE_NS::array_view<Node>(nodeArray); 680 { 681 BASE_NS::move_iterator<IterNode> it = make_move_iterator(nodeAv.begin()); 682 ASSERT_EQ(it->value, 4); 683 ASSERT_EQ(it->next, nullptr); 684 } 685 686 { 687 const BASE_NS::move_iterator<IterNode> it = make_move_iterator(nodeAv.end() - 1); 688 ASSERT_EQ(it->value, 0); 689 ASSERT_EQ(it->next, nullptr); 690 } 691 }