tests/testcollection.vala

   1 /* testcollection.vala
   2  *
   3  * Copyright (C) 2008  Jürg Billeter
   4  * Copyright (C) 2009  Didier Villevalois, Julien Peeters
   5  * Copyright (C) 2011-2012  Maciej Piechotka
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  20  *
  21  * Author:
  22  *      Jürg Billeter <j@bitron.ch>
  23  *      Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
  24  *      Julien Peeters <contact@julienpeeters.fr>
  25  *      Maciej Piechotka <uzytkownik2@gmail.com>
  26  */
  27
  28 using Gee;
  29
  30 public abstract class CollectionTests : Gee.TestCase {
  31
  32         public CollectionTests (string name) {
  33                 base (name);
  34                 add_test ("[Collection] type correctness", test_type_correctness);
  35                 add_test ("[Collection] iterator returns all elements once",
  36                           test_iterator_returns_all_elements_once);
  37                 add_test ("[Collection] mutable iterator", test_mutable_iterator);
  38                 add_test ("[Collection] contains, size and is_empty",
  39                           test_contains_size_and_is_empty);
  40                 add_test ("[Collection] add and remove", test_add_remove);
  41                 add_test ("[Collection] clear", test_clear);
  42                 add_test ("[Collection] add_all", test_add_all);
  43                 add_test ("[Collection] contains_all", test_contains_all);
  44                 add_test ("[Collection] remove_all", test_remove_all);
  45                 add_test ("[Collection] retain_all", test_retain_all);
  46                 add_test ("[Collection] to_array", test_to_array);
  47                 add_test ("[Collection] GObject properties", test_gobject_properties);
  48                 add_test ("[Collection] fold", test_fold);
  49                 add_test ("[Collection] foreach", test_foreach);
  50                 add_test ("[Collection] map", test_map);
  51                 add_test ("[Collection] scan", test_scan);
  52                 add_test ("[Collection] filter", test_filter);
  53                 add_test ("[Collection] chop", test_chop);
  54         }
  55
  56         protected Collection<string> test_collection;
  57
  58         public void test_type_correctness () {
  59                 // Check the collection exists
  60                 assert (test_collection != null);
  61
  62                 // Check the advertised element type
  63                 assert (test_collection.element_type == typeof (string));
  64         }
  65
  66         public void test_iterator_returns_all_elements_once () {
  67                 // Check the collection exists
  68                 assert (test_collection != null);
  69                 bool has_next;
  70
  71                 // Check with an empty collection
  72                 Iterator<string> iterator = test_collection.iterator ();
  73                 assert (! iterator.has_next ());
  74                 assert (! iterator.next ());
  75
  76                 unowned string[] data = TestData.get_data ();
  77
  78                 // Check for some elements in the collection
  79                 foreach (unowned string el in data) {
  80                         assert (test_collection.add (el));
  81                 }
  82
  83                 uint[] found_times = new uint[data.length];
  84                 for (uint i = 0; i < 2; i++) {
  85                         for (uint j = 0; j < found_times.length; j++) {
  86                                 found_times[j] = 0;
  87                         }
  88                         iterator = test_collection.iterator ();
  89                         bool valid = iterator.valid;
  90                         assert (! valid);
  91                         while (true) {
  92                                 has_next = iterator.has_next ();
  93                                 assert (valid == iterator.valid);
  94                                 assert (has_next == iterator.next ());
  95                                 assert (valid = iterator.valid);
  96                                 if (! has_next) {
  97                                         break;
  98                                 }
  99
 100                                 string element = iterator.get ();
 101                                 assert (iterator.valid);
 102                                 for (uint element_idx = 0;; element_idx++) {
 103                                         assert (element_idx < data.length);
 104                                         if (data[element_idx] == element) {
 105                                                 found_times[element_idx]++;
 106                                                 break;
 107                                         }
 108                                 }
 109                         }
 110                         has_next = iterator.has_next ();
 111                         assert (! has_next);
 112                         assert (iterator.valid);
 113                         assert (has_next == iterator.next ());
 114                         assert (iterator.valid);
 115                         foreach (var ft in found_times) {
 116                                 assert (ft == 1);
 117                         }
 118                 }
 119         }
 120
 121         public void test_mutable_iterator () {
 122                 // Check the collection exists
 123                 assert (test_collection != null);
 124                 bool has_next;
 125
 126                 // Check with an empty collection
 127                 Iterator<string> iterator = test_collection.iterator ();
 128                 // ...
 129
 130                 unowned string[] data = TestData.get_data ();
 131                 unowned uint[] idx = TestData.get_drawn_numbers ();
 132
 133                 // Check for some elements in the collection and remove few
 134                 foreach (unowned string el in data) {
 135                         assert (test_collection.add (el));
 136                 }
 137
 138                 iterator = test_collection.iterator ();
 139                 uint[] found_times = new uint[data.length];
 140                 for (uint i = 0; i <= idx.length; i++) {
 141                         for (uint j = 0; j < found_times.length; j++) {
 142                                 found_times[j] = 0;
 143                         }
 144                         iterator = test_collection.iterator ();
 145                         assert (! iterator.valid);
 146                         bool last_removed = false;
 147                         while (true) {
 148                                 has_next = iterator.has_next ();
 149                                 assert (has_next == iterator.next ());
 150                                 if (! has_next) {
 151                                         break;
 152                                 }
 153
 154                                 string element = iterator.get ();
 155                                 assert (iterator.valid);
 156                                 for (uint element_idx = 0;; element_idx++) {
 157                                         assert (element_idx < data.length);
 158                                         if (data[element_idx] == element) {
 159                                                 if (i != idx.length && data[element_idx] == data[idx[i]]) {
 160                                                         iterator.remove ();
 161                                                         assert (! iterator.valid);
 162                                                         last_removed = true;
 163                                                 } else {
 164                                                         last_removed = false;
 165                                                 }
 166                                                 found_times[element_idx]++;
 167                                                 break;
 168                                         }
 169                                 }
 170                         }
 171                         has_next = iterator.has_next ();
 172                         assert (! has_next);
 173                         assert (iterator.valid == !last_removed);
 174                         assert (has_next == iterator.next ());
 175                         assert (iterator.valid == !last_removed);
 176                         for (uint j = 0; j < found_times.length; j++) {
 177                                 bool removed = false;
 178                                 for (int k = 0; k < i; k++) {
 179                                         if (idx[k] == j) {
 180                                                 removed = true;
 181                                                 break;
 182                                         }
 183                                 }
 184                                 assert (found_times[j] == (removed ? 0 : 1));
 185                         }
 186                 }
 187         }
 188
 189         public void test_contains_size_and_is_empty () {
 190                 // Check the collection exists
 191                 assert (test_collection != null);
 192
 193                 unowned string[] data = TestData.get_data ();
 194                 unowned uint[] idx = TestData.get_drawn_numbers ();
 195
 196                 // Check the collection is initially empty
 197                 foreach (unowned string s in data) {
 198                         assert (! test_collection.contains (s));
 199                 }
 200                 assert (test_collection.size == 0);
 201                 assert (test_collection.is_empty);
 202
 203                 // Add an element
 204                 assert (test_collection.add (data[0]));
 205                 assert (test_collection.contains (data[0]));
 206                 for (uint i = 1; i < data.length; i++) {
 207                         assert (! test_collection.contains (data[i]));
 208                 }
 209                 assert (test_collection.size == 1);
 210                 assert (! test_collection.is_empty);
 211
 212                 // Remove the added element
 213                 assert (test_collection.remove ("one"));
 214                 foreach (unowned string s in data) {
 215                         assert (! test_collection.contains (s));
 216                 }
 217                 assert (test_collection.size == 0);
 218                 assert (test_collection.is_empty);
 219
 220                 // Add more elements
 221                 for (uint i = 0; i < data.length; i++) {
 222                         assert (test_collection.add (data[i]));
 223                         for (uint j = 0; j <= i; j++) {
 224                                 assert (test_collection.contains (data[j]));
 225                         }
 226                         for (uint j = i + 1; j < data.length; j++) {
 227                                 assert (! test_collection.contains (data[j]));
 228                         }
 229                         assert (test_collection.size == i + 1);
 230                         assert (! test_collection.is_empty);
 231                 }
 232                 for (uint i = 0; i < idx.length; i++) {
 233                         // Remove one element
 234                         assert (test_collection.remove (data[idx[i]]));
 235                         for (uint j = 0; j < data.length; j++) {
 236                                 bool removed = false;
 237                                 for (uint k = 0; k <= i; k++) {
 238                                         if (idx[k] == j) {
 239                                                 removed = true;
 240                                                 break;
 241                                         }
 242                                 }
 243                                 assert (test_collection.contains (data[j]) == !removed);
 244                         }
 245                         assert (test_collection.size == data.length - (i + 1));
 246
 247                         // Remove the same element again
 248                         assert (! test_collection.remove (data[idx[i]]));
 249                         for (uint j = 0; j < data.length; j++) {
 250                                 bool removed = false;
 251                                 for (uint k = 0; k <= i; k++) {
 252                                         if (idx[k] == j) {
 253                                                 removed = true;
 254                                                 break;
 255                                         }
 256                                 }
 257                                 assert (test_collection.contains (data[j]) == !removed);
 258                         }
 259                         assert (test_collection.size == data.length - (i + 1));
 260                 }
 261
 262                 // Remove all elements
 263                 test_collection.clear ();
 264                 foreach (unowned string el in data) {
 265                         assert (! test_collection.contains (el));
 266                 }
 267                 assert (test_collection.size == 0);
 268                 assert (test_collection.is_empty);
 269         }
 270
 271         public void test_add_remove () {
 272                 // Check the collection exists
 273                 assert (test_collection != null);
 274
 275                 unowned string[] to_add = TestData.get_data ();
 276                 var expected_size = 0;
 277
 278                 foreach (var a in to_add) {
 279                         assert (!test_collection.contains (a));
 280                         assert (test_collection.size == expected_size++);
 281                         assert (test_collection.add (a));
 282                         assert (test_collection.contains (a));
 283                 }
 284                 assert (test_collection.size == to_add.length);
 285
 286                 foreach (var a in to_add) {
 287                         assert (test_collection.contains (a));
 288                 }
 289
 290                 foreach (var a in to_add) {
 291                         assert (test_collection.contains (a));
 292                         assert (test_collection.size == expected_size--);
 293                         assert (test_collection.remove (a));
 294                         assert (!test_collection.contains (a));
 295                 }
 296                 assert (test_collection.size == 0);
 297         }
 298
 299         public void test_clear () {
 300                 // Check the collection exists
 301                 assert (test_collection != null);
 302
 303                 unowned string[] to_add = TestData.get_data ();
 304                 var expected_size = 0;
 305
 306                 foreach (var a in to_add) {
 307                         assert (!test_collection.contains (a));
 308                         assert (test_collection.size == expected_size++);
 309                         assert (test_collection.add (a));
 310                         assert (test_collection.contains (a));
 311                 }
 312                 assert (test_collection.size == to_add.length);
 313
 314                 test_collection.clear ();
 315
 316                 assert (test_collection.size == 0);
 317
 318                 Iterator<string> iter = test_collection.iterator ();
 319                 assert (iter != null);
 320                 assert (!iter.has_next ());
 321
 322         }
 323
 324         public void test_add_all () {
 325                 // Check the collection exists
 326                 assert (test_collection != null);
 327
 328                 // Creating a dummy collection
 329                 var dummy = new ArrayList<string> ();
 330
 331                 // Check when the test collection is initially empty and
 332                 // dummy collection is empty
 333                 assert (! test_collection.add_all (dummy));
 334
 335                 assert (test_collection.is_empty);
 336                 assert (dummy.is_empty);
 337
 338                 // Check when test collection is not empty but dummy is
 339                 assert (test_collection.add ("hello"));
 340                 assert (! test_collection.add_all (dummy));
 341
 342                 assert (test_collection.size == 1);
 343                 assert (test_collection.contains ("hello"));
 344
 345                 test_collection.clear ();
 346                 dummy.clear ();
 347
 348                 // Check when the test collection is initially empty and
 349                 // dummy collection is not empty
 350                 assert (dummy.add ("hello1"));
 351                 assert (dummy.add ("hello2"));
 352                 assert (dummy.add ("hello3"));
 353
 354                 assert (test_collection.add_all (dummy));
 355
 356                 assert (test_collection.size == 3);
 357                 assert (test_collection.contains ("hello1"));
 358                 assert (test_collection.contains ("hello2"));
 359                 assert (test_collection.contains ("hello3"));
 360                 assert (dummy.size == 3);
 361                 assert (dummy.contains ("hello1"));
 362                 assert (dummy.contains ("hello2"));
 363                 assert (dummy.contains ("hello3"));
 364
 365                 test_collection.clear ();
 366                 dummy.clear ();
 367
 368                 // Check when the test collection is not empty and both
 369                 // collections does not intersect
 370                 assert (dummy.add ("hello1"));
 371                 assert (dummy.add ("hello2"));
 372                 assert (dummy.add ("hello3"));
 373
 374                 assert (test_collection.add ("hello"));
 375
 376                 assert (test_collection.add_all (dummy));
 377
 378                 assert (test_collection.size == 4);
 379                 assert (test_collection.contains ("hello"));
 380                 assert (test_collection.contains ("hello1"));
 381                 assert (test_collection.contains ("hello2"));
 382                 assert (test_collection.contains ("hello3"));
 383                 assert (dummy.size == 3);
 384                 assert (dummy.contains ("hello1"));
 385                 assert (dummy.contains ("hello2"));
 386                 assert (dummy.contains ("hello3"));
 387
 388                 test_collection.clear ();
 389                 dummy.clear ();
 390
 391                 // Check when the test collection is not empty and both
 392                 // collection intersect
 393                 assert (dummy.add ("hello1"));
 394                 assert (dummy.add ("hello2"));
 395                 assert (dummy.add ("hello3"));
 396
 397                 assert (test_collection.add ("hello1"));
 398
 399                 assert (test_collection.add_all (dummy));
 400
 401                 // We can only assert the result is greater or equal than 3
 402                 // as we do not assume duplicates
 403                 assert (test_collection.size >= 3);
 404                 assert (test_collection.contains ("hello1"));
 405                 assert (test_collection.contains ("hello2"));
 406                 assert (test_collection.contains ("hello3"));
 407                 assert (dummy.size == 3);
 408                 assert (dummy.contains ("hello1"));
 409                 assert (dummy.contains ("hello2"));
 410                 assert (dummy.contains ("hello3"));
 411         }
 412
 413         public void test_contains_all () {
 414                 // Check the collection exists
 415                 assert (test_collection != null);
 416
 417                 // Creating a dummy collection
 418                 var dummy = new ArrayList<string> ();
 419                 assert (dummy.add ("hello1"));
 420                 assert (dummy.add ("hello2"));
 421                 assert (dummy.add ("hello3"));
 422
 423                 // Check when the test collection is initially empty
 424                 assert (test_collection.is_empty);
 425                 assert (! test_collection.contains_all (dummy));
 426
 427                 // Check when the test collection is not empty and both
 428                 // collections does not intersect
 429                 assert (test_collection.add ("hello4"));
 430                 assert (test_collection.add ("hello5"));
 431                 assert (! test_collection.contains_all (dummy));
 432
 433                 // Check when the test collection is not empty and both
 434                 // collections intersect but are not equal
 435                 assert (test_collection.add ("hello1"));
 436                 assert (test_collection.add ("hello2"));
 437                 assert (! test_collection.contains_all (dummy));
 438
 439                 // Check when the test collection is not empty and the
 440                 // dummy collection is contained in the test one
 441                 assert (test_collection.add ("hello3"));
 442                 assert (test_collection.contains_all (dummy));
 443                 assert (! dummy.contains_all (test_collection));
 444         }
 445
 446         public void test_remove_all () {
 447                 // Check the collection exists
 448                 assert (test_collection != null);
 449
 450                 // Creating a dummy collection
 451                 var dummy = new ArrayList<string> ();
 452
 453                 // Check when both collection are intially empty
 454                 assert (! test_collection.remove_all (dummy));
 455
 456                 assert (test_collection.is_empty);
 457                 assert (dummy.is_empty);
 458
 459                 // Check when the test collection is initially empty and
 460                 // dummy collection is not empty
 461                 assert (dummy.add ("hello1"));
 462                 assert (dummy.add ("hello2"));
 463                 assert (dummy.add ("hello3"));
 464
 465                 assert (! test_collection.remove_all (dummy));
 466
 467                 assert (test_collection.is_empty);
 468
 469                 test_collection.clear ();
 470                 dummy.clear ();
 471
 472                 // Check when the test collection is not empty and both
 473                 // collections does not intersect
 474                 assert (dummy.add ("hello1"));
 475                 assert (dummy.add ("hello2"));
 476                 assert (dummy.add ("hello3"));
 477                 assert (test_collection.add ("hello4"));
 478                 assert (test_collection.add ("hello5"));
 479
 480                 assert (! test_collection.remove_all (dummy));
 481
 482                 assert (test_collection.size == 2);
 483                 assert (dummy.size == 3);
 484
 485                 test_collection.clear ();
 486                 dummy.clear ();
 487
 488                 // Check when the test collection is not empty and both
 489                 // collections intersect
 490                 assert (dummy.add ("hello1"));
 491                 assert (dummy.add ("hello2"));
 492                 assert (dummy.add ("hello3"));
 493                 assert (test_collection.add ("hello1"));
 494                 assert (test_collection.add ("hello2"));
 495                 assert (test_collection.add ("hello3"));
 496
 497                 assert (test_collection.remove_all (dummy));
 498
 499                 assert (test_collection.is_empty);
 500                 assert (dummy.size == 3);
 501
 502                 test_collection.clear ();
 503                 dummy.clear ();
 504         }
 505
 506         public void test_retain_all () {
 507                 // Check the collection exists
 508                 assert (test_collection != null);
 509
 510                 // Creating a dummy collection
 511                 var dummy = new ArrayList<string> ();
 512
 513                 // Check when the test collection is initially empty and
 514                 // dummy collection is empty
 515                 assert (! test_collection.retain_all (dummy));
 516
 517                 assert (test_collection.is_empty);
 518                 assert (dummy.is_empty);
 519
 520                 // Check when the test collection is not empty and
 521                 // the dummy one is
 522                 assert (test_collection.add ("hello1"));
 523                 assert (test_collection.add ("hello2"));
 524
 525                 assert (test_collection.retain_all (dummy));
 526
 527                 assert (test_collection.is_empty);
 528                 assert (dummy.is_empty);
 529
 530                 test_collection.clear ();
 531                 dummy.clear ();
 532
 533                 // Check when the test collection is initially empty and
 534                 // dummy collection is not empty
 535                 assert (dummy.add ("hello1"));
 536                 assert (dummy.add ("hello2"));
 537                 assert (dummy.add ("hello3"));
 538
 539                 assert (! test_collection.retain_all (dummy));
 540
 541                 assert (test_collection.is_empty);
 542                 assert (dummy.size == 3);
 543                 assert (dummy.contains ("hello1"));
 544                 assert (dummy.contains ("hello2"));
 545                 assert (dummy.contains ("hello3"));
 546
 547                 test_collection.clear ();
 548                 dummy.clear ();
 549
 550                 // Check when the test collection is not empty and both
 551                 // collection does not intersect
 552                 assert (dummy.add ("hello1"));
 553                 assert (dummy.add ("hello2"));
 554                 assert (dummy.add ("hello3"));
 555                 assert (test_collection.add ("hello4"));
 556                 assert (test_collection.add ("hello5"));
 557
 558                 assert (test_collection.retain_all (dummy));
 559
 560                 assert (test_collection.is_empty);
 561                 assert (dummy.size == 3);
 562                 assert (dummy.contains ("hello1"));
 563                 assert (dummy.contains ("hello2"));
 564                 assert (dummy.contains ("hello3"));
 565
 566                 test_collection.clear ();
 567                 dummy.clear ();
 568
 569                 // Check when both collections have the same elements
 570                 assert (dummy.add ("hello1"));
 571                 assert (dummy.add ("hello2"));
 572                 assert (dummy.add ("hello3"));
 573                 assert (test_collection.add ("hello1"));
 574                 assert (test_collection.add ("hello2"));
 575                 assert (test_collection.add ("hello3"));
 576
 577                 assert (! test_collection.retain_all (dummy));
 578
 579                 assert (test_collection.size == 3);
 580                 assert (test_collection.contains ("hello1"));
 581                 assert (test_collection.contains ("hello2"));
 582                 assert (test_collection.contains ("hello3"));
 583                 assert (dummy.size == 3);
 584                 assert (dummy.contains ("hello1"));
 585                 assert (dummy.contains ("hello2"));
 586                 assert (dummy.contains ("hello3"));
 587
 588                 test_collection.clear ();
 589                 dummy.clear ();
 590
 591                 // Check when the test collection is not empty and both
 592                 // collections intersect but are not equal
 593                 assert (dummy.add ("hello1"));
 594                 assert (dummy.add ("hello2"));
 595                 assert (dummy.add ("hello3"));
 596                 assert (test_collection.add ("hello2"));
 597                 assert (test_collection.add ("hello3"));
 598                 assert (test_collection.add ("hello4"));
 599
 600                 assert (test_collection.retain_all (dummy));
 601
 602                 assert (test_collection.size == 2);
 603                 assert (test_collection.contains ("hello2"));
 604                 assert (test_collection.contains ("hello3"));
 605                 assert (dummy.size == 3);
 606                 assert (dummy.contains ("hello1"));
 607                 assert (dummy.contains ("hello2"));
 608                 assert (dummy.contains ("hello3"));
 609
 610                 test_collection.clear ();
 611                 dummy.clear ();
 612         }
 613
 614         public void test_to_array () {
 615                 // Check the collection exists
 616                 assert (test_collection != null);
 617
 618                 // Check the collection is empty
 619                 assert (test_collection.is_empty);
 620
 621                 // Add some elements
 622                 assert (test_collection.add ("hello1"));
 623                 assert (test_collection.add ("hello2"));
 624                 assert (test_collection.add ("hello3"));
 625
 626                 // Check the conversion to array
 627                 string[] array = (string[]) test_collection.to_array ();
 628                 int index = 0;
 629                 foreach (string element in test_collection) {
 630                         assert (element == array[index++]);
 631                 }
 632         }
 633
 634         public void test_gobject_properties () {
 635                 // Check the collection exists
 636                 assert (test_collection != null);
 637                 Value value;
 638
 639                 value = Value (typeof (int));
 640                 test_collection.get_property ("size", ref value);
 641                 assert (value.get_int () == test_collection.size);
 642                 value.unset ();
 643         }
 644
 645         public void test_fold () {
 646                 assert (test_collection.add ("one"));
 647                 assert (test_collection.add ("two"));
 648                 assert (test_collection.add ("three"));
 649
 650                 int count;
 651
 652                 count = test_collection.fold<int> ((x, y) => {return y + 1;}, 0);
 653                 assert (count == 3);
 654
 655                 count = test_collection.iterator ().fold<int> ((x, y) => {return y + 1;}, 0);
 656                 assert (count == 3);
 657
 658                 Iterator<string> iter = test_collection.iterator ();
 659                 assert (iter.next ());
 660                 count = iter.fold<int> ((x, y) => {return y + 1;}, 0);
 661                 assert (count == 3);
 662         }
 663
 664         public void test_foreach () {
 665                 assert (test_collection.add ("one"));
 666                 assert (test_collection.add ("two"));
 667                 assert (test_collection.add ("three"));
 668
 669                 int count = 0;
 670
 671                 test_collection.foreach ((x) => {count++; return true;});
 672                 assert (count == 3);
 673
 674                 test_collection.iterator ().foreach ((x) => {count++; return true;});
 675                 assert (count == 6);
 676
 677                 Iterator<string> iter = test_collection.iterator ();
 678                 assert (iter.next ());
 679                 iter.foreach ((x) => {count++; return true;});
 680                 assert (count == 9);
 681         }
 682
 683         public void test_map () {
 684                 assert (test_collection.add ("one"));
 685                 assert (test_collection.add ("two"));
 686                 assert (test_collection.add ("three"));
 687
 688                 bool one = false;
 689                 bool two = false;
 690                 bool three = false;
 691
 692                 int i = 0;
 693                 var iter = test_collection.iterator().map<int> ((str) => {
 694                         if (str == "one") {
 695                                 assert (!one);
 696                                 one = true;
 697                         } else if (str == "two") {
 698                                 assert (!two);
 699                                 two = true;
 700                         } else if (str == "three") {
 701                                 assert (!three);
 702                                 three = true;
 703                         } else {
 704                                 assert_not_reached ();
 705                         }
 706                         return i++;
 707                 });
 708                 int j = 0;
 709                 while (iter.next ()) {
 710                         assert (i == j);
 711                         assert (j == iter.get ());
 712                         assert (j == iter.get ());
 713                         j++;
 714                         assert (i == j);
 715                 }
 716
 717                 assert (i == j);
 718                 assert (i == test_collection.size);
 719                 assert (one);
 720                 assert (two);
 721                 assert (three);
 722
 723                 one = two = three = false;
 724                 i = j = 0;
 725
 726                 iter = test_collection.map<int> ((str) => {
 727                         if (str == "one") {
 728                                 assert (!one);
 729                                 one = true;
 730                         } else if (str == "two") {
 731                                 assert (!two);
 732                                 two = true;
 733                         } else if (str == "three") {
 734                                 assert (!three);
 735                                 three = true;
 736                         } else {
 737                                 assert_not_reached ();
 738                         }
 739                         return i++;
 740                 });
 741                 while (iter.next ()) {
 742                         assert (i == j);
 743                         assert (j == iter.get ());
 744                         assert (j == iter.get ());
 745                         j++;
 746                         assert (i == j);
 747                 }
 748
 749                 assert (i == j);
 750                 assert (i == test_collection.size);
 751                 assert (one);
 752                 assert (two);
 753                 assert (three);
 754         }
 755
 756         public void test_scan () {
 757                 assert (test_collection.add ("one"));
 758                 assert (test_collection.add ("two"));
 759                 assert (test_collection.add ("three"));
 760
 761                 bool one = false;
 762                 bool two = false;
 763                 bool three = false;
 764
 765                 var iter = test_collection.iterator().scan<int> ((str, cur) => {
 766                         if (str == "one") {
 767                                 assert (!one);
 768                                 one = true;
 769                         } else if (str == "two") {
 770                                 assert (!two);
 771                                 two = true;
 772                         } else if (str == "three") {
 773                                 assert (!three);
 774                                 three = true;
 775                         } else {
 776                                 assert_not_reached ();
 777                         }
 778                         return cur + 1;
 779                 }, 0);
 780
 781                 int j = 0;
 782                 do {
 783                         assert (j == iter.get ());
 784                         assert (j == iter.get ());
 785                         j++;
 786                 } while (iter.next ());
 787
 788                 assert (j == test_collection.size + 1);
 789                 assert (one);
 790                 assert (two);
 791                 assert (three);
 792
 793                 one = two = three = false;
 794                 j = 0;
 795
 796                 iter = test_collection.scan<int> ((str, cur) => {
 797                         if (str == "one") {
 798                                 assert (!one);
 799                                 one = true;
 800                         } else if (str == "two") {
 801                                 assert (!two);
 802                                 two = true;
 803                         } else if (str == "three") {
 804                                 assert (!three);
 805                                 three = true;
 806                         } else {
 807                                 assert_not_reached ();
 808                         }
 809                         return cur + 1;
 810                 }, 0);
 811
 812                 do {
 813                         assert (j == iter.get ());
 814                         assert (j == iter.get ());
 815                         j++;
 816                 } while (iter.next ());
 817
 818                 assert (j == test_collection.size + 1);
 819                 assert (one);
 820                 assert (two);
 821                 assert (three);
 822         }
 823
 824         public void test_filter () {
 825                 assert (test_collection.add ("one"));
 826                 assert (test_collection.add ("two"));
 827                 assert (test_collection.add ("three"));
 828
 829                 bool one = false;
 830                 bool two = false;
 831                 bool three = false;
 832
 833                 var iter = test_collection.iterator().filter ((str) => {
 834                         if (str == "one") {
 835                                 assert (!one);
 836                                 one = true;
 837                         } else if (str == "two") {
 838                                 assert (!two);
 839                                 two = true;
 840                         } else if (str == "three") {
 841                                 assert (!three);
 842                                 three = true;
 843                         } else {
 844                                 assert_not_reached ();
 845                         }
 846                         return str != "two";
 847                 });
 848
 849                 assert (!iter.valid);
 850
 851                 int j = 0;
 852                 while (iter.next ()) {
 853                         assert(iter.get () != "two");
 854                         j++;
 855                 }
 856                 assert (j == 2);
 857                 assert (one);
 858                 assert (two);
 859                 assert (three);
 860
 861                 one = two = three = false;
 862                 j = 0;
 863
 864                 iter = test_collection.filter ((str) => {
 865                         if (str == "one") {
 866                                 assert (!one);
 867                                 one = true;
 868                         } else if (str == "two") {
 869                                 assert (!two);
 870                                 two = true;
 871                         } else if (str == "three") {
 872                                 assert (!three);
 873                                 three = true;
 874                         } else {
 875                                 assert_not_reached ();
 876                         }
 877                         return str != "two";
 878                 });
 879
 880                 assert (!iter.valid);
 881
 882                 while (iter.next ()) {
 883                         assert(iter.get () != "two");
 884                         j++;
 885                 }
 886                 assert (j == 2);
 887                 assert (one);
 888                 assert (two);
 889                 assert (three);
 890         }
 891
 892         public void test_chop () {
 893                 assert (test_collection.add ("one"));
 894                 assert (test_collection.add ("two"));
 895                 assert (test_collection.add ("three"));
 896
 897                 var iter = test_collection.iterator().chop (1, 1);
 898                 assert (!iter.valid);
 899                 var iter2 = test_collection.iterator();
 900
 901                 assert (iter2.next ());
 902                 assert (iter2.next ());
 903                 assert (iter.next ());
 904                 assert (iter2.get () == iter.get ());
 905                 assert (!iter.next ());
 906                 assert (iter2.next ());
 907
 908                 iter = test_collection.chop (1, 1);
 909                 assert (!iter.valid);
 910                 iter2 = test_collection.iterator();
 911
 912                 assert (iter2.next ());
 913                 assert (iter2.next ());
 914                 assert (iter.next ());
 915                 assert (iter2.get () == iter.get ());
 916                 assert (!iter.next ());
 917                 assert (iter2.next ());
 918         }
 919 }
 920