tests/testbidirsortedmap.vala

   1 /* testbidirsortedmap.vala
   2  *
   3  * Copyright (C) 2012  Maciej Piechotka
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Maciej Piechotka <uzytkownik2@gmail.com>
  21  */
  22 using GLib;
  23 using Gee;
  24
  25 public abstract class BidirSortedMapTests : SortedMapTests {
  26         public BidirSortedMapTests(string name) {
  27                 base (name);
  28                 add_test ("[SortedMap] bi-directional iterators can go backward",
  29                           test_bidir_iterator_can_go_backward);
  30                 add_test ("[SortedSet] bi-directional iterators can to end",
  31                           test_bidir_iterator_last);
  32                 get_suite ().add_suite (new BidirSubMapTests (this, SortedMapTests.SubMapTests.Type.HEAD).get_suite ());
  33                 get_suite ().add_suite (new BidirSubMapTests (this, SortedMapTests.SubMapTests.Type.TAIL).get_suite ());
  34                 get_suite ().add_suite (new BidirSubMapTests (this, SortedMapTests.SubMapTests.Type.SUB).get_suite ());
  35                 get_suite ().add_suite (new BidirSubMapTests (this, SortedMapTests.SubMapTests.Type.EMPTY).get_suite ());
  36         }
  37
  38         public void test_bidir_iterator_can_go_backward () {
  39                 var test_sorted_map = test_map as BidirSortedMap<string,string>;
  40                 var keys = (test_sorted_map.ascending_keys) as BidirSortedSet<string>;
  41                 var entries = (test_sorted_map.ascending_entries) as BidirSortedSet<Map.Entry<string,string>>;
  42
  43                 var keys_iterator = keys.bidir_iterator ();
  44                 var entries_iterator = entries.bidir_iterator ();
  45                 var map_iterator = test_sorted_map.bidir_map_iterator ();
  46
  47                 assert (!keys_iterator.has_previous ());
  48                 assert (!entries_iterator.has_previous ());
  49
  50                 assert (!map_iterator.has_previous ());
  51                 assert (!keys_iterator.previous ());
  52                 assert (!entries_iterator.has_previous ());
  53
  54                 assert (!map_iterator.previous ());
  55
  56                 test_sorted_map.set ("one", "one");
  57                 test_sorted_map.set ("two", "two");
  58                 test_sorted_map.set ("three", "three");
  59                 test_sorted_map.set ("four", "four");
  60                 test_sorted_map.set ("five", "five");
  61                 test_sorted_map.set ("six", "six");
  62
  63                 keys_iterator = keys.bidir_iterator ();
  64                 entries_iterator = entries.bidir_iterator ();
  65                 map_iterator = test_sorted_map.bidir_map_iterator ();
  66
  67                 assert (keys_iterator.next ());
  68                 assert (entries_iterator.next ());
  69
  70                 assert (map_iterator.next ());
  71                 assert (keys_iterator.get () == "five");
  72                 assert_entry (entries_iterator.get (), "five", "five");
  73
  74                 assert (map_iterator.get_key () == "five");
  75                 assert (map_iterator.get_value () == "five");
  76
  77                 assert (!keys_iterator.has_previous ());
  78                 assert (!entries_iterator.has_previous ());
  79
  80                 assert (!map_iterator.has_previous ());
  81                 assert (keys_iterator.next ());
  82                 assert (entries_iterator.next ());
  83
  84                 assert (map_iterator.next ());
  85                 assert (keys_iterator.get () == "four");
  86                 assert_entry (entries_iterator.get (), "four", "four");
  87
  88                 assert (map_iterator.get_key () == "four");
  89                 assert (map_iterator.get_value () == "four");
  90
  91                 assert (keys_iterator.has_previous ());
  92                 assert (entries_iterator.has_previous ());
  93
  94                 assert (map_iterator.has_previous ());
  95                 assert (keys_iterator.next ());
  96                 assert (entries_iterator.next ());
  97
  98                 assert (map_iterator.next ());
  99                 assert (keys_iterator.get () == "one");
 100                 assert_entry (entries_iterator.get (), "one", "one");
 101
 102                 assert (map_iterator.get_key () == "one");
 103                 assert (map_iterator.get_value () == "one");
 104
 105                 assert (keys_iterator.has_previous ());
 106                 assert (entries_iterator.has_previous ());
 107
 108                 assert (map_iterator.has_previous ());
 109                 assert (keys_iterator.next ());
 110                 assert (entries_iterator.next ());
 111
 112                 assert (map_iterator.next ());
 113                 assert (keys_iterator.get () == "six");
 114                 assert_entry (entries_iterator.get (), "six", "six");
 115
 116                 assert (map_iterator.get_key () == "six");
 117                 assert (map_iterator.get_value () == "six");
 118                 assert (keys_iterator.has_previous ());
 119
 120                 assert (entries_iterator.has_previous ());
 121                 assert (map_iterator.has_previous ());
 122                 assert (keys_iterator.next ());
 123
 124                 assert (entries_iterator.next ());
 125                 assert (map_iterator.next ());
 126                 assert (keys_iterator.get () == "three");
 127
 128                 assert_entry (entries_iterator.get (), "three", "three");
 129                 assert (map_iterator.get_key () == "three");
 130                 assert (map_iterator.get_value () == "three");
 131
 132                 assert (keys_iterator.has_previous ());
 133                 assert (entries_iterator.has_previous ());
 134                 assert (map_iterator.has_previous ());
 135
 136                 assert (keys_iterator.next ());
 137                 assert (entries_iterator.next ());
 138                 assert (map_iterator.next ());
 139
 140                 assert (keys_iterator.get () == "two");
 141                 assert_entry (entries_iterator.get (), "two", "two");
 142                 assert (map_iterator.get_key () == "two");
 143                 assert (map_iterator.get_value () == "two");
 144
 145                 assert (keys_iterator.has_previous ());
 146                 assert (entries_iterator.has_previous ());
 147                 assert (map_iterator.has_previous ());
 148
 149                 assert (!keys_iterator.next ());
 150                 assert (!entries_iterator.next ());
 151                 assert (!map_iterator.next ());
 152
 153                 assert (keys_iterator.previous ());
 154                 assert (entries_iterator.previous ());
 155                 assert (map_iterator.previous ());
 156
 157                 assert (keys_iterator.get () == "three");
 158                 assert_entry (entries_iterator.get (), "three", "three");
 159                 assert (map_iterator.get_key () == "three");
 160                 assert (map_iterator.get_value () == "three");
 161
 162                 assert (keys_iterator.previous ());
 163                 assert (entries_iterator.previous ());
 164                 assert (map_iterator.previous ());
 165
 166                 assert (keys_iterator.get () == "six");
 167                 assert_entry (entries_iterator.get (), "six", "six");
 168                 assert (map_iterator.get_key () == "six");
 169                 assert (map_iterator.get_value () == "six");
 170
 171                 assert (keys_iterator.previous ());
 172                 assert (entries_iterator.previous ());
 173                 assert (map_iterator.previous ());
 174
 175                 assert (keys_iterator.get () == "one");
 176                 assert_entry (entries_iterator.get (), "one", "one");
 177                 assert (map_iterator.get_key () == "one");
 178                 assert (map_iterator.get_value () == "one");
 179
 180                 assert (keys_iterator.previous ());
 181                 assert (entries_iterator.previous ());
 182                 assert (map_iterator.previous ());
 183
 184                 assert (keys_iterator.get () == "four");
 185                 assert_entry (entries_iterator.get (), "four", "four");
 186                 assert (map_iterator.get_key () == "four");
 187                 assert (map_iterator.get_value () == "four");
 188
 189                 assert (keys_iterator.previous ());
 190                 assert (entries_iterator.previous ());
 191                 assert (map_iterator.previous ());
 192
 193                 assert (keys_iterator.get () == "five");
 194                 assert_entry (entries_iterator.get (), "five", "five");
 195                 assert (map_iterator.get_key () == "five");
 196                 assert (map_iterator.get_value () == "five");
 197
 198                 assert (!keys_iterator.previous ());
 199                 assert (!entries_iterator.previous ());
 200                 assert (!map_iterator.previous ());
 201
 202                 assert (keys_iterator.get () == "five");
 203                 assert_entry (entries_iterator.get (), "five", "five");
 204                 assert (map_iterator.get_key () == "five");
 205                 assert (map_iterator.get_value () == "five");
 206         }
 207
 208         public void test_bidir_iterator_last () {
 209                 var test_sorted_map = test_map as BidirSortedMap<string,string>;
 210                 var keys = (test_sorted_map.ascending_keys) as BidirSortedSet<string>;
 211                 var entries = (test_sorted_map.ascending_entries) as BidirSortedSet<Map.Entry<string,string>>;
 212
 213                 var keys_iterator = keys.bidir_iterator ();
 214                 var entries_iterator = entries.bidir_iterator ();
 215
 216                 assert (!keys_iterator.last ());
 217                 assert (!entries_iterator.last ());
 218
 219                 test_sorted_map.set ("one", "one");
 220                 test_sorted_map.set ("two", "two");
 221                 test_sorted_map.set ("three", "three");
 222                 test_sorted_map.set ("four", "four");
 223                 test_sorted_map.set ("five", "five");
 224                 test_sorted_map.set ("six", "six");
 225
 226                 keys_iterator = keys.bidir_iterator ();
 227                 entries_iterator = entries.bidir_iterator ();
 228
 229                 assert (keys_iterator.last ());
 230                 assert (entries_iterator.last ());
 231
 232                 assert (keys_iterator.get () == "two");
 233                 assert_entry (entries_iterator.get (), "two", "two");
 234         }
 235
 236
 237         public class BidirSubMapTests : Gee.TestCase {
 238                 private BidirSortedMap<string,string> master;
 239                 private BidirSortedMap<string,string> submap;
 240                 private BidirSortedMapTests test;
 241                 private SortedMapTests.SubMapTests.Type type;
 242
 243                 public BidirSubMapTests (BidirSortedMapTests test, SortedMapTests.SubMapTests.Type type) {
 244                         base ("%s Subset".printf (type.to_string ()));
 245                         this.test = test;
 246                         this.type = type;
 247                         add_test ("[BidirSortedSet] bi-directional iterator", test_bidir_iterators);
 248                 }
 249
 250                 public override void set_up () {
 251                         test.set_up ();
 252                         master = test.test_map as BidirSortedMap<string,string>;
 253                         switch (type) {
 254                         case SortedMapTests.SubMapTests.Type.HEAD:
 255                                 submap = master.head_map ("one") as BidirSortedMap<string,string>; break;
 256                         case SortedMapTests.SubMapTests.Type.TAIL:
 257                                 submap = master.tail_map ("six") as BidirSortedMap<string,string>; break;
 258                         case SortedMapTests.SubMapTests.Type.SUB:
 259                                 submap = master.sub_map ("four", "three") as BidirSortedMap<string,string>; break;
 260                         case SortedMapTests.SubMapTests.Type.EMPTY:
 261                                 submap = master.sub_map ("three", "four") as BidirSortedMap<string,string>; break;
 262                         default:
 263                                 assert_not_reached ();
 264                         }
 265                 }
 266
 267                 public override void tear_down () {
 268                         test.tear_down ();
 269                 }
 270
 271                 protected void set_default_values (out string[] contains = null, out string[] not_contains = null) {
 272                         master.set ("one", "one");
 273                         master.set ("two", "two");
 274                         master.set ("three", "three");
 275                         master.set ("four", "four");
 276                         master.set ("five", "five");
 277                         master.set ("six", "six");
 278                         switch (type) {
 279                         case SortedMapTests.SubMapTests.Type.HEAD:
 280                                 contains = {"five", "four"};
 281                                 not_contains = {"one", "two", "three", "six"};
 282                                 break;
 283                         case SortedMapTests.SubMapTests.Type.TAIL:
 284                                 contains = {"six", "three", "two"};
 285                                 not_contains = {"one", "four", "five"};
 286                                 break;
 287                         case SortedMapTests.SubMapTests.Type.SUB:
 288                                 contains = {"four", "one", "six"};
 289                                 not_contains = {"two", "three", "five"};
 290                                 break;
 291                         case SortedMapTests.SubMapTests.Type.EMPTY:
 292                                 contains = {};
 293                                 not_contains = {"one", "two", "three", "four", "five", "six"};
 294                                 break;
 295                         default:
 296                                 assert_not_reached ();
 297                         }
 298                 }
 299
 300                 public void test_bidir_iterators () {
 301                         string[] contains, not_contains;
 302
 303                         var _map_iter = submap.bidir_map_iterator ();
 304
 305                         assert (!_map_iter.has_next ());
 306                         assert (!_map_iter.next ());
 307                         assert (!_map_iter.has_previous ());
 308                         assert (!_map_iter.previous ());
 309
 310                         set_default_values (out contains, out not_contains);
 311
 312                         var i = 0;
 313                         _map_iter = submap.bidir_map_iterator ();
 314                         while (_map_iter.next ()) {
 315                                 assert (_map_iter.get_key () == contains[i]);
 316                                 assert (_map_iter.get_value () == contains[i]);
 317                                 i++;
 318                         }
 319                         assert (i == contains.length);
 320
 321                         i = 0;
 322                         foreach (var k in submap.keys)
 323                                 assert (k == contains[i++]);
 324                         assert (i == contains.length);
 325
 326                         i = 0;
 327                         foreach (var e in submap.entries) {
 328                                 MapTests.assert_entry (e, contains[i], contains[i]);
 329                                 i++;
 330                         }
 331                         assert (i == contains.length);
 332
 333                         var keys_iter = ((submap.ascending_keys) as BidirSortedSet<string>).bidir_iterator ();
 334                         var entries_iter = ((submap.ascending_entries) as BidirSortedSet<Map.Entry<string,string>>).bidir_iterator ();
 335                         var map_iter = submap.bidir_map_iterator ();
 336                         if (type != SortedMapTests.SubMapTests.Type.EMPTY) {
 337                                 assert (map_iter.last ());
 338                                 assert (map_iter.get_key () == contains[contains.length - 1]);
 339                                 assert (map_iter.get_value () == contains[contains.length - 1]);
 340
 341                                 map_iter = submap.bidir_map_iterator ();
 342                                 assert (map_iter.next ());
 343
 344                                 assert (map_iter.get_key () == contains[0]);
 345                                 assert (map_iter.get_value () == contains[0]);
 346
 347                                 assert (map_iter.has_next ());
 348                                 assert (map_iter.next ());
 349                                 assert (map_iter.get_key () == contains[1]);
 350                                 assert (map_iter.get_value () == contains[1]);
 351
 352                                 assert (map_iter.has_previous ());
 353                                 map_iter.unset ();
 354                                 assert (map_iter.has_previous ());
 355                                 if (type != SortedMapTests.SubMapTests.Type.HEAD)
 356                                         assert (map_iter.has_next ());
 357                                 else
 358                                         assert (!map_iter.has_next ());
 359                                 assert (map_iter.previous ());
 360                                 assert (map_iter.get_key () == contains[0]);
 361                                 assert (map_iter.get_value () == contains[0]);
 362
 363                                 // Repeat for keys
 364                                 master.clear ();
 365                                 set_default_values (out contains, out not_contains);
 366
 367                                 assert (keys_iter.last ());
 368                                 assert (keys_iter.get () == contains[contains.length - 1]);
 369                                 assert (keys_iter.first ());
 370
 371                                 assert (keys_iter.get () == contains[0]);
 372                                 assert (keys_iter.has_next ());
 373                                 assert (keys_iter.next ());
 374                                 assert (keys_iter.get () == contains[1]);
 375                                 assert (keys_iter.has_previous ());
 376                                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
 377                                                        TestTrapFlags.SILENCE_STDERR)) {
 378                                         keys_iter.remove ();
 379                                         Posix.exit (0);
 380                                 }
 381                                 assert (keys_iter.has_previous ());
 382                                 if (type != SortedMapTests.SubMapTests.Type.HEAD)
 383                                         assert (keys_iter.has_next ());
 384                                 else
 385                                         assert (!keys_iter.has_next ());
 386                                 assert (keys_iter.previous ());
 387                                 assert (keys_iter.get () == contains[0]);
 388
 389                                 // Repeat for entries
 390                                 master.clear ();
 391                                 set_default_values (out contains, out not_contains);
 392
 393                                 assert (entries_iter.last ());
 394                                 MapTests.assert_entry (entries_iter.get (), contains[contains.length - 1], contains[contains.length - 1]);
 395                                 assert (entries_iter.first ());
 396
 397                                 MapTests.assert_entry (entries_iter.get (), contains[0], contains[0]);
 398                                 assert (entries_iter.has_next ());
 399                                 assert (entries_iter.next ());
 400                                 MapTests.assert_entry (entries_iter.get (), contains[1], contains[1]);
 401                                 assert (entries_iter.has_previous ());
 402                                 entries_iter.remove ();
 403                                 assert (entries_iter.has_previous ());
 404                                 if (type != SortedMapTests.SubMapTests.Type.HEAD)
 405                                         assert (entries_iter.has_next ());
 406                                 else
 407                                         assert (!entries_iter.has_next ());
 408                                 assert (entries_iter.previous ());
 409                                 MapTests.assert_entry (entries_iter.get (), contains[0], contains[0]);
 410                         } else {
 411                                 assert (!keys_iter.first ());
 412                                 assert (!keys_iter.last ());
 413                                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
 414                                                        TestTrapFlags.SILENCE_STDERR)) {
 415                                         keys_iter.remove ();
 416                                         Posix.exit (0);
 417                                 }
 418                                 Test.trap_assert_failed ();
 419                                 assert (!entries_iter.first ());
 420                                 if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT |
 421                                                        TestTrapFlags.SILENCE_STDERR)) {
 422                                         entries_iter.remove ();
 423                                         Posix.exit (0);
 424                                 }
 425                                 Test.trap_assert_failed ();
 426                         }
 427                 }
 428         }
 429 }
 430