libstdc++-v3/testsuite/24_iterators/iterator.cc

   1 // 24.1.5 Random access iterators
   2 // 24.3.1 Iterator traits
   3 // (basic_string and vector implementations)
   4 //
   5 // Copyright (C) 1999, 2003, 2004, 2005 Free Software Foundation, Inc.
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 2 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  19 // USA
  20
  21
  22 #include <string>
  23 #include <vector>
  24 #include <testsuite_hooks.h>
  25
  26 int
  27 string_stuff()
  28 {
  29    int failures(0);
  30
  31    std::string s("abcde");
  32
  33    std::string::iterator i1(s.begin());
  34    if (*i1 != 'a')
  35       ++failures;
  36
  37    ++i1;
  38    if (*i1 != 'b')
  39       ++failures;
  40
  41    if (*i1++ != 'b')
  42        ++failures;
  43    if (*i1 != 'c')
  44       ++failures;
  45
  46    ++ ++i1;
  47    if (*i1 != 'e')
  48       ++failures;
  49
  50    --i1;
  51    if (*i1 != 'd')
  52       ++failures;
  53
  54    if (*i1-- != 'd')
  55       ++failures;
  56    if (*i1 != 'c')
  57       ++failures;
  58
  59    -- --i1;
  60    if (*i1 != 'a')
  61       ++failures;
  62
  63    std::string::iterator i2;
  64    i2 = s.end();
  65    std::iterator_traits<std::string::iterator>::difference_type d1;
  66    d1 = i2 - i1;
  67    if (d1 != 5)
  68       ++failures;
  69
  70    std::iterator_traits<std::string::iterator>::value_type v1;
  71    v1 = i1[0];
  72    if (v1 != 'a')
  73       ++failures;
  74
  75    std::iterator_traits<std::string::iterator>::reference r1(i1[0]);
  76    if (r1 != 'a')
  77       ++failures;
  78    r1 = 'x';
  79    if (r1 != 'x')
  80       ++failures;
  81    r1 = 'a';
  82
  83    if ((i1 != i2) != true)
  84       ++failures;
  85    if ((i1 == i2) != false)
  86       ++failures;
  87    if ((i1 <  i2) != true)
  88       ++failures;
  89    if ((i1 >  i2) != false)
  90       ++failures;
  91    if ((i1 <= i2) != true)
  92       ++failures;
  93    if ((i1 >= i2) != false)
  94       ++failures;
  95
  96    std::string::iterator i3;
  97    i3 = i1;
  98    if ((i3 == i1) != true)
  99       ++failures;
 100
 101    i3 += 5;
 102    if ((i3 == i2) != true)
 103       ++failures;
 104
 105    i3 -= 5;
 106    if ((i3 == i1) != true)
 107       ++failures;
 108
 109    if (i3 + 5 != i2)
 110       ++failures;
 111
 112    if (5 + i3 != i2)
 113       ++failures;
 114
 115    if (i2 - 5 != i3)
 116       ++failures;
 117
 118    if (i1[0] != 'a')
 119       ++failures;
 120
 121    i1[4] = 'x';
 122    if (i2[-1] != 'x')
 123       ++failures;
 124    i1[4] = 'e';
 125
 126    i1[2] = 'x';
 127    if (i2[-3] != 'x')
 128       ++failures;
 129    i1[2] = 'c';
 130
 131    std::string::const_iterator ci1(s.begin());
 132    if (*ci1 != 'a')
 133       ++failures;
 134
 135    ++ci1;
 136    if (*ci1 != 'b')
 137       ++failures;
 138
 139    if (*ci1++ != 'b')
 140       ++failures;
 141    if (*ci1 != 'c')
 142       ++failures;
 143
 144    ++ ++ci1;
 145    if (*ci1 != 'e')
 146       ++failures;
 147
 148    --ci1;
 149    if (*ci1 != 'd')
 150       ++failures;
 151
 152    if (*ci1-- != 'd')
 153       ++failures;
 154    if (*ci1 != 'c')
 155       ++failures;
 156
 157    -- --ci1;
 158    if (*ci1 != 'a')
 159       ++failures;
 160
 161    std::string::const_iterator ci2;
 162    ci2 = s.end();
 163    std::iterator_traits<std::string::const_iterator>::difference_type d2;
 164    d2 = ci2 - ci1;
 165    if (d2 != 5)
 166      ++failures;
 167
 168    std::iterator_traits<std::string::const_iterator>::value_type v2;
 169    v2 = ci1[0];
 170    if (v2 != 'a')
 171      ++failures;
 172
 173    std::iterator_traits<std::string::const_iterator>::reference r2(ci1[0]);
 174    if (r2 != 'a')
 175       ++failures;
 176
 177    if ((ci1 != ci2) != true)
 178       ++failures;
 179    if ((ci1 == ci2) != false)
 180       ++failures;
 181    if ((ci1 <  ci2) != true)
 182       ++failures;
 183    if ((ci1 >  ci2) != false)
 184       ++failures;
 185    if ((ci1 <= ci2) != true)
 186       ++failures;
 187    if ((ci1 >= ci2) != false)
 188       ++failures;
 189
 190    std::string::const_iterator ci3;
 191    ci3 = ci1;
 192    if ((ci3 == ci1) != true)
 193       ++failures;
 194
 195    ci3 += 5;
 196    if ((ci3 == ci2) != true)
 197       ++failures;
 198
 199    ci3 -= 5;
 200    if ((ci3 == ci1) != true)
 201       ++failures;
 202
 203    if (ci3 + 5 != ci2)
 204       ++failures;
 205
 206    if (5 + ci3 != ci2)
 207       ++failures;
 208
 209    if (ci2 - 5 != ci3)
 210       ++failures;
 211
 212    if (ci1[2] != 'c')
 213       ++failures;
 214
 215    if (ci2[-1] != 'e')
 216       ++failures;
 217
 218    // iterator and const_iterator
 219    std::string::const_iterator ci4(i1);
 220    if ((ci4 == i1) != true)
 221       ++failures;
 222    if ((ci4 != i1) != false)
 223       ++failures;
 224    if ((ci4 < i1)  != false)
 225      ++failures;
 226    if ((ci4 > i1)  != false)
 227      ++failures;
 228    if ((ci4 <= i1) != true)
 229      ++failures;
 230    if ((ci4 >= i1) != true)
 231      ++failures;
 232    ci4 = i2;
 233    if ((i2 == ci4) != true)
 234      ++failures;
 235    if ((i2 < ci4)  != false)
 236      ++failures;
 237    if ((i2 > ci4)  != false)
 238      ++failures;
 239    if ((i2 <= ci4) != true)
 240      ++failures;
 241    if ((i2 >= ci4) != true)
 242      ++failures;
 243
 244    const std::string cs("ABCDE");
 245    std::string::const_iterator ci5(cs.begin());
 246    if (ci5[0] != 'A')
 247       ++failures;
 248
 249    return failures;
 250 }
 251
 252 int
 253 vector_stuff()
 254 {
 255    int failures(0);
 256
 257    std::vector<int> v;
 258    v.push_back(int(1));
 259    v.push_back(int(2));
 260    v.push_back(int(3));
 261    v.push_back(int(4));
 262    v.push_back(int(5));
 263
 264    std::vector<int>::iterator i1(v.begin());
 265    if (*i1 != 1)
 266       ++failures;
 267
 268    ++i1;
 269    if (*i1 != 2)
 270       ++failures;
 271
 272    if (*i1++ != 2)
 273       ++failures;
 274    if (*i1 != 3)
 275       ++failures;
 276
 277    ++ ++i1;
 278    if (*i1 != 5)
 279       ++failures;
 280
 281    --i1;
 282    if (*i1 != 4)
 283       ++failures;
 284
 285    if (*i1-- != 4)
 286       ++failures;
 287    if (*i1 != 3)
 288       ++failures;
 289
 290    -- --i1;
 291    if (*i1 != 1)
 292       ++failures;
 293
 294    std::vector<int>::iterator i2;
 295    i2 = v.end();
 296    std::iterator_traits<std::vector<int>::iterator>::difference_type d1;
 297    d1 = i2 - i1;
 298    if (d1 != 5)
 299       ++failures;
 300
 301    std::iterator_traits<std::vector<int>::iterator>::value_type v1;
 302    v1 = i1[0];
 303    if (v1 != 1)
 304       ++failures;
 305
 306    std::iterator_traits<std::vector<int>::iterator>::reference r1(i1[0]);
 307    if (r1 != 1)
 308       ++failures;
 309    r1 = 9;
 310    if (r1 != 9)
 311       ++failures;
 312    r1 = 1;
 313
 314    if ((i1 != i2) != true)
 315       ++failures;
 316    if ((i1 == i2) != false)
 317       ++failures;
 318    if ((i1 <  i2) != true)
 319       ++failures;
 320    if ((i1 >  i2) != false)
 321       ++failures;
 322    if ((i1 <= i2) != true)
 323       ++failures;
 324    if ((i1 >= i2) != false)
 325       ++failures;
 326
 327    std::vector<int>::iterator i3;
 328    i3 = i1;
 329    if ((i3 == i1) != true)
 330       ++failures;
 331
 332    i3 += 5;
 333    if ((i3 == i2) != true)
 334       ++failures;
 335
 336    i3 -= 5;
 337    if ((i3 == i1) != true)
 338       ++failures;
 339
 340    if (i3 + 5 != i2)
 341       ++failures;
 342
 343    if (5 + i3 != i2)
 344       ++failures;
 345
 346    if (i2 - 5 != i3)
 347       ++failures;
 348
 349    if (i1[0] != 1)
 350       ++failures;
 351
 352    i1[4] = 9;
 353    if (i2[-1] != 9)
 354       ++failures;
 355    i1[4] = 5;
 356
 357    i1[2] = 9;
 358    if (i2[-3] != 9)
 359       ++failures;
 360    i1[2] = 3;
 361
 362    std::vector<int>::const_iterator ci1(v.begin());
 363    if (*ci1 != 1)
 364       ++failures;
 365
 366    ++ci1;
 367    if (*ci1 != 2)
 368       ++failures;
 369
 370    if (*ci1++ != 2)
 371       ++failures;
 372    if (*ci1 != 3)
 373       ++failures;
 374
 375    ++ ++ci1;
 376    if (*ci1 != 5)
 377       ++failures;
 378
 379    --ci1;
 380    if (*ci1 != 4)
 381       ++failures;
 382
 383    if (*ci1-- != 4)
 384       ++failures;
 385    if (*ci1 != 3)
 386       ++failures;
 387
 388    -- --ci1;
 389    if (*ci1 != 1)
 390       ++failures;
 391
 392    std::vector<int>::const_iterator ci2;
 393    ci2 = v.end();
 394    std::iterator_traits<std::vector<int>::const_iterator>::difference_type d2;
 395    d2 = ci2 - ci1;
 396    if (d2 != 5)
 397       ++failures;
 398
 399    std::iterator_traits<std::vector<int>::const_iterator>::value_type v2;
 400    v2 = ci1[0];
 401    if (v2 != 1)
 402       ++failures;
 403
 404    std::iterator_traits<std::vector<int>::const_iterator>::reference
 405       r2(ci1[0]);
 406    if (r2 != 1)
 407       ++failures;
 408
 409    if ((ci1 != ci2) != true)
 410       ++failures;
 411    if ((ci1 == ci2) != false)
 412       ++failures;
 413    if ((ci1 <  ci2) != true)
 414       ++failures;
 415    if ((ci1 >  ci2) != false)
 416       ++failures;
 417    if ((ci1 <= ci2) != true)
 418       ++failures;
 419    if ((ci1 >= ci2) != false)
 420       ++failures;
 421
 422    std::vector<int>::const_iterator ci3;
 423    ci3 = ci1;
 424    if ((ci3 == ci1) != true)
 425       ++failures;
 426
 427    ci3 += 5;
 428    if ((ci3 == ci2) != true)
 429       ++failures;
 430
 431    ci3 -= 5;
 432    if ((ci3 == ci1) != true)
 433       ++failures;
 434
 435    if (ci3 + 5 != ci2)
 436       ++failures;
 437
 438    if (5 + ci3 != ci2)
 439       ++failures;
 440
 441    if (ci2 - 5 != ci3)
 442       ++failures;
 443
 444    if (ci1[2] != 3)
 445       ++failures;
 446
 447    if (ci2[-1] != 5)
 448       ++failures;
 449
 450    // iterator to const_iterator
 451    std::vector<int>::const_iterator ci4(i1);
 452    if ((ci4 == i1) != true)
 453       ++failures;
 454    if ((ci4 != i1) != false)
 455       ++failures;
 456    if ((ci4 < i1)  != false)
 457      ++failures;
 458    if ((ci4 > i1)  != false)
 459      ++failures;
 460    if ((ci4 <= i1) != true)
 461      ++failures;
 462    if ((ci4 >= i1) != true)
 463      ++failures;
 464    ci4 = i2;
 465    if ((i2 == ci4) != true)
 466      ++failures;
 467    if ((i2 < ci4)  != false)
 468      ++failures;
 469    if ((i2 > ci4)  != false)
 470      ++failures;
 471    if ((i2 <= ci4) != true)
 472      ++failures;
 473    if ((i2 >= ci4) != true)
 474      ++failures;
 475
 476    const std::vector<int> cv(v);
 477    std::vector<int>::const_iterator ci5(cv.begin());
 478    if (ci5[0] != 1)
 479       ++failures;
 480
 481    std::vector<std::string> vs;
 482    vs.push_back(std::string("abc"));
 483    std::vector<std::string>::iterator ivs(vs.begin());
 484    if (ivs->c_str()[1] != 'b')
 485       ++failures;
 486
 487    return failures;
 488 }
 489
 490 int
 491 reverse_stuff()
 492 {
 493    int failures(0);
 494
 495    std::string s("abcde");
 496
 497    std::string::reverse_iterator ri(s.rbegin());
 498    if (*ri != 'e')
 499       ++failures;
 500
 501    std::iterator_traits<std::string::reverse_iterator>::difference_type d;
 502    d = s.rend() - ri;
 503    if (d != 5)
 504       ++failures;
 505
 506    const std::string cs("abcde");
 507    std::string::const_reverse_iterator cri(cs.rend());
 508    if (cri - 5 != cs.rbegin())
 509       ++failures;
 510
 511    return failures;
 512 }
 513
 514 // the following should be compiler errors
 515 // flag runtime errors in case they slip through the compiler
 516 int
 517 wrong_stuff()
 518 {
 519    int failures(0);
 520
 521 #ifdef ITER24_F1
 522    extern void f(std::vector<std::string*>::iterator);
 523    std::vector<std::string*> vs[2];
 524    f(vs);                       // address of array is not an iterator
 525    failures++;
 526 #endif
 527
 528 #ifdef ITER24_F2
 529    std::string s;
 530    char *i = s.begin();         // begin() doesn't return a pointer
 531    failures++;
 532 #endif
 533
 534 #ifdef ITER24_F3
 535    std::string::const_iterator ci;
 536    std::string::iterator i;
 537    if (i - ci)                  // remove const_ is a warning
 538       i++;
 539    // failures++;  only a warning
 540 #endif
 541
 542 #ifdef ITER24_F4
 543    std::vector<char>::iterator iv;
 544    std::string::iterator is(iv);// vector<char> is not string
 545    failures++;
 546 #endif
 547
 548 #ifdef ITER24_F5
 549    std::vector<char>::iterator iv;
 550    std::string::iterator is;
 551    if (iv == is)                // vector<char> is not string
 552       ++iv;
 553    failures++;
 554 #endif
 555
 556 #ifdef ITER24_F6
 557    std::vector<char>::const_iterator ci;
 558    std::vector<char>::iterator i = ci;  // remove const_ is a warning
 559    ++i;
 560    // failures++; only a warning
 561 #endif
 562
 563 #ifdef ITER24_F7
 564    std::vector<int> v(1);
 565    std::vector<int>::const_iterator ci(v.begin());
 566    *ci = 1;                     // cannot assign through const_iterator
 567    failures++;
 568 #endif
 569
 570 #ifdef ITER24_F8
 571    std::vector<const int> v(1);
 572    std::vector<const int>::reference r(v.begin()[0]);
 573    r = 1;                       // cannot assign through reference to const
 574    failures++;
 575 #endif
 576
 577    return failures;
 578 }
 579
 580 // libstdc++/6642
 581 int
 582 test6642()
 583 {
 584    std::string s;
 585    std::string::iterator it = s.begin();
 586    std::string::const_iterator cit = s.begin();
 587
 588    return it - cit;
 589 }
 590
 591 int
 592 main()
 593 {
 594    int failures(0);
 595
 596    failures += string_stuff();
 597
 598    failures += vector_stuff();
 599
 600    failures += reverse_stuff();
 601
 602    failures += wrong_stuff();
 603
 604    failures += test6642();
 605
 606    VERIFY(failures == 0);
 607    return 0;
 608 }