Fix Issue #43

* testing most containers with classes

tab to whitespace

Author: burner

src/containers/cyclicbuffer.d

@@ -792,3 +792,13 @@ unittest
 	b.reserve(b.capacity + 1);
 	assert(equal(b[], [7, 6, 0, 1, 2, 3, 4, 5]));
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+    }
+
+    CyclicBuffer!Foo b;
+}

src/containers/hashmap.d

@@ -481,3 +481,16 @@ unittest
 	hm3[100] = 1;
 	assert (hm3.get(100, 20) == 1);
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+    }
+
+    auto hm = HashMap!(string, Foo)(16);
+    auto f = new Foo;
+    hm.insert("foo", f);
+    assert("foo" in hm);
+}

src/containers/hashset.d

@@ -119,15 +119,15 @@ struct HashSet(T, Allocator = Mallocator, alias hashFunction = generateHash!T,
 	/**
 	 * Returns: true if value is contained in the set.
 	 */
-	bool contains(T value) inout nothrow
+	bool contains(T value) inout
 	{
 		return (value in this) !is null;
 	}
 
 	/**
 	 * Supports $(B a in b) syntax
 	 */
-	inout(T)* opBinaryRight(string op)(T value) inout nothrow if (op == "in")
+	inout(T)* opBinaryRight(string op)(T value) inout if (op == "in")
 	{
 		if (buckets.length == 0 || _length == 0)
 			return null;
@@ -634,3 +634,28 @@ unittest
 	auto h = new AStruct(10, 10);
 	assert(h in fred);
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+    }
+
+    hash_t stringToHash(string str) @safe pure nothrow @nogc
+    {
+        hash_t hash = 5381;
+        return hash;
+    }
+
+    hash_t FooToHash(Foo e) pure @safe nothrow @nogc
+    {
+        return stringToHash(e.name);
+    }
+
+    HashSet!(Foo, Mallocator, FooToHash) hs;
+    auto f = new Foo;
+    hs.insert(f);
+    assert(f in hs);
+    auto r = hs.range();
+}

src/containers/openhashset.d

@@ -123,7 +123,7 @@ struct OpenHashSet(T, Allocator = Mallocator,
 	 * Returns:
 	 *     $(B true) if the hash set contains the given item, false otherwise.
 	 */
-	bool contains(T item) const nothrow @safe
+	bool contains(T item) const
 	{
 		if (empty)
 			return false;
@@ -135,7 +135,7 @@ struct OpenHashSet(T, Allocator = Mallocator,
 	}
 
 	/// ditto
-	bool opBinaryRight(string op)(T item) inout nothrow if (op == "in")
+	bool opBinaryRight(string op)(T item) inout if (op == "in")
 	{
 		return contains(item);
 	}
@@ -282,7 +282,7 @@ private:
 	 * Returns:
 	 *     size_t.max if the item was not found
 	 */
-	static size_t toIndex(const Node[] n, T item, size_t hash) nothrow @safe
+	static size_t toIndex(const Node[] n, T item, size_t hash)
 	{
 		immutable size_t bucketMask = (n.length - 1);
 		immutable size_t index = hash & bucketMask;
@@ -354,3 +354,34 @@ unittest
 	assert (ohs.remove(0));
 	assert (ohs.remove(1));
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+
+        override bool opEquals(Object other) const @safe pure nothrow @nogc
+        {
+            Foo f = cast(Foo)other;
+            return f !is null && f.name == this.name;
+        }
+    }
+
+    hash_t stringToHash(string str) @safe pure nothrow @nogc
+    {
+        hash_t hash = 5381;
+        return hash;
+    }
+
+    hash_t FooToHash(Foo e) pure @safe nothrow @nogc
+    {
+        return stringToHash(e.name);
+    }
+
+    OpenHashSet!(Foo, Mallocator, FooToHash) hs;
+    auto f = new Foo;
+    hs.insert(f);
+    assert(f in hs);
+    auto r = hs.range();
+}

src/containers/slist.d

@@ -284,3 +284,15 @@ unittest
 	l ~= "fghij";
 	assert (l.length == 2);
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+    }
+
+    SList!Foo hs;
+    auto f = new Foo;
+    hs.put(f);
+}

src/containers/treemap.d

@@ -184,3 +184,15 @@ unittest
 	assert(equal(tm.keys, a));
 	assert(equal(tm.values, repeat(0).take(a.length)));
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+    }
+
+    TreeMap!(string, Foo) tm;
+    auto f = new Foo;
+    tm["foo"] = f;
+}

src/containers/ttree.d

@@ -1164,3 +1164,23 @@ unittest
 		assert(allocator.bytesUsed == 0);
 	}
 }
+
+unittest
+{
+    static class Foo
+    {
+        string name;
+
+        this(string s)
+        {
+            this.name = s;
+        }
+    }
+
+    TTree!(Foo, Mallocator, false, "a.name < b.name") tt;
+    auto f = new Foo("foo");
+    tt.insert(f);
+    f = new Foo("bar");
+    tt.insert(f);
+    auto r = tt.range();
+}

src/containers/unrolledlist.d

@@ -599,3 +599,21 @@ unittest
 	static assert (is (typeof(objs.front) == const));
 	static assert (is (typeof(objs[].front) == const));
 }
+
+unittest
+{
+    static class A
+    {
+        int a;
+        int b;
+
+        this(int a, int b)
+        {
+            this.a = a;
+            this.b = b;
+        }
+    }
+
+    UnrolledList!(A) objs;
+    objs.insert(new A(10, 11));
+}