+2008-05-01 Jürg Billeter <j@bitron.ch>
+
+ * tests/testarraylist.vala:
+ * tests/testhashmap.vala:
+ * tests/testhashset.vala:
+
+ Extend test suite, based on patch by Quikee
+
2008-04-14 Jürg Billeter <j@bitron.ch>
* gee/arraylist.vala, gee/hashmap.vala, gee/hashset.vala,
-/* testarraylist.vala
+/* testhashmap.vala
*
* Copyright (C) 2008 Jürg Billeter
*
using GLib;
using Gee;
-void test_arraylist_int_add () {
- var arraylist = new ArrayList<int> ();
+const string INDEX_OUT_OF_RANGE = "*index >= 0 && index < self->priv->_size*";
+const string INSERT_INDEX_OUT_OF_RANGE = "*index >= 0 && index <= self->priv->_size*";
- arraylist.add (42);
- assert (arraylist.contains (42));
- assert (arraylist.size == 1);
+void test_arraylist_get () {
+ var arraylistOfString = new ArrayList<string> ();
+
+ // Check get for empty list
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.get (0);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ // Check get for valid index in list with one element
+ arraylistOfString.add ("1");
+ assert (arraylistOfString.get (0) == "1");
+
+ // Check get for indexes out of range
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.get (1);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ // Check get for invalid index number
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.get (-1);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ // Check get for valid indexes in list with multiple element
+ arraylistOfString.add ("2");
+ arraylistOfString.add ("3");
+ assert (arraylistOfString.get (0) == "1");
+ assert (arraylistOfString.get (1) == "2");
+ assert (arraylistOfString.get (2) == "3");
+
+ // Check get if list is cleared and empty again
+ arraylistOfString.clear ();
+
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.get (0);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
}
-void test_arraylist_int_iterator () {
- var arraylist = new ArrayList<int> ();
- arraylist.add (42);
+void test_arraylist_set () {
+ var arraylistOfString = new ArrayList<string> ();
+
+ // Check set when list is empty.
+ assert (arraylistOfString.size == 0);
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.set (0, "0");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+ assert (arraylistOfString.size == 0);
+
+ // Check set when one item is in list
+ arraylistOfString.add ("1"); // Add item "1"
+ assert (arraylistOfString.size == 1);
+ assert (arraylistOfString.get (0) == "1");
+
+ arraylistOfString.set (0, "2"); // Set the item to value 2
+ assert (arraylistOfString.size == 1);
+ assert (arraylistOfString.get (0) == "2");
+
+ // Check set when index out of range
+ assert (arraylistOfString.size == 1);
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.set (1, "0");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+ assert (arraylistOfString.size == 1);
+}
- var it = arraylist.iterator ();
- assert (it.next ());
- assert (it.get () == 42);
- assert (!it.next ());
+void test_arraylist_insert () {
+ var arraylistOfString = new ArrayList<string> ();
+
+ // Check inserting in empty list
+ // Inserting at index 1
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.insert (1, "0");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INSERT_INDEX_OUT_OF_RANGE);
+
+ // Inserting at index 0
+ assert (arraylistOfString.size == 0);
+ arraylistOfString.insert (0, "10");
+ assert (arraylistOfString.size == 1);
+ assert (arraylistOfString.get (0) == "10");
+
+ // Check insert to the beginning
+ arraylistOfString.insert (0, "5");
+ assert (arraylistOfString.get (0) == "5");
+ assert (arraylistOfString.get (1) == "10");
+
+ // Check insert in between
+ arraylistOfString.insert (1, "7");
+ assert (arraylistOfString.get (0) == "5");
+ assert (arraylistOfString.get (1) == "7");
+ assert (arraylistOfString.get (2) == "10");
+
+ // Check insert into index out of current range
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.insert (4, "20");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INSERT_INDEX_OUT_OF_RANGE);
+
+ // Check insert to the end
+ arraylistOfString.insert (3, "20");
+ assert (arraylistOfString.get (0) == "5");
+ assert (arraylistOfString.get (1) == "7");
+ assert (arraylistOfString.get (2) == "10");
+ assert (arraylistOfString.get (3) == "20");
+
+ // Check insert into invalid index
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.insert (-1, "0");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INSERT_INDEX_OUT_OF_RANGE);
+
}
-void test_arraylist_int_remove () {
- var arraylist = new ArrayList<int> ();
- arraylist.add (42);
+void test_arraylist_remove_at () {
+ var arraylistOfString = new ArrayList<string> ();
+
+ // Check removing in empty list
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.remove_at (0);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.remove_at (1);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ // add 5 items
+ arraylistOfString.add ("1");
+ arraylistOfString.add ("2");
+ arraylistOfString.add ("3");
+ arraylistOfString.add ("4");
+ arraylistOfString.add ("5");
+ assert (arraylistOfString.size == 5);
+
+ // Check remove_at first
+ arraylistOfString.remove_at (0);
+ assert (arraylistOfString.size == 4);
+ assert (arraylistOfString.get (0) == "2");
+ assert (arraylistOfString.get (1) == "3");
+ assert (arraylistOfString.get (2) == "4");
+ assert (arraylistOfString.get (3) == "5");
+
+ // Check remove_at last
+ arraylistOfString.remove_at (3);
+ assert (arraylistOfString.size == 3);
+ assert (arraylistOfString.get (0) == "2");
+ assert (arraylistOfString.get (1) == "3");
+ assert (arraylistOfString.get (2) == "4");
+
+ // Check remove_at in between
+ arraylistOfString.remove_at (1);
+ assert (arraylistOfString.size == 2);
+ assert (arraylistOfString.get (0) == "2");
+ assert (arraylistOfString.get (1) == "4");
+
+ // Check remove_at when index out of range
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.remove_at (2);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+
+ // Check remove_at when invalid index
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ arraylistOfString.remove_at (-1);
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (INDEX_OUT_OF_RANGE);
+}
- arraylist.remove (42);
- assert (!arraylist.contains (42));
- assert (arraylist.size == 0);
+void test_arraylist_index_of () {
+ var arraylistOfString = new ArrayList<string> (str_equal);
+ // Check empty list
+ assert (arraylistOfString.index_of ("one") == -1);
+
+ // Check invalid type
+ assert (arraylistOfString.index_of (1) == -1);
+
+ // Check one item
+ arraylistOfString.add ("one");
+ assert (arraylistOfString.index_of ("one") == 0);
+ assert (arraylistOfString.index_of ("two") == -1);
+
+ // Check more items
+ arraylistOfString.add ("two");
+ arraylistOfString.add ("three");
+ arraylistOfString.add ("four");
+ assert (arraylistOfString.index_of ("one") == 0);
+ assert (arraylistOfString.index_of ("two") == 1);
+ assert (arraylistOfString.index_of ("three") == 2);
+ assert (arraylistOfString.index_of ("four") == 3);
+ assert (arraylistOfString.index_of ("five") == -1);
+
+ // Check list of ints
+ var arraylistOfInt = new ArrayList<int> ();
+
+ // Check more items
+ arraylistOfInt.add (1);
+ arraylistOfInt.add (2);
+ arraylistOfInt.add (3);
+ assert (arraylistOfInt.index_of (1) == 0);
+ assert (arraylistOfInt.index_of (2) == 1);
+ assert (arraylistOfInt.index_of (3) == 2);
+ assert (arraylistOfInt.index_of (4) == -1);
+
+ // Check list of objects
+ var arraylistOfObjects = new ArrayList<Object> ();
+
+ var object1 = new Object ();
+ var object2 = new Object ();
+ var object3 = new Object ();
+ var object4 = new Object ();
+
+ arraylistOfObjects.add (object1);
+ arraylistOfObjects.add (object2);
+ arraylistOfObjects.add (object3);
+
+ assert (arraylistOfObjects.index_of (object1) == 0);
+ assert (arraylistOfObjects.index_of (object2) == 1);
+ assert (arraylistOfObjects.index_of (object3) == 2);
+ assert (arraylistOfObjects.index_of (4) == -1);
+
}
-void test_arraylist_string_add () {
- var arraylist = new ArrayList<string> (str_equal);
+void test_arraylist_add () {
+ var arraylistOfString = new ArrayList<string> (str_equal);
- arraylist.add ("hello");
- assert (arraylist.contains ("hello"));
- assert (arraylist.size == 1);
+ arraylistOfString.add ("42");
+ assert (arraylistOfString.contains ("42"));
+ assert (arraylistOfString.size == 1);
+
+ // check for correct order of elements
+ arraylistOfString.add ("43");
+ arraylistOfString.add ("44");
+ arraylistOfString.add ("45");
+ assert (arraylistOfString.get (0) == "42");
+ assert (arraylistOfString.get (1) == "43");
+ assert (arraylistOfString.get (2) == "44");
+ assert (arraylistOfString.get (3) == "45");
+ assert (arraylistOfString.size == 4);
+
+ // check adding of ints
+ var arrayListOfInt = new ArrayList<int> ();
+
+ arrayListOfInt.add (42);
+ assert (arrayListOfInt.contains (42));
+ assert (arrayListOfInt.size == 1);
+
+ // check adding of objects
+ var arrayListOfGLibObject = new ArrayList<Object> ();
+
+ var fooObject = new Object();
+ arrayListOfGLibObject.add (fooObject);
+ assert (arrayListOfGLibObject.contains (fooObject));
+ assert (arrayListOfGLibObject.size == 1);
+
}
-void test_arraylist_string_iterator () {
- var arraylist = new ArrayList<string> (str_equal);
- arraylist.add ("hello");
+void test_arraylist_clear () {
+ var arraylistOfString = new ArrayList<string> (str_equal);
+ assert (arraylistOfString.size == 0);
+
+ // Check clear on empty list
+ arraylistOfString.clear();
+ assert (arraylistOfString.size == 0);
+
+ // Check clear one item
+ arraylistOfString.add ("1");
+ assert (arraylistOfString.size == 1);
+ arraylistOfString.clear();
+ assert (arraylistOfString.size == 0);
+
+ // Check clear multiple items
+ arraylistOfString.add ("1");
+ arraylistOfString.add ("2");
+ arraylistOfString.add ("3");
+ assert (arraylistOfString.size == 3);
+ arraylistOfString.clear();
+ assert (arraylistOfString.size == 0);
+}
- var it = arraylist.iterator ();
- assert (it.next ());
- assert (it.get () == "hello");
- assert (!it.next ());
+void test_arraylist_contains () {
+ var arraylistOfString = new ArrayList<string> (str_equal);
+
+ // Check on empty list
+ assert (!arraylistOfString.contains("1"));
+
+ // Check incomaptible type
+ assert (!arraylistOfString.contains(1));
+
+ // Check items
+ arraylistOfString.add ("10");
+ assert (arraylistOfString.contains("10"));
+ assert (!arraylistOfString.contains("20"));
+ assert (!arraylistOfString.contains("30"));
+
+ arraylistOfString.add ("20");
+ assert (arraylistOfString.contains("10"));
+ assert (arraylistOfString.contains("20"));
+ assert (!arraylistOfString.contains("30"));
+
+ arraylistOfString.add ("30");
+ assert (arraylistOfString.contains("10"));
+ assert (arraylistOfString.contains("20"));
+ assert (arraylistOfString.contains("30"));
+
+ // Clear and recheck
+ arraylistOfString.clear();
+ assert (!arraylistOfString.contains("10"));
+ assert (!arraylistOfString.contains("20"));
+ assert (!arraylistOfString.contains("30"));
+
+ var arraylistOfInt = new ArrayList<int> ();
+
+ // Check items
+ arraylistOfInt.add (10);
+ assert (arraylistOfInt.contains(10));
+ assert (!arraylistOfInt.contains(20));
+ assert (!arraylistOfInt.contains(30));
+
+ arraylistOfInt.add (20);
+ assert (arraylistOfInt.contains(10));
+ assert (arraylistOfInt.contains(20));
+ assert (!arraylistOfInt.contains(30));
+
+ arraylistOfInt.add (30);
+ assert (arraylistOfInt.contains(10));
+ assert (arraylistOfInt.contains(20));
+ assert (arraylistOfInt.contains(30));
+
+ // Clear and recheck
+ arraylistOfInt.clear();
+ assert (!arraylistOfInt.contains(10));
+ assert (!arraylistOfInt.contains(20));
+ assert (!arraylistOfInt.contains(30));
}
-void test_arraylist_string_remove () {
- var arraylist = new ArrayList<string> (str_equal);
- arraylist.add ("hello");
+void test_arraylist_remove () {
+ var arraylistOfString = new ArrayList<string> (str_equal);
+
+ // Check remove if list is empty
+ arraylistOfString.remove("42");
+
+ // Check remove for incompatible type
+ arraylistOfString.remove(10);
+
+ // Add 5 same elements
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("42");
+
+ // Check remove one element
+ arraylistOfString.remove ("42");
+ assert (arraylistOfString.size == 4);
+ assert (arraylistOfString.contains ("42"));
+
+ // Check remove another one element
+ arraylistOfString.remove ("42");
+ assert (arraylistOfString.size == 3);
+ assert (arraylistOfString.contains ("42"));
+
+ // Clear the list to start from scratch
+ arraylistOfString.clear();
+
+ // Add 5 different elements
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("43");
+ arraylistOfString.add ("44");
+ arraylistOfString.add ("45");
+ arraylistOfString.add ("46");
+ assert (arraylistOfString.size == 5);
+
+ // Check remove first
+ arraylistOfString.remove("42");
+ assert (arraylistOfString.size == 4);
+ assert (arraylistOfString.get (0) == "43");
+ assert (arraylistOfString.get (1) == "44");
+ assert (arraylistOfString.get (2) == "45");
+ assert (arraylistOfString.get (3) == "46");
+
+ // Check remove last
+ arraylistOfString.remove("46");
+ assert (arraylistOfString.size == 3);
+ assert (arraylistOfString.get (0) == "43");
+ assert (arraylistOfString.get (1) == "44");
+ assert (arraylistOfString.get (2) == "45");
+
+ // Check remove in between
+ arraylistOfString.remove("44");
+ assert (arraylistOfString.size == 2);
+ assert (arraylistOfString.get (0) == "43");
+ assert (arraylistOfString.get (1) == "45");
+
+ // Check removing of int element
+ var arraylistOfInt = new ArrayList<int> ();
+
+ // Add 5 different elements
+ arraylistOfInt.add (42);
+ arraylistOfInt.add (43);
+ arraylistOfInt.add (44);
+ arraylistOfInt.add (45);
+ arraylistOfInt.add (46);
+ assert (arraylistOfInt.size == 5);
+
+ // Remove first
+ arraylistOfInt.remove(42);
+ assert (arraylistOfInt.size == 4);
+ assert (arraylistOfInt.get (0) == 43);
+ assert (arraylistOfInt.get (1) == 44);
+ assert (arraylistOfInt.get (2) == 45);
+ assert (arraylistOfInt.get (3) == 46);
+
+ // Remove last
+ arraylistOfInt.remove(46);
+ assert (arraylistOfInt.size == 3);
+ assert (arraylistOfInt.get (0) == 43);
+ assert (arraylistOfInt.get (1) == 44);
+ assert (arraylistOfInt.get (2) == 45);
+
+ // Remove in between
+ arraylistOfInt.remove(44);
+ assert (arraylistOfInt.size == 2);
+ assert (arraylistOfInt.get (0) == 43);
+ assert (arraylistOfInt.get (1) == 45);
+}
- arraylist.remove ("hello");
- assert (!arraylist.contains ("hello"));
+void test_arraylist_size () {
+ var arraylist = new ArrayList<string> ();
+
+ // Check empty list
+ assert (arraylist.size == 0);
+
+ // Check when one item
+ arraylist.add ("1");
+ assert (arraylist.size == 1);
+
+ // Check when more items
+ arraylist.add ("2");
+ assert (arraylist.size == 2);
+
+ // Check when items cleared
+ arraylist.clear();
assert (arraylist.size == 0);
}
+void test_arraylist_iterator () {
+ var arraylistOfString = new ArrayList<string> ();
+
+ // Check iterate empty list
+ var iterator = arraylistOfString.iterator ();
+ assert (!iterator.next());
+
+ // Check iterate list
+ arraylistOfString.add ("42");
+ arraylistOfString.add ("43");
+ arraylistOfString.add ("44");
+
+ iterator = arraylistOfString.iterator ();
+ assert (iterator.next());
+ assert (iterator.get () == "42");
+ assert (iterator.next());
+ assert (iterator.get () == "43");
+ assert (iterator.next());
+ assert (iterator.get () == "44");
+ assert (!iterator.next());
+}
+
void main (string[] args) {
Test.init (ref args);
-
- Test.add_func ("/arraylist/int/add", test_arraylist_int_add);
- Test.add_func ("/arraylist/int/iterator", test_arraylist_int_iterator);
- Test.add_func ("/arraylist/int/remove", test_arraylist_int_remove);
-
- Test.add_func ("/arraylist/string/add", test_arraylist_string_add);
- Test.add_func ("/arraylist/string/iterator", test_arraylist_string_iterator);
- Test.add_func ("/arraylist/string/remove", test_arraylist_string_remove);
-
+
+ // Methods of List interface
+ Test.add_func ("/Arraylist/List/get", test_arraylist_get);
+ Test.add_func ("/Arraylist/List/set", test_arraylist_set);
+ Test.add_func ("/Arraylist/List/insert", test_arraylist_insert);
+ Test.add_func ("/Arraylist/List/remove_at", test_arraylist_remove_at);
+ Test.add_func ("/Arraylist/List/index_of", test_arraylist_index_of);
+
+ // Methods of Collection interface
+ Test.add_func ("/Arraylist/Collection/add", test_arraylist_add);
+ Test.add_func ("/Arraylist/Collection/clear", test_arraylist_clear);
+ Test.add_func ("/Arraylist/Collection/contains", test_arraylist_contains);
+ Test.add_func ("/Arraylist/Collection/remove", test_arraylist_remove);
+ Test.add_func ("/Arraylist/Collection/size", test_arraylist_size);
+
+ // Methods of Iterable interface
+ Test.add_func ("/Arraylist/Iterable/iterator", test_arraylist_iterator);
+
Test.run ();
}
using GLib;
using Gee;
-void test_hashmap_int_int_remove () {
- var hashmap = new HashMap<int,int> ();
- hashmap.set (42, 23);
+const string CODE_NOT_REACHABLE = "*code should not be reached*";
- hashmap.remove (42);
- assert (!hashmap.contains (42));
- assert (hashmap.size == 0);
+void test_hashmap_get () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // Check get from empty map
+ assert (hashmap.get ("foo") == null);
+
+ // Check get from map with one items
+ hashmap.set ("key", "value");
+ assert (hashmap.get ("key") == "value");
+
+ // Check get from non-existing key
+ assert (hashmap.get ("foo") == null);
+
+ // Check get from map with multiple items
+ hashmap.set ("key2", "value2");
+ hashmap.set ("key3", "value3");
+ assert (hashmap.get ("key") == "value");
+ assert (hashmap.get ("key2") == "value2");
+ assert (hashmap.get ("key3") == "value3");
+
}
-void test_hashmap_int_int_set () {
- var hashmap = new HashMap<int,int> ();
+void test_hashmap_set () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // check map is empty
+ assert (hashmap.size == 0);
+
+ // check set an item to map
+ hashmap.set ("abc", "one");
+ assert (hashmap.contains ("abc"));
+ assert (hashmap.get ("abc") == "one");
+ assert (hashmap.size == 1);
+
+ // check set an item to map with same value
+ hashmap.set ("def", "one");
+ assert (hashmap.contains ("def"));
+ assert (hashmap.get ("abc") == "one");
+ assert (hashmap.get ("def") == "one");
+ assert (hashmap.size == 2);
+
+ // check set with same key
+ hashmap.set ("def", "two");
+ assert (hashmap.contains ("def"));
+ assert (hashmap.get ("abc") == "one");
+ assert (hashmap.get ("def") == "two");
+ assert (hashmap.size == 2);
+}
- hashmap.set (42, 23);
- assert (hashmap.contains (42));
- assert (hashmap.get (42) == 23);
+void test_hashmap_remove () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // check removing when map is empty
+ hashmap.remove ("foo");
+ assert (hashmap.size == 0);
+
+ // add items
+ hashmap.set ("aaa", "111");
+ hashmap.set ("bbb", "222");
+ hashmap.set ("ccc", "333");
+ hashmap.set ("ddd", "444");
+ assert (hashmap.size == 4);
+
+ // check remove on first place
+ hashmap.remove ("aaa");
+ assert (hashmap.size == 3);
+
+ // check remove in between
+ hashmap.remove ("ccc");
+ assert (hashmap.size == 2);
+
+ // check remove in last place
+ hashmap.remove ("ddd");
assert (hashmap.size == 1);
+
+ // check remove invalid key
+ hashmap.remove ("bar");
+
+ // check remove last in map
+ hashmap.remove ("bbb");
+ assert (hashmap.size == 0);
}
-void test_hashmap_string_string_remove () {
+void test_hashmap_contains () {
var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
- hashmap.set ("hello", "world");
+
+ // Check on empty map
+ assert (!hashmap.contains ("111"));
+
+ // Check items
+ hashmap.set ("10", "111");
+ assert (hashmap.contains ("10"));
+ assert (!hashmap.contains ("20"));
+ assert (!hashmap.contains ("30"));
+
+ assert (hashmap.get ("10") == "111");
+
+ hashmap.set ("20", "222");
+ assert (hashmap.contains ("10"));
+ assert (hashmap.contains ("20"));
+ assert (!hashmap.contains ("30"));
+
+ assert (hashmap.get ("10") == "111");
+ assert (hashmap.get ("20") == "222");
+
+ hashmap.set ("30", "333");
+ assert (hashmap.contains ("10"));
+ assert (hashmap.contains ("20"));
+ assert (hashmap.contains ("30"));
+
+ assert (hashmap.get ("10") == "111");
+ assert (hashmap.get ("20") == "222");
+ assert (hashmap.get ("30") == "333");
+
+ // Clear and recheck
+ hashmap.clear ();
+ assert (!hashmap.contains ("10"));
+ assert (!hashmap.contains ("20"));
+ assert (!hashmap.contains ("30"));
+
+ var hashmapOfInt = new HashMap<int,int> ();
+
+ // Check items
+ hashmapOfInt.set (10, 111);
+ assert (hashmapOfInt.contains (10));
+ assert (!hashmapOfInt.contains (20));
+ assert (!hashmapOfInt.contains (30));
+
+ assert (hashmapOfInt.get (10) == 111);
+
+ hashmapOfInt.set (20, 222);
+ assert (hashmapOfInt.contains (10));
+ assert (hashmapOfInt.contains (20));
+ assert (!hashmapOfInt.contains (30));
+
+ assert (hashmapOfInt.get (10) == 111);
+ assert (hashmapOfInt.get (20) == 222);
+
+ hashmapOfInt.set (30, 333);
+ assert (hashmapOfInt.contains (10));
+ assert (hashmapOfInt.contains (20));
+ assert (hashmapOfInt.contains (30));
+
+ assert (hashmapOfInt.get (10) == 111);
+ assert (hashmapOfInt.get (20) == 222);
+ assert (hashmapOfInt.get (30) == 333);
+}
- hashmap.remove ("hello");
- assert (!hashmap.contains ("hello"));
+void test_hashmap_size () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // Check empty map
+ assert (hashmap.size == 0);
+
+ // Check when one item
+ hashmap.set ("1", "1");
+ assert (hashmap.size == 1);
+
+ // Check when more items
+ hashmap.set ("2", "2");
+ assert (hashmap.size == 2);
+
+ // Check when items cleared
+ hashmap.clear ();
assert (hashmap.size == 0);
}
-void test_hashmap_string_string_set () {
+void test_hashmap_get_keys () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // Check keys on empty map
+ var keySet = hashmap.get_keys ();
+ assert (keySet.size == 0);
+
+ // Check keys on map with one item
+ hashmap.set ("aaa", "111");
+ assert (keySet.size == 1);
+ assert (keySet.contains ("aaa"));
+ keySet = hashmap.get_keys ();
+ assert (keySet.size == 1);
+ assert (keySet.contains ("aaa"));
+
+ // Check modify key set directly
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ keySet.add ("ccc");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (CODE_NOT_REACHABLE);
+
+ // Check keys on map with multiple items
+ hashmap.set ("bbb", "222");
+ assert (keySet.size == 2);
+ assert (keySet.contains ("aaa"));
+ assert (keySet.contains ("bbb"));
+ keySet = hashmap.get_keys ();
+ assert (keySet.size == 2);
+ assert (keySet.contains ("aaa"));
+ assert (keySet.contains ("bbb"));
+
+ // Check keys on map clear
+ hashmap.clear ();
+ assert (keySet.size == 0);
+ keySet = hashmap.get_keys ();
+ assert (keySet.size == 0);
+
+}
+
+void test_hashmap_get_values () {
var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+
+ // Check keys on empty map
+ var valueCollection = hashmap.get_values ();
+ assert (valueCollection.size == 0);
+
+ // Check keys on map with one item
+ hashmap.set ("aaa", "111");
+ assert (valueCollection.size == 1);
+ assert (valueCollection.contains ("111"));
+ valueCollection = hashmap.get_values ();
+ assert (valueCollection.size == 1);
+ assert (valueCollection.contains ("111"));
+
+ // Check modify key set directly
+ if (Test.trap_fork (0, TestTrapFlags.SILENCE_STDOUT | TestTrapFlags.SILENCE_STDERR)) {
+ valueCollection.add ("ccc");
+ return;
+ }
+ Test.trap_assert_failed ();
+ Test.trap_assert_stderr (CODE_NOT_REACHABLE);
+
+ // Check keys on map with multiple items
+ hashmap.set ("bbb", "222");
+ assert (valueCollection.size == 2);
+ assert (valueCollection.contains ("111"));
+ assert (valueCollection.contains ("222"));
+ valueCollection = hashmap.get_values ();
+ assert (valueCollection.size == 2);
+ assert (valueCollection.contains ("111"));
+ assert (valueCollection.contains ("222"));
+
+ // Check keys on map clear
+ hashmap.clear ();
+ assert (valueCollection.size == 0);
+ valueCollection = hashmap.get_values ();
+ assert (valueCollection.size == 0);
+
+}
- hashmap.set ("hello", "world");
- assert (hashmap.contains ("hello"));
- assert (hashmap.get ("hello") == "world");
+void test_hashmap_clear () {
+ var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
+ assert (hashmap.size == 0);
+
+ // Check clear on empty map
+ hashmap.clear ();
+ assert (hashmap.size == 0);
+
+ // Check clear one item
+ hashmap.set ("1", "1");
assert (hashmap.size == 1);
+ hashmap.clear ();
+ assert (hashmap.size == 0);
+
+ // Check clear multiple items
+ hashmap.set ("1", "1");
+ hashmap.set ("2", "2");
+ hashmap.set ("3", "3");
+ assert (hashmap.size == 3);
+ hashmap.clear ();
+ assert (hashmap.size == 0);
}
void main (string[] args) {
Test.init (ref args);
- Test.add_func ("/hashmap/int-int/remove", test_hashmap_int_int_remove);
- Test.add_func ("/hashmap/int-int/set", test_hashmap_int_int_set);
-
- Test.add_func ("/hashmap/string-string/remove", test_hashmap_string_string_remove);
- Test.add_func ("/hashmap/string-string/set", test_hashmap_string_string_set);
+ Test.add_func ("/HashMap/Map/get", test_hashmap_get);
+ Test.add_func ("/HashMap/Map/set", test_hashmap_set);
+ Test.add_func ("/HashMap/Map/remove", test_hashmap_remove);
+ Test.add_func ("/HashMap/Map/contains", test_hashmap_contains);
+ Test.add_func ("/HashMap/Map/size", test_hashmap_size);
+ Test.add_func ("/HashMap/Map/get_keys", test_hashmap_get_keys);
+ Test.add_func ("/HashMap/Map/get_values", test_hashmap_get_values);
+ Test.add_func ("/HashMap/Map/clear", test_hashmap_clear);
Test.run ();
}
using GLib;
using Gee;
-void test_hashset_int_add () {
- var hashset = new HashSet<int> ();
+void test_hashset_add () {
+ // Check adding of strings
+ var hashset = new HashSet<string> (str_hash, str_equal);
- hashset.add (42);
- assert (hashset.contains (42));
+ hashset.add ("42");
+ assert (hashset.contains ("42"));
assert (hashset.size == 1);
-}
-
-void test_hashset_int_iterator () {
- var hashset = new HashSet<int> ();
- hashset.add (42);
+
+ hashset.add ("43");
+ assert (hashset.contains ("42"));
+ assert (hashset.contains ("43"));
+ assert (hashset.size == 2);
+
+ // Check add same element
+ assert (hashset.size == 2);
+ hashset.add ("43");
+ assert (hashset.contains ("42"));
+ assert (hashset.contains ("43"));
+ assert (hashset.size == 2);
+
+ // Check adding of ints
+ var hashsetInt = new HashSet<int> ();
- var it = hashset.iterator ();
- assert (it.next ());
- assert (it.get () == 42);
- assert (!it.next ());
+ hashsetInt.add (42);
+ assert (hashsetInt.contains (42));
+ assert (hashsetInt.size == 1);
+
+ hashsetInt.add (43);
+ assert (hashsetInt.contains (42));
+ assert (hashsetInt.contains (43));
+ assert (hashsetInt.size == 2);
+
+ // Check add same element
+ assert (hashsetInt.size == 2);
+ hashsetInt.add (43);
+ assert (hashsetInt.contains (42));
+ assert (hashsetInt.contains (43));
+ assert (hashsetInt.size == 2);
+
+ // Check adding of objects
+ var hashsetObject = new HashSet<Object> ();
+
+ var fooObject = new Object();
+ hashsetObject.add (fooObject);
+ assert (hashsetObject.contains (fooObject));
+ assert (hashsetObject.size == 1);
+
+ var fooObject2 = new Object();
+ hashsetObject.add (fooObject2);
+ assert (hashsetObject.contains (fooObject));
+ assert (hashsetObject.contains (fooObject2));
+ assert (hashsetObject.size == 2);
+
+ // Check add same element
+ assert (hashsetObject.size == 2);
+ hashsetObject.add (fooObject2);
+ assert (hashsetObject.contains (fooObject));
+ assert (hashsetObject.contains (fooObject2));
+ assert (hashsetObject.size == 2);
}
-void test_hashset_int_remove () {
- var hashset = new HashSet<int> ();
- hashset.add (42);
-
- hashset.remove (42);
- assert (!hashset.contains (42));
+void test_hashset_clear () {
+ var hashset = new HashSet<string> (str_hash, str_equal);
+ assert (hashset.size == 0);
+
+ // Check clear on empty set
+ hashset.clear ();
+ assert (hashset.size == 0);
+
+ // Check clear one item
+ hashset.add ("1");
+ assert (hashset.size == 1);
+ hashset.clear ();
+ assert (hashset.size == 0);
+
+ // Check clear multiple items
+ hashset.add ("1");
+ hashset.add ("2");
+ hashset.add ("3");
+ assert (hashset.size == 3);
+ hashset.clear ();
assert (hashset.size == 0);
}
-void test_hashset_string_add () {
- var hashset = new HashSet<string> (str_hash, str_equal);
-
- hashset.add ("hello");
- assert (hashset.contains ("hello"));
- assert (hashset.size == 1);
+void test_hashset_contains () {
+ var hashsetString = new HashSet<string> (str_hash, str_equal);
+
+ // Check on empty set
+ assert (!hashsetString.contains ("1"));
+
+ // Check items
+ hashsetString.add ("10");
+ assert (hashsetString.contains ("10"));
+ assert (!hashsetString.contains ("20"));
+ assert (!hashsetString.contains ("30"));
+
+ hashsetString.add ("20");
+ assert (hashsetString.contains ("10"));
+ assert (hashsetString.contains ("20"));
+ assert (!hashsetString.contains ("30"));
+
+ hashsetString.add ("30");
+ assert (hashsetString.contains ("10"));
+ assert (hashsetString.contains ("20"));
+ assert (hashsetString.contains ("30"));
+
+ // Clear and recheck
+ hashsetString.clear ();
+ assert (!hashsetString.contains ("10"));
+ assert (!hashsetString.contains ("20"));
+ assert (!hashsetString.contains ("30"));
+
+ var hashsetInt = new HashSet<int> ();
+
+ // Check items
+ hashsetInt.add (10);
+ assert (hashsetInt.contains (10));
+ assert (!hashsetInt.contains (20));
+ assert (!hashsetInt.contains (30));
+
+ hashsetInt.add (20);
+ assert (hashsetInt.contains (10));
+ assert (hashsetInt.contains (20));
+ assert (!hashsetInt.contains (30));
+
+ hashsetInt.add (30);
+ assert (hashsetInt.contains (10));
+ assert (hashsetInt.contains (20));
+ assert (hashsetInt.contains (30));
+
+ // Clear and recheck
+ hashsetInt.clear ();
+ assert (!hashsetInt.contains (10));
+ assert (!hashsetInt.contains (20));
+ assert (!hashsetInt.contains (30));
}
-void test_hashset_string_iterator () {
- var hashset = new HashSet<string> (str_hash, str_equal);
- hashset.add ("hello");
+void test_hashset_remove () {
+ var hashsetString = new HashSet<string> (str_hash, str_equal);
+
+ // Check remove if list is empty
+ hashsetString.remove ("42");
+
+ // Add 5 different elements
+ hashsetString.add ("42");
+ hashsetString.add ("43");
+ hashsetString.add ("44");
+ hashsetString.add ("45");
+ hashsetString.add ("46");
+ assert (hashsetString.size == 5);
+
+ // Check remove first
+ hashsetString.remove ("42");
+ assert (hashsetString.size == 4);
+ assert (hashsetString.contains ("43"));
+ assert (hashsetString.contains ("44"));
+ assert (hashsetString.contains ("45"));
+ assert (hashsetString.contains ("46"));
+
+ // Check remove last
+ hashsetString.remove ("46");
+ assert (hashsetString.size == 3);
+ assert (hashsetString.contains ("43"));
+ assert (hashsetString.contains ("44"));
+ assert (hashsetString.contains ("45"));
+
+ // Check remove in between
+ hashsetString.remove ("44");
+ assert (hashsetString.size == 2);
+ assert (hashsetString.contains ("43"));
+ assert (hashsetString.contains ("45"));
- var it = hashset.iterator ();
- assert (it.next ());
- assert (it.get () == "hello");
- assert (!it.next ());
+ // Check removing of int element
+ var hashsetInt = new HashSet<int> ();
+
+ // Add 5 different elements
+ hashsetInt.add (42);
+ hashsetInt.add (43);
+ hashsetInt.add (44);
+ hashsetInt.add (45);
+ hashsetInt.add (46);
+ assert (hashsetInt.size == 5);
+
+ // Remove first
+ hashsetInt.remove (42);
+ assert (hashsetInt.size == 4);
+ assert (hashsetInt.contains (43));
+ assert (hashsetInt.contains (44));
+ assert (hashsetInt.contains (45));
+ assert (hashsetInt.contains (46));
+
+ // Remove last
+ hashsetInt.remove (46);
+ assert (hashsetInt.size == 3);
+ assert (hashsetInt.contains (43));
+ assert (hashsetInt.contains (44));
+ assert (hashsetInt.contains (45));
+
+ // Remove in between
+ hashsetInt.remove (44);
+ assert (hashsetInt.size == 2);
+ assert (hashsetInt.contains (43));
+ assert (hashsetInt.contains (45));
}
-void test_hashset_string_remove () {
+void test_hashset_size () {
var hashset = new HashSet<string> (str_hash, str_equal);
- hashset.add ("hello");
-
- hashset.remove ("hello");
- assert (!hashset.contains ("hello"));
+
+ // Check empty list
+ assert (hashset.size == 0);
+
+ // Check when one item
+ hashset.add ("1");
+ assert (hashset.size == 1);
+
+ // Check when more items
+ hashset.add ("2");
+ assert (hashset.size == 2);
+
+ // Check when items cleared
+ hashset.clear ();
assert (hashset.size == 0);
}
+void test_hashset_iterator () {
+ var hashset = new HashSet<string> (str_hash, str_equal);
+
+ // Check iterate empty list
+ var iterator = hashset.iterator ();
+ assert (!iterator.next());
+
+ // Check iterate list
+ hashset.add ("42");
+ hashset.add ("43");
+
+ iterator = hashset.iterator ();
+
+ // A set is usually not ordered, so this is not a requirement
+ assert (iterator.next());
+ string firstString = iterator.get();
+ assert (hashset.contains (firstString));
+
+ assert (iterator.next());
+ string secondString = iterator.get();
+ assert (hashset.contains (secondString));
+ assert (!str_equal (firstString, secondString)); // they can not be identical neither equal
+
+ assert (!iterator.next());
+}
void main (string[] args) {
Test.init (ref args);
- Test.add_func ("/hashset/int/add", test_hashset_int_add);
- Test.add_func ("/hashset/int/iterator", test_hashset_int_iterator);
- Test.add_func ("/hashset/int/remove", test_hashset_int_remove);
-
- Test.add_func ("/hashset/string/add", test_hashset_string_add);
- Test.add_func ("/hashset/string/iterator", test_hashset_string_iterator);
- Test.add_func ("/hashset/string/remove", test_hashset_string_remove);
+ Test.add_func ("/HashSet/Collection/add", test_hashset_add);
+ Test.add_func ("/HashSet/Collection/clear", test_hashset_clear);
+ Test.add_func ("/HashSet/Collection/contains", test_hashset_contains);
+ Test.add_func ("/HashSet/Collection/remove", test_hashset_remove);
+ Test.add_func ("/HashSet/Collection/size", test_hashset_size);
+
+ Test.add_func ("/HashSet/Iterable/iterator", test_hashset_iterator);
Test.run ();
}
projects / platform / upstream / libgee.git / commitdiff