[Vala] Gee tests and extension proposal

[Quikee <quikee gmail com>]

Hello.

I have extended the tests in Gee library. Now they cover all methods
provided by the interfaces they extend so that future changes to the
library can be done without fear to break the behavior of those
methods. The extended tests are attached to this post.

I would also like to propose an extension to the interfaces in form of
additional convenient / often used methods. What I had in mind is
this:

Collection interface:
- void add_all(Collection) - Adds all items from the input collection
to this collection. Convenient for joining collections. Java also has
this on the interface of Collection.
- bool contains_all(Collection) - Checks if all items in the input
collection are present in this collection. Convenient for checking
items for example if "a" AND "b" exist in collection.
- bool contains_any(Collection) - Checks if any items in the input
collection are present in this collection. Convenient for checking
items for example if "a" OR "b" exist in collection.
- bool is_empty() - special state of a collection when it doesn't
contain any value. Added because it is clearer as list.size == 0.

List interface
- G first()
- G last() - First and last items are often special - it adds better
clarity to the algorithm if they don't need to be "addressed" as
list.get(0) or worse list.get(list.size -1).

Set interface

Map interface
- void set_all(Map) - Same as add_all for collections.
- expose Node<K,V> and make it possible to iterate through Nodes:
foreach (Node<int,int> item in map.get_nodes()) {

}

Iterators
- It would be convenient

using GLib;
using Gee;

class ClassForTesting : GLib.Object {
	public string prop { get;set; }
}

class ERR : GLib.Object {
	public static string INDEX_OUT_OF_RANGE = "*(index >= 0 && index < self->priv->_size)*";
}

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(ERR.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(ERR.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(ERR.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(ERR.INDEX_OUT_OF_RANGE);
}

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(ERR.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(ERR.INDEX_OUT_OF_RANGE);
	assert(arraylistOfString.size == 1);
}

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(ERR.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(ERR.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(ERR.INDEX_OUT_OF_RANGE);
	
}

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(ERR.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(ERR.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(ERR.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(ERR.INDEX_OUT_OF_RANGE);
}

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<ClassForTesting> ();
	
	var object1 = new ClassForTesting();
	var object2 = new ClassForTesting();
	var object3 = new ClassForTesting();
	var object4 = new ClassForTesting();
	
	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_add () {
	var arraylistOfString = new ArrayList<string> (str_equal);

	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<ClassForTesting> ();
	
	var fooObject = new ClassForTesting();
	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);
	
	// 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 ();
}

/* testhashmap.vala
 *
 * Copyright (C) 2008  Jürg Billeter
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Jürg Billeter <j bitron ch>
 */

using GLib;
using Gee;

class ClassForTesting : GLib.Object {
	public string prop { get;set; }
}

class ERR : GLib.Object {
	public static string INDEX_OUT_OF_RANGE = "*(index >= 0 && index < self->priv->_size)*";
	public static string CODE_NOT_REACHABLE = "*code should not be reached*";
}

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_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);
}

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_contains() {
	var hashmap = new HashMap<string,string> (str_hash, str_equal, str_equal);
	
	// 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);
}

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_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(ERR.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(ERR.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);

}

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/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 ();
}

/* testhashset.vala
 *
 * Copyright (C) 2008  Jürg Billeter
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 * 	Jürg Billeter <j bitron ch>
 */

using GLib;
using Gee;

class ClassForTesting : GLib.Object {
	public string prop { get;set; }
}

class ERR : GLib.Object {
	public static string INDEX_OUT_OF_RANGE = "*(index >= 0 && index < self->priv->_size)*";
}

void test_hashset_add () {
	// Check adding of strings
	var hashset = new HashSet<string> (str_hash, str_equal);

	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<ClassForTesting> ();
	
	var fooObject = new ClassForTesting();
	hashsetObject.add (fooObject);
	assert (hashsetObject.contains (fooObject));
	assert (hashsetObject.size == 1);
	
	var fooObject2 = new ClassForTesting();
	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_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_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_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_size() {
	var hashset = new HashSet<string> (str_hash, str_equal);
	
	// 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/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 ();
}