Update Changelog
[profile/ivi/libgee.git] / tests / testreadonlymap.vala
1 /* testreadonlymap.vala
2  *
3  * Copyright (C) 2008  Jürg Billeter
4  * Copyright (C) 2009  Didier Villevalois
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  *      Didier 'Ptitjes' Villevalois <ptitjes@free.fr>
22  */
23
24 using Gee;
25
26 public class ReadOnlyMapTests : Gee.TestCase {
27
28         public ReadOnlyMapTests () {
29                 base ("ReadOnlyMap");
30                 add_test ("[ReadOnlyMap] unique read-only view instance",
31                           test_unique_read_only_view_instance);
32                 add_test ("[ReadOnlyMap] immutable iterator", test_immutable_iterator);
33                 add_test ("[ReadOnlyMap] immutable", test_immutable);
34                 add_test ("[ReadOnlyMap] accurate view", test_accurate_view);
35         }
36
37         protected Map<string,string> test_map;
38         protected Map<string,string> ro_map;
39
40         public override void set_up () {
41                 test_map = new TreeMap<string,string> ();
42                 ro_map = test_map.read_only_view;
43         }
44
45         public override void tear_down () {
46                 test_map = null;
47                 ro_map = null;
48         }
49
50         public void test_unique_read_only_view_instance () {
51                 var another_ro_map = test_map.read_only_view;
52                 assert (ro_map == another_ro_map);
53
54                 ro_map.set_data ("marker", new Object ());
55                 assert (another_ro_map.get_data<Object> ("marker") != null);
56
57                 another_ro_map = null;
58                 ro_map = null;
59
60                 another_ro_map = test_map.read_only_view;
61                 assert (another_ro_map.get_data<Object> ("marker") == null);
62
63                 // Check that the read-only view of the view is itself
64                 assert (another_ro_map == another_ro_map.read_only_view);
65         }
66
67         public void test_immutable_iterator () {
68                 test_map.set ("one", "one");
69                 test_map.set ("two", "two");
70
71                 assert (ro_map.size == 2);
72                 assert (ro_map.has_key ("one"));
73                 assert (ro_map.has ("one", "one"));
74                 assert (ro_map.has_key ("two"));
75                 assert (ro_map.has ("two", "two"));
76
77                 Iterator<string> iterator = ro_map.keys.iterator ();
78
79                 assert (iterator.has_next ());
80                 assert (iterator.next ());
81                 assert (iterator.get () == "one");
82
83                 assert (iterator.has_next ());
84                 assert (iterator.next ());
85                 assert (iterator.get () == "two");
86
87                 assert (! iterator.has_next ());
88                 assert (! iterator.next ());
89
90                 iterator = ro_map.keys.iterator ();
91                 assert (iterator.has_next ());
92                 assert (iterator.next ());
93                 assert (iterator.get () == "one");
94
95                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
96                                        TestTrapFlags.SILENCE_STDERR)) {
97                         iterator.remove ();
98                         Posix.exit (0);
99                 }
100                 Test.trap_assert_failed ();
101
102                 assert (ro_map.size == 2);
103                 assert (ro_map.has_key ("one"));
104                 assert (ro_map.has ("one", "one"));
105                 assert (ro_map.has_key ("two"));
106                 assert (ro_map.has ("two", "two"));
107         }
108
109         public void test_immutable () {
110                 test_map.set ("one", "one");
111                 assert (ro_map.size == 1);
112                 assert (ro_map.has_key ("one"));
113                 assert (ro_map.has ("one", "one"));
114
115                 Map<string,string> dummy = new HashMap<string,string> ();
116                 dummy.set ("one", "one");
117                 dummy.set ("two", "two");
118
119                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
120                                        TestTrapFlags.SILENCE_STDERR)) {
121                         ro_map.set ("two", "two");
122                         Posix.exit (0);
123                 }
124                 Test.trap_assert_failed ();
125                 assert (ro_map.size == 1);
126                 assert (ro_map.has_key ("one"));
127                 assert (ro_map.has ("one", "one"));
128
129                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
130                                        TestTrapFlags.SILENCE_STDERR)) {
131                         ro_map.clear ();
132                         Posix.exit (0);
133                 }
134                 Test.trap_assert_failed ();
135                 assert (ro_map.size == 1);
136                 assert (ro_map.has_key ("one"));
137                 assert (ro_map.has ("one", "one"));
138
139                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
140                                        TestTrapFlags.SILENCE_STDERR)) {
141                         assert (ro_map.unset ("one"));
142                         Posix.exit (0);
143                 }
144                 Test.trap_assert_failed ();
145                 assert (ro_map.size == 1);
146                 assert (ro_map.has_key ("one"));
147                 assert (ro_map.has ("one", "one"));
148
149                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
150                                        TestTrapFlags.SILENCE_STDERR)) {
151                         ro_map.set_all (dummy);
152                         Posix.exit (0);
153                 }
154                 Test.trap_assert_failed ();
155                 assert (ro_map.size == 1);
156                 assert (ro_map.has_key ("one"));
157                 assert (ro_map.has ("one", "one"));
158
159                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
160                                        TestTrapFlags.SILENCE_STDERR)) {
161                         assert (ro_map.unset_all (dummy));
162                         Posix.exit (0);
163                 }
164                 Test.trap_assert_failed ();
165                 assert (ro_map.size == 1);
166                 assert (ro_map.has_key ("one"));
167                 assert (ro_map.has ("one", "one"));
168         }
169
170         public void test_accurate_view () {
171                 Map<string,string> dummy = new HashMap<string,string> ();
172                 dummy.set ("one", "one");
173                 dummy.set ("two", "two");
174
175                 assert (ro_map.size == 0);
176                 assert (ro_map.is_empty);
177                 assert (! ro_map.has_key ("one"));
178                 assert (! ro_map.has ("one", "one"));
179                 assert (ro_map.get ("one") == null);
180
181                 test_map.set ("one", "one");
182                 assert (ro_map.size == 1);
183                 assert (! ro_map.is_empty);
184                 assert (ro_map.has_key ("one"));
185                 assert (ro_map.has ("one", "one"));
186                 assert (ro_map.get ("one") == "one");
187
188                 test_map.set ("two", "two");
189                 assert (ro_map.size == 2);
190                 assert (! ro_map.is_empty);
191                 assert (ro_map.has_key ("one"));
192                 assert (ro_map.has ("one", "one"));
193                 assert (ro_map.get ("one") == "one");
194                 assert (ro_map.has_key ("two"));
195                 assert (ro_map.has ("two", "two"));
196                 assert (ro_map.get ("two") == "two");
197                 assert (ro_map.has_all (dummy));
198
199                 assert (test_map.unset ("one"));
200                 assert (ro_map.size == 1);
201                 assert (! ro_map.is_empty);
202                 assert (! ro_map.has_key ("one"));
203                 assert (! ro_map.has ("one", "one"));
204                 assert (ro_map.get ("one") == null);
205                 assert (ro_map.has_key ("two"));
206                 assert (ro_map.has ("two", "two"));
207                 assert (ro_map.get ("two") == "two");
208                 assert (! ro_map.has_all (dummy));
209
210                 test_map.clear ();
211                 assert (ro_map.size == 0);
212                 assert (ro_map.is_empty);
213                 assert (! ro_map.has ("one", "one"));
214                 assert (! ro_map.has ("two", "two"));
215                 assert (ro_map.get ("one") == null);
216                 assert (ro_map.get ("two") == null);
217         }
218 }