Update Changelog
[profile/ivi/libgee.git] / 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