Update Changelog
[profile/ivi/libgee.git] / tests / testmap.vala
1 /* testmap.vala
2  *
3  * Copyright (C) 2008  Jürg Billeter
4  * Copyright (C) 2009  Didier Villevalois, Julien Peeters, Maciej Piechotka
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10
11  * This library 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 GNU
14  * Lesser General Public License for more details.
15
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
19  *
20  * Author:
21  *      Jürg Billeter <j@bitron.ch>
22  *      Maciej Piechotka <uzytkownik2@gmail.com>
23  *      Julien Peeters <contact@julienpeeters.fr>
24  */
25
26 using Gee;
27
28 public abstract class MapTests : Gee.TestCase {
29
30         public MapTests (string name) {
31                 base (name);
32                 add_test ("[Map] type correctness", test_type_correctness);
33                 add_test ("[Map] has_key, size and is_empty",
34                           test_has_key_size_is_empty);
35                 add_test ("[Map] keys", test_keys);
36                 add_test ("[Map] values", test_values);
37                 add_test ("[Map] entries", test_entries);
38                 add_test ("[Map] set all", test_set_all);
39                 add_test ("[Map] unset all", test_unset_all);
40                 add_test ("[Map] has all", test_has_all);
41                 add_test ("[Map] GObject properties", test_gobject_properties);
42                 add_test ("[Map] fold", test_fold);
43                 add_test ("[Map] foreach", test_foreach);
44         }
45
46         protected Map<string, string> test_map;
47
48         public void test_type_correctness () {
49                 // Check the map exists
50                 assert (test_map != null);
51
52                 // Check the advertised key and value types
53                 assert (test_map.key_type == typeof (string));
54                 assert (test_map.value_type == typeof (string));
55         }
56
57         public void test_has_key_size_is_empty () {
58                 // Check the collection exists
59                 assert (test_map != null);
60                 string value;
61
62                 // Check the collection is initially empty
63                 assert (! test_map.has_key ("one"));
64                 assert (! test_map.has_key ("two"));
65                 assert (! test_map.has_key ("three"));
66                 assert (test_map.size == 0);
67                 assert (test_map.is_empty);
68
69                 // Add a binding
70                 test_map.set ("one", "value_of_one");
71                 assert (test_map.has_key ("one"));
72                 assert (test_map.has ("one", "value_of_one"));
73                 assert (! test_map.has ("one", "another_value_for_one"));
74                 assert (test_map.get ("one") == "value_of_one");
75                 assert (! test_map.has_key ("two"));
76                 assert (test_map.get ("two") == null);
77                 assert (! test_map.has_key ("three"));
78                 assert (test_map.get ("three") == null);
79                 assert (test_map.size == 1);
80                 assert (! test_map.is_empty);
81
82                 // Remove the last added binding
83                 assert (test_map.unset ("one"));
84                 assert (! test_map.has_key ("one"));
85                 assert (! test_map.has ("one", "value_of_one"));
86                 assert (! test_map.has ("one", "another_value_for_one"));
87                 assert (test_map.get ("one") == null);
88                 assert (! test_map.has_key ("two"));
89                 assert (test_map.get ("two") ==  null);
90                 assert (! test_map.has_key ("three"));
91                 assert (test_map.get ("three") == null);
92                 assert (test_map.size == 0);
93                 assert (test_map.is_empty);
94
95                 // Add more bindings
96                 test_map.set ("one", "value_of_one");
97                 assert (test_map.has_key ("one"));
98                 assert (test_map.get ("one") == "value_of_one");
99                 assert (! test_map.has_key ("two"));
100                 assert (test_map.get ("two") == null);
101                 assert (! test_map.has_key ("three"));
102                 assert (test_map.get ("three") == null);
103                 assert (test_map.size == 1);
104                 assert (! test_map.is_empty);
105
106                 test_map.set ("two", "value_of_two");
107                 assert (test_map.has_key ("one"));
108                 assert (test_map.get ("one") == "value_of_one");
109                 assert (test_map.has_key ("two"));
110                 assert (test_map.get ("two") == "value_of_two");
111                 assert (! test_map.has_key ("three"));
112                 assert (test_map.get ("three") == null);
113                 assert (test_map.size == 2);
114                 assert (! test_map.is_empty);
115
116                 test_map.set ("three", "value_of_three");
117                 assert (test_map.has_key ("one"));
118                 assert (test_map.get ("one") == "value_of_one");
119                 assert (test_map.has_key ("two"));
120                 assert (test_map.get ("two") == "value_of_two");
121                 assert (test_map.has_key ("three"));
122                 assert (test_map.get ("three") == "value_of_three");
123                 assert (test_map.size == 3);
124                 assert (! test_map.is_empty);
125
126                 // Update an existent binding
127                 test_map.set ("two", "value_of_two_new");
128                 assert (test_map.has_key ("one"));
129                 assert (test_map.get ("one") == "value_of_one");
130                 assert (test_map.has_key ("two"));
131                 assert (test_map.get ("two") == "value_of_two_new");
132                 assert (test_map.has_key ("three"));
133                 assert (test_map.get ("three") == "value_of_three");
134                 assert (test_map.size == 3);
135                 assert (! test_map.is_empty);
136
137                 // Remove one element
138                 assert (test_map.unset ("two", out value));
139                 assert (value == "value_of_two_new");
140                 assert (test_map.has_key ("one"));
141                 assert (test_map.get ("one") == "value_of_one");
142                 assert (! test_map.has_key ("two"));
143                 assert (test_map.get ("two") == null);
144                 assert (test_map.has_key ("three"));
145                 assert (test_map.get ("three") == "value_of_three");
146                 assert (test_map.size == 2);
147                 assert (! test_map.is_empty);
148
149                 // Remove the same element again
150                 assert (! test_map.unset ("two", out value));
151                 assert (value == null);
152                 assert (test_map.has_key ("one"));
153                 assert (! test_map.has_key ("two"));
154                 assert (test_map.has_key ("three"));
155                 assert (test_map.size == 2);
156                 assert (! test_map.is_empty);
157
158                 // Remove all elements
159                 test_map.clear ();
160                 assert (! test_map.has_key ("one"));
161                 assert (test_map.get ("one") == null);
162                 assert (! test_map.has_key ("two"));
163                 assert (test_map.get ("two") == null);
164                 assert (! test_map.has_key ("three"));
165                 assert (test_map.get ("three") == null);
166                 assert (test_map.size == 0);
167                 assert (test_map.is_empty);
168         }
169
170         public void test_keys () {
171                 // Check keys on empty map
172                 var keys = test_map.keys;
173                 assert (keys.size == 0);
174
175                 // Check keys on map with one item
176                 test_map.set ("one", "value_of_one");
177                 assert (keys.size == 1);
178                 assert (keys.contains ("one"));
179                 keys = test_map.keys;
180                 assert (keys.size == 1);
181                 assert (keys.contains ("one"));
182
183                 // Check modify key set directly
184                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
185                                        TestTrapFlags.SILENCE_STDERR)) {
186                         assert (! keys.add ("three"));
187                         Posix.exit (0);
188                 }
189                 Test.trap_assert_failed ();
190                 Test.trap_assert_stderr ("*code should not be reached*");
191
192                 // Check keys on map with multiple items
193                 test_map.set ("two", "value_of_two");
194                 assert (keys.size == 2);
195                 assert (keys.contains ("one"));
196                 assert (keys.contains ("two"));
197                 keys = test_map.keys;
198                 assert (keys.size == 2);
199                 assert (keys.contains ("one"));
200                 assert (keys.contains ("two"));
201
202                 // Check keys on map clear
203                 test_map.clear ();
204                 assert (keys.size == 0);
205                 keys = test_map.keys;
206                 assert (keys.size == 0);
207         }
208
209         public void test_values () {
210                 // Check keys on empty map
211                 var values = test_map.values;
212                 assert (values.size == 0);
213
214                 // Check keys on map with one item
215                 test_map.set ("one", "value_of_one");
216                 assert (values.size == 1);
217                 assert (values.contains ("value_of_one"));
218                 values = test_map.values;
219                 assert (values.size == 1);
220                 assert (values.contains ("value_of_one"));
221
222                 // Check modify key set directly
223                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
224                                        TestTrapFlags.SILENCE_STDERR)) {
225                         assert (! values.add ("two"));
226                         Posix.exit (0);
227                 }
228                 Test.trap_assert_failed ();
229                 Test.trap_assert_stderr ("*code should not be reached*");
230
231                 // Check keys on map with multiple items
232                 test_map.set ("two", "value_of_two");
233                 assert (values.size == 2);
234                 assert (values.contains ("value_of_one"));
235                 assert (values.contains ("value_of_two"));
236                 values = test_map.values;
237                 assert (values.size == 2);
238                 assert (values.contains ("value_of_one"));
239                 assert (values.contains ("value_of_two"));
240
241                 // Check keys on map clear
242                 test_map.clear ();
243                 assert (values.size == 0);
244                 values = test_map.values;
245                 assert (values.size == 0);
246         }
247
248         public void test_entries () {
249                 // Check entries on empty map
250                 var entries = test_map.entries;
251                 assert (entries.size == 0);
252
253                 // Check entries on map with one item
254                 test_map.set ("one", "value_of_one");
255                 assert (entries.size == 1);
256                 assert (entries.contains (new TestEntry<string,string> ("one", "value_of_one")));
257                 entries = test_map.entries;
258                 assert (entries.size == 1);
259                 assert (entries.contains (new TestEntry<string,string> ("one", "value_of_one")));
260
261                 // Check modify entry set directly
262                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
263                                        TestTrapFlags.SILENCE_STDERR)) {
264                         assert (! entries.add (new TestEntry<string,string> ("two", "value_of_two")));
265                         Posix.exit (0);
266                 }
267                 Test.trap_assert_failed ();
268                 Test.trap_assert_stderr ("*code should not be reached*");
269
270                 // Check entries on map with multiple items
271                 test_map.set ("two", "value_of_two");
272                 assert (entries.size == 2);
273                 assert (entries.contains (new TestEntry<string,string> ("one", "value_of_one")));
274                 assert (entries.contains (new TestEntry<string,string> ("two", "value_of_two")));
275                 entries = test_map.entries;
276                 assert (entries.size == 2);
277                 assert (entries.contains (new TestEntry<string,string> ("one", "value_of_one")));
278                 assert (entries.contains (new TestEntry<string,string> ("two", "value_of_two")));
279
280                 // Check keys on map clear
281                 test_map.clear ();
282                 assert (entries.size == 0);
283                 entries = test_map.entries;
284                 assert (entries.size == 0);
285         }
286         
287         public void test_clear () {
288                 test_map.set ("one", "value_of_one");
289                 test_map.set ("two", "value_of_two");
290                 test_map.set ("three", "value_of_three");
291                 
292                 test_map.clear ();
293                 assert (test_map.size == 0);
294                 
295                 Set<string> keys = test_map.keys;
296                 assert (keys != null);
297                 Iterator<string> ikeys = keys.iterator ();
298                 assert (ikeys != null);
299                 assert (!ikeys.has_next ());
300                 
301                 Collection<string> vals = test_map.values;
302                 assert (vals != null);
303                 Iterator<string> ivals = vals.iterator ();
304                 assert (ivals != null);
305                 assert (!ivals.has_next ());
306                 
307                 Set<Map.Entry<string, string>> ents = test_map.entries;
308                 assert (ents != null);
309                 Iterator<Map.Entry<string, string>> ients = ents.iterator ();
310                 assert (ients != null);
311                 assert (!ients.has_next ());
312                 
313                 MapIterator<string, string> iter = test_map.map_iterator ();
314                 assert (iter != null);
315                 assert (!iter.has_next ());
316         }
317
318         public void test_set_all () {
319                 var another_map = new HashMap<string,string> ();
320
321                 test_map.set ("one", "value_of_one");
322                 test_map.set ("two", "value_of_two");
323                 test_map.set ("three", "value_of_three");
324                 another_map.set ("four", "value_of_four");
325                 another_map.set ("five", "value_of_five");
326                 another_map.set ("six", "value_of_six");
327
328                 test_map.set_all (another_map);
329
330                 assert (test_map.size == 6);
331                 assert (test_map.has_key ("one"));
332                 assert (test_map.has_key ("two"));
333                 assert (test_map.has_key ("three"));
334                 assert (test_map.has_key ("four"));
335                 assert (test_map.has_key ("five"));
336                 assert (test_map.has_key ("six"));
337
338                 assert (test_map.get ("one") == "value_of_one");
339                 assert (test_map.get ("two") == "value_of_two");
340                 assert (test_map.get ("three") == "value_of_three");
341                 assert (test_map.get ("four") == "value_of_four");
342                 assert (test_map.get ("five") == "value_of_five");
343                 assert (test_map.get ("six") == "value_of_six");
344         }
345
346         public void test_unset_all () {
347                 var another_map = new HashMap<string,string> ();
348
349                 // Check unset all on empty maps.
350                 assert (test_map.is_empty);
351                 assert (another_map.is_empty);
352
353                 assert (! test_map.unset_all (another_map));
354
355                 assert (test_map.is_empty);
356                 assert (another_map.is_empty);
357
358                 test_map.clear ();
359                 another_map.clear ();
360
361                 // Test_Map is empty, another_map has entries. -> no change
362                 another_map.set ("one", "value_of_one");
363                 another_map.set ("two", "value_of_two");
364
365                 assert (test_map.is_empty);
366                 assert (another_map.size == 2);
367
368                 assert (! test_map.unset_all (another_map));
369
370                 assert (test_map.is_empty);
371                 assert (another_map.size == 2);
372
373                 test_map.clear ();
374                 another_map.clear ();
375
376                 // Test_Map has entries, another_map is empty. -> no change
377                 test_map.set ("one", "value_of_one");
378                 test_map.set ("two", "value_of_two");
379
380                 assert (test_map.size == 2);
381                 assert (another_map.is_empty);
382
383                 assert (! test_map.unset_all (another_map));
384
385                 assert (test_map.size == 2);
386                 assert (another_map.is_empty);
387
388                 test_map.clear ();
389                 another_map.clear ();
390
391                 // Test_Map and another_map have the same
392                 // entries -> test_map is cleared
393                 test_map.set ("one", "value_of_one");
394                 test_map.set ("two", "value_of_two");
395                 another_map.set ("one", "value_of_one");
396                 another_map.set ("two", "value_of_two");
397
398                 assert (test_map.size == 2);
399                 assert (another_map.size == 2);
400
401                 assert (test_map.unset_all (another_map));
402
403                 assert (test_map.is_empty);
404                 assert (another_map.size == 2);
405
406                 test_map.clear ();
407                 another_map.clear ();
408
409                 // Test_Map has some common keys with another_map
410                 // but both have also unique keys -> common key are
411                 // cleared from test_map
412                 test_map.set ("one", "value_of_one");
413                 test_map.set ("two", "value_of_two");
414                 test_map.set ("three", "value_of_three");
415                 another_map.set ("two", "value_of_two");
416                 another_map.set ("three", "value_of_three");
417                 another_map.set ("four", "value_of_four");
418                 another_map.set ("five", "value_of_five");
419
420                 assert (test_map.size == 3);
421                 assert (another_map.size == 4);
422
423                 assert (test_map.unset_all (another_map));
424
425                 assert (test_map.size == 1);
426                 assert (another_map.size == 4);
427
428                 assert (test_map.has_key ("one"));
429         }
430
431         public void test_has_all () {
432                 var another_map = new HashMap<string,string> ();
433
434                 // Check empty.
435                 assert (test_map.has_all (another_map));
436
437                 // Test_Map has items, another_map is empty.
438                 test_map.set ("one", "value_of_one");
439
440                 assert (test_map.has_all (another_map));
441
442                 test_map.clear ();
443                 another_map.clear ();
444
445                 // Test_Map is empty, another_map has items.
446                 another_map.set ("one", "value_of_one");
447
448                 assert (! test_map.has_all (another_map));
449
450                 test_map.clear ();
451                 another_map.clear ();
452
453                 // Test_Map and another_map are the same.
454                 test_map.set ("one", "value_of_one");
455                 test_map.set ("two", "value_of_two");
456
457                 another_map.set ("one", "value_of_one");
458                 another_map.set ("two", "value_of_two");
459
460                 assert (test_map.has_all (another_map));
461
462                 test_map.clear ();
463                 another_map.clear ();
464
465                 // Test_Map and another_map are not the same.
466                 test_map.set ("one", "value_of_one");
467                 test_map.set ("two", "value_of_two");
468
469                 another_map.set ("one", "another_value_of_one");
470                 another_map.set ("two", "another_value_of_two");
471
472                 assert (! test_map.has_all (another_map));
473
474                 test_map.clear ();
475                 another_map.clear ();
476
477                 // Test_Map and another_map are not the same
478                 test_map.set ("one", "value_of_one");
479                 another_map.set ("two", "value_of_two");
480
481                 assert (! test_map.has_all (another_map));
482
483                 test_map.clear ();
484                 another_map.clear ();
485
486                 // Test_Map has a subset of another_map
487                 test_map.set ("one", "value_of_one");
488                 test_map.set ("two", "value_of_two");
489                 test_map.set ("three", "value_of_three");
490                 test_map.set ("four", "value_of_four");
491                 test_map.set ("five", "value_of_five");
492                 test_map.set ("six", "value_of_six");
493                 another_map.set ("two", "value_of_two");
494                 another_map.set ("three", "value_of_three");
495                 another_map.set ("four", "value_of_four");
496
497                 assert (test_map.has_all (another_map));
498
499                 test_map.clear ();
500                 another_map.clear ();
501
502                 // Test_Map has a subset of another_map in all but one element another_map
503                 test_map.set ("one", "value_of_one");
504                 test_map.set ("two", "value_of_two");
505                 test_map.set ("three", "value_of_three");
506                 test_map.set ("four", "value_of_four");
507                 test_map.set ("five", "value_of_five");
508                 test_map.set ("six", "value_of_six");
509                 another_map.set ("two", "value_of_two");
510                 another_map.set ("three", "value_of_three");
511                 another_map.set ("four", "value_of_four");
512                 another_map.set ("height", "value_of_height");
513
514                 assert (! test_map.has_all (another_map));
515         }
516
517         public void test_gobject_properties () {
518                 // Check the map exists
519                 assert (test_map != null);
520                 Value value;
521
522                 value = Value (typeof (int));
523                 test_map.get_property ("size", ref value);
524                 assert (value.get_int () == test_map.size);
525                 value.unset ();
526         }
527
528         public void test_fold () {
529                 test_map.set ("one", "one");
530                 test_map.set ("two", "two");
531                 test_map.set ("three", "three");
532                 
533                 int count;
534                 
535                 count = test_map.map_iterator ().fold<int> ((x, y, z) => {return z + 1;}, 0);
536                 assert (count == 3);
537                 
538                 var iter = test_map.map_iterator ();
539                 assert (iter.next ());
540                 count = iter.fold<int> ((x, y, z) => {return z + 1;}, 0);
541                 assert (count == 3);
542         }
543         
544         public void test_foreach () {
545                 test_map.set ("one", "one");
546                 test_map.set ("two", "two");
547                 test_map.set ("three", "three");
548                 
549                 int count = 0;
550                 
551                 test_map.map_iterator ().foreach ((x, y) => {count++; return true;});
552                 assert (count == 3);
553                 
554                 var iter = test_map.map_iterator ();
555                 assert (iter.next ());
556                 iter.foreach ((x, y) => {count++; return true;});
557                 assert (count == 6);
558         }
559
560         public static Map.Entry<string,string> entry_for (string key, string value) {
561                 return new TestEntry<string,string> (key, value);
562         }
563         
564         public static bool check_entry (owned Map.Entry<string,string> e, string key, string value) {
565                 return e.key == key && e.value == value;
566         }
567         
568         public static void assert_entry (Map.Entry<string,string> e, string key, string value) {
569                 assert (e.key == key);
570                 assert (e.value == value);
571         }
572         
573         private class TestEntry<K,V> : Map.Entry<K,V> {
574                 public TestEntry (K key, V value) {
575                         this._key = key;
576                         this.value = value;
577                 }
578                 
579                 public override K key { get {return _key; } }
580                 private K _key;
581                 public override V value { get; set; }
582                 public override bool read_only { get { return false; } }
583         }
584 }
585