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 <[EMAIL PROTECTED]>
*/
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 <[EMAIL PROTECTED]>
*/
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 ();
}
_______________________________________________
Vala-list mailing list
Vala-list@gnome.org
http://mail.gnome.org/mailman/listinfo/vala-list
