libgee r30 - in trunk: . tests

[juergbi svn gnome org]

Author: juergbi
Date: Thu May  1 20:05:50 2008
New Revision: 30
URL: http://svn.gnome.org/viewvc/libgee?rev=30&view=rev

Log:
2008-05-01  Juerg Billeter  <j bitron ch>

	* tests/testarraylist.vala:
	* tests/testhashmap.vala:
	* tests/testhashset.vala:

	Extend test suite, based on patch by Quikee


Modified:
   trunk/ChangeLog
   trunk/tests/testarraylist.vala
   trunk/tests/testhashmap.vala
   trunk/tests/testhashset.vala

Modified: trunk/tests/testarraylist.vala
==============================================================================
--- trunk/tests/testarraylist.vala	(original)
+++ trunk/tests/testarraylist.vala	Thu May  1 20:05:50 2008
@@ -1,4 +1,4 @@
-/* testarraylist.vala
+/* testhashmap.vala
  *
  * Copyright (C) 2008  JÃrg Billeter
  *
@@ -23,71 +23,528 @@
 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);
-
-	var it = arraylist.iterator ();
-	assert (it.next ());
-	assert (it.get () == 42);
-	assert (!it.next ());
-}
-
-void test_arraylist_int_remove () {
-	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);
+}
 
-	arraylist.remove (42);
-	assert (!arraylist.contains (42));
-	assert (arraylist.size == 0);
+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_string_add () {
-	var arraylist = new ArrayList<string> (str_equal);
+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.add ("hello");
-	assert (arraylist.contains ("hello"));
-	assert (arraylist.size == 1);
+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_iterator () {
-	var arraylist = new ArrayList<string> (str_equal);
-	arraylist.add ("hello");
-
-	var it = arraylist.iterator ();
-	assert (it.next ());
-	assert (it.get () == "hello");
-	assert (!it.next ());
-}
-
-void test_arraylist_string_remove () {
-	var arraylist = new ArrayList<string> (str_equal);
-	arraylist.add ("hello");
+void test_arraylist_add () {
+	var arraylistOfString = new ArrayList<string> (str_equal);
 
-	arraylist.remove ("hello");
-	assert (!arraylist.contains ("hello"));
+	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_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);
+}
+
+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_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);
+}
+
+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 ();
 }
 

Modified: trunk/tests/testhashmap.vala
==============================================================================
--- trunk/tests/testhashmap.vala	(original)
+++ trunk/tests/testhashmap.vala	Thu May  1 20:05:50 2008
@@ -23,50 +23,291 @@
 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 ();
 }

Modified: trunk/tests/testhashset.vala
==============================================================================
--- trunk/tests/testhashset.vala	(original)
+++ trunk/tests/testhashset.vala	Thu May  1 20:05:50 2008
@@ -23,70 +23,265 @@
 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);
+	
+	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> ();
+
+	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_iterator () {
-	var hashset = new HashSet<int> ();
-	hashset.add (42);
-
-	var it = hashset.iterator ();
-	assert (it.next ());
-	assert (it.get () == 42);
-	assert (!it.next ());
-}
-
-void test_hashset_int_remove () {
-	var hashset = new HashSet<int> ();
-	hashset.add (42);
-
-	hashset.remove (42);
-	assert (!hashset.contains (42));
-	assert (hashset.size == 0);
-}
-
-void test_hashset_string_add () {
+void test_hashset_clear () {
 	var hashset = new HashSet<string> (str_hash, str_equal);
-
-	hashset.add ("hello");
-	assert (hashset.contains ("hello"));
+	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_iterator () {
-	var hashset = new HashSet<string> (str_hash, str_equal);
-	hashset.add ("hello");
+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));
+}
 
-	var it = hashset.iterator ();
-	assert (it.next ());
-	assert (it.get () == "hello");
-	assert (!it.next ());
+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"));
+
+	// 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 ();
 }