autoc 1.4 → 2.0.0

data/lib/autoc/scaffold/test_int_hash_set.rb

@@ -0,0 +1,448 @@
+require 'autoc/hash_set'
+
+type_test(AutoC::HashSet, :IntHashSet, :int) do
+
+	###
+
+	def render_forward_declarations(stream)
+		super
+		stream << "void #{dump}(#{const_rvalue} target);"
+	end
+
+	def render_implementation(stream)
+		super
+		stream << %{
+			#include <stdio.h>
+			void #{dump}(#{const_rvalue} target) {
+				#{range} r;
+				for(r = #{range.new}(target); !#{range.empty}(&r); #{range.pop_front}(&r)) {
+					printf("%d ", #{range.take_front}(&r));
+				}
+				printf("\\n");
+			}
+		}
+	end
+
+	setup %{
+		#{self} t;
+	}
+
+	cleanup %{
+		#{destroy}(&t);
+	}
+
+	test :create_empty, %{
+		#{create}(&t);
+		TEST_TRUE( #{empty}(&t) );
+		TEST_EQUAL( #{size}(&t), 0 );
+	}
+
+	test :iterate_0, %{
+		#{create}(&t);
+		#{range} r = #{range.new}(&t);
+		TEST_TRUE( #{range.empty}(&r) );
+	}
+
+	test :iterate_1, %{
+		#{create}(&t);
+		TEST_EQUAL( #{size}(&t), 0 );
+		#{put}(&t, -3);
+		TEST_EQUAL( #{size}(&t), 1 );
+		#{range} r = #{range.new}(&t);
+		TEST_FALSE( #{range.empty}(&r) );
+		TEST_EQUAL( #{range.take_front}(&r), -3 );
+		#{range.pop_front}(&r);
+		TEST_TRUE( #{range.empty}(&r) );
+	}
+
+	###
+
+	setup %{
+		int i;
+		#{self} t;
+		#{create}(&t);
+		for(i = 0; i < 3; ++i) {
+			#{put}(&t, i*11);
+		}
+	}
+
+	cleanup %{
+		#{destroy}(&t);
+	}
+
+	test :iterate_3, %{
+		TEST_EQUAL( #{size}(&t), 3);
+		#{range} r = #{range.new}(&t);
+		TEST_FALSE( #{range.empty}(&r) );
+		#{range.pop_front}(&r);
+		TEST_FALSE( #{range.empty}(&r) );
+		#{range.pop_front}(&r);
+		TEST_FALSE( #{range.empty}(&r) );
+		#{range.pop_front}(&r);
+		TEST_TRUE( #{range.empty}(&r) );
+	}
+
+	###
+
+	setup %{
+		#{self} t;
+		#{create}(&t);
+	}
+
+	cleanup %{
+		#{destroy}(&t);
+	}
+
+	test :put_uniques, %{
+		TEST_TRUE( #{put}(&t, 0) );
+		TEST_TRUE( #{put}(&t, -1) );
+		TEST_TRUE( #{put}(&t, 1) );
+		TEST_EQUAL( #{size}(&t), 3 );
+	}
+
+	test :put_duplicates, %{
+		TEST_TRUE( #{put}(&t, 0) );
+		TEST_TRUE( #{put}(&t, -1) );
+		TEST_TRUE( #{put}(&t, 1) );
+		TEST_FALSE( #{put}(&t, 0) );
+		TEST_FALSE( #{put}(&t, 1) );
+		TEST_FALSE( #{put}(&t, -1) );
+		TEST_EQUAL( #{size}(&t), 3 );
+	}
+
+	test :push, %{
+		TEST_FALSE( #{push}(&t, 1) );
+		TEST_FALSE( #{push}(&t, -1) );
+		TEST_TRUE( #{push}(&t, 1) );
+		TEST_EQUAL( #{size}(&t), 2 );
+	}
+
+	test :contains, %{
+		TEST_FALSE( #{contains}(&t, -1) );
+		TEST_TRUE( #{put}(&t, -1) );
+		TEST_TRUE( #{contains}(&t, -1) );
+	}
+
+	###
+
+	setup %{
+		#{self} t, r;
+		#{create}(&t);
+		#{create}(&r);
+	}
+
+	cleanup %{
+		#{destroy}(&t);
+		#{destroy}(&r);
+	}
+
+	test :remove_empty, %{
+		TEST_EQUAL( #{size}(&t), 0 );
+		TEST_FALSE( #{remove}(&t, 0) );
+		TEST_TRUE( #{equal}(&t, &r) );
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	test :remove_nonexistent, %{
+		TEST_TRUE( #{put}(&t, 1) );
+		TEST_TRUE( #{put}(&t, 2) );
+		TEST_TRUE( #{put}(&t, 3) );
+		TEST_TRUE( #{put}(&r, 1) );
+		TEST_TRUE( #{put}(&r, 2) );
+		TEST_TRUE( #{put}(&r, 3) );
+		TEST_EQUAL( #{size}(&t), 3 );
+		TEST_FALSE( #{remove}(&t, 0) );
+		TEST_TRUE( #{equal}(&t, &r) );
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	test :remove, %{
+		TEST_TRUE( #{put}(&t, 1) );
+		TEST_TRUE( #{put}(&t, 2) );
+		TEST_TRUE( #{put}(&t, 3) );
+		TEST_TRUE( #{put}(&r, 1) );
+		TEST_TRUE( #{put}(&r, 3) );
+		TEST_EQUAL( #{size}(&t), 3 );
+		TEST_TRUE( #{contains}(&t, 2) );
+		TEST_TRUE( #{remove}(&t, 2) );
+		TEST_FALSE( #{contains}(&t, 2) );
+		TEST_TRUE( #{equal}(&t, &r) );
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	###
+
+	setup %{
+		#{self} t1, t2;
+		#{create}(&t1);
+		#{create}(&t2);
+	}
+
+	cleanup %{
+		#{destroy}(&t1);
+		#{destroy}(&t2);
+	}
+
+	test :equal_empty, %{
+		TEST_EQUAL( #{size}(&t1), 0 );
+		TEST_EQUAL( #{size}(&t2), 0 );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+	}
+
+	test :equal_one, %{
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_EQUAL( #{size}(&t1), 1 );
+		TEST_EQUAL( #{size}(&t2), 1 );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+	}
+
+	test :equal, %{
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t1, -3) );
+		TEST_TRUE( #{put}(&t1, 0) );
+		TEST_TRUE( #{put}(&t2, -3) );
+		TEST_TRUE( #{put}(&t2, 0) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_EQUAL( #{size}(&t1), 3 );
+		TEST_EQUAL( #{size}(&t2), 3 );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+	}
+
+	test :subset_empty, %{
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t1, &t1) );
+		TEST_TRUE( #{subset}(&t2, &t2) );
+		TEST_TRUE( #{subset}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t2, &t1) );
+	}
+
+	test :subset_equal, %{
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_TRUE( #{put}(&t2, 2) );
+		TEST_TRUE( #{put}(&t2, 1) );
+		/* t2 == t1 */
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t1, &t1) );
+		TEST_TRUE( #{subset}(&t2, &t2) );
+		TEST_TRUE( #{subset}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t2, &t1) );
+	}
+
+	test :subset, %{
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t2, 2) );
+		TEST_TRUE( #{put}(&t2, 1) );
+		/* t2 < t1 */
+		TEST_FALSE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t1, &t1) );
+		TEST_TRUE( #{subset}(&t2, &t2) );
+		TEST_FALSE( #{subset}(&t1, &t2) );
+		TEST_TRUE( #{subset}(&t2, &t1) );
+	}
+
+	test :disjoint, %{
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t2, -1) );
+		TEST_TRUE( #{put}(&t2, -2) );
+		TEST_TRUE( #{put}(&t2, -3) );
+		TEST_FALSE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{disjoint}(&t1, &t2) );
+		TEST_TRUE( #{disjoint}(&t2, &t1) );
+		TEST_TRUE( #{put}(&t1, 0) );
+		TEST_TRUE( #{put}(&t2, 0) );
+		TEST_FALSE( #{disjoint}(&t1, &t2) );
+		TEST_FALSE( #{disjoint}(&t2, &t1) );
+	}
+
+	test :disjoint_equal, %{
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		TEST_TRUE( #{put}(&t2, 1) );
+		TEST_TRUE( #{put}(&t2, 2) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		TEST_FALSE( #{disjoint}(&t1, &t2) );
+		TEST_FALSE( #{disjoint}(&t2, &t1) );
+	}
+
+	test :disjoint_empty, %{
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{disjoint}(&t1, &t2) );
+		TEST_TRUE( #{disjoint}(&t2, &t1) );
+	}
+
+	###
+
+	setup %{
+		#{self} t1, t2, r, t;
+		#{create}(&t1);
+		#{create}(&t2);
+		#{create}(&r);
+	}
+
+	cleanup %{
+		#{destroy}(&t1);
+		#{destroy}(&t2);
+		#{destroy}(&r);
+		#{destroy}(&t);
+	}
+
+	test :join_empty, %{
+		#{create_join}(&t, &t1, &t2);
+		#{join}(&t1, &t2);
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&r, &t2) );
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	test :join, %{
+		/* 1,2,3 */
+		TEST_TRUE( #{put}(&r, 1) );
+		TEST_TRUE( #{put}(&r, 2) );
+		TEST_TRUE( #{put}(&r, 3) );
+		/* 1,2 */
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		/* 1,3 */
+		TEST_TRUE( #{put}(&t2, 1) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		#{create_join}(&t, &t1, &t2);
+		#{join}(&t1, &t2); /* 1,2 | 1,3 -> 1,2,3 */
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&t1, &r) );
+		TEST_FALSE( #{equal}(&r, &t2) );
+		TEST_FALSE( #{equal}(&t2, &r) );
+		TEST_TRUE( #{equal}(&t, &r) );
+	}
+
+	test :subtract, %{
+		/* 0,2 */
+		TEST_TRUE( #{put}(&r, 0) );
+		TEST_TRUE( #{put}(&r, 2) );
+		/* 0,1,2 */
+		TEST_TRUE( #{put}(&t1, 0) );
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		/* 1,3 */
+		TEST_TRUE( #{put}(&t2, 1) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		#{create_difference}(&t, &t1, &t2); /* 0,1,2 - 1,3 -> 0,2 */
+		#{subtract}(&t1, &t2);
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&t1, &r) );
+		TEST_FALSE( #{equal}(&r, &t2) );
+		TEST_FALSE( #{equal}(&t2, &r) );
+		TEST_TRUE( #{equal}(&t, &t1) );
+	}
+
+	test :intersect_disjoint, %{
+		/* 1,2,3 */
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		/* -1,-2,-3 */
+		TEST_TRUE( #{put}(&t2, -1) );
+		TEST_TRUE( #{put}(&t2, -2) );
+		TEST_TRUE( #{put}(&t2, -3) );
+		#{create_intersection}(&t, &t1, &t2);
+		#{intersect}(&t1, &t2);
+		TEST_TRUE( #{empty}(&t1) );
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&t1, &r) );
+		TEST_TRUE( #{equal}(&t, &r) );
+		TEST_TRUE( #{empty}(&t) );
+	}
+
+	test :intersect_equal, %{
+		/* 1,2,3 */
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		/* 1,2,3 */
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_TRUE( #{put}(&t2, 2) );
+		TEST_TRUE( #{put}(&t2, 1) );
+		/* 1,2,3 */
+		TEST_TRUE( #{put}(&r, 3) );
+		TEST_TRUE( #{put}(&r, 2) );
+		TEST_TRUE( #{put}(&r, 1) );
+		#{create_intersection}(&t, &t1, &t2);
+		#{intersect}(&t1, &t2); /* 1,2,3 & 1,2,3 -> 1,2,3 */
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&t1, &r) );
+		TEST_TRUE( #{equal}(&r, &t2) );
+		TEST_TRUE( #{equal}(&t2, &r) );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		TEST_TRUE( #{equal}(&t2, &t1) );
+		TEST_TRUE( #{equal}(&t, &r) );
+	}
+
+	test :intersect, %{
+		/* 0,1,2,3 */
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		TEST_TRUE( #{put}(&t1, 3) );
+		/* 0,-1,-2,-3 */
+		TEST_TRUE( #{put}(&t2, -1) );
+		TEST_TRUE( #{put}(&t2, -2) );
+		TEST_TRUE( #{put}(&t2, -3) );
+		TEST_TRUE( #{put}(&t1, 0) );
+		TEST_TRUE( #{put}(&t2, 0) );
+		TEST_TRUE( #{put}(&r, 0) );
+		#{create_intersection}(&t, &t1, &t2);
+		#{intersect}(&t1, &t2); /* 0,1,2,3  &  0,-1,-2,-3 -> 0 */
+		TEST_TRUE( #{equal}(&r, &t1) );
+		TEST_TRUE( #{equal}(&t1, &r) );
+		TEST_FALSE( #{equal}(&r, &t2) );
+		TEST_FALSE( #{equal}(&t2, &r) );
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	test :disjoin_disjoint, %{
+		/* 1,2 */
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		/* 3,4 */
+		TEST_TRUE( #{put}(&t2, 4) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		/* 1,2,3,4 */
+		TEST_TRUE( #{put}(&r, 3) );
+		TEST_TRUE( #{put}(&r, 1) );
+		TEST_TRUE( #{put}(&r, 2) );
+		TEST_TRUE( #{put}(&r, 4) );
+		#{create_disjunction}(&t, &t2, &t1);
+		#{disjoin}(&t1, &t2);
+		TEST_TRUE( #{equal}(&r, &t1) ); /* 1,2 ^ 3,4 -> 1,2,3,4 */
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+	test :disjoin, %{
+		/* 1,2,-3 */
+		TEST_TRUE( #{put}(&t1, -3) );
+		TEST_TRUE( #{put}(&t1, 1) );
+		TEST_TRUE( #{put}(&t1, 2) );
+		/* 3,4, -3 */
+		TEST_TRUE( #{put}(&t2, 4) );
+		TEST_TRUE( #{put}(&t2, 3) );
+		TEST_TRUE( #{put}(&t2, -3) );
+		/* 1,2,3,4 */
+		TEST_TRUE( #{put}(&r, 3) );
+		TEST_TRUE( #{put}(&r, 1) );
+		TEST_TRUE( #{put}(&r, 2) );
+		TEST_TRUE( #{put}(&r, 4) );
+		#{create_disjunction}(&t, &t2, &t1);
+		#{disjoin}(&t1, &t2);
+		TEST_TRUE( #{equal}(&r, &t1) ); /* 1,2, -3 ^ 3,4, -3 -> 1,2,3,4 */
+		TEST_TRUE( #{equal}(&r, &t) );
+	}
+
+end

data/lib/autoc/scaffold/test_int_list.rb

@@ -0,0 +1,106 @@
+require 'autoc/list'
+
+[
+	[:IntListDefault, :int, {}],
+	[:IntListComputedSize, :int, { maintain_size: false }]
+].each do |n, e, kws|
+
+	type_test(AutoC::List, n, e, **kws) do
+
+		###
+
+		setup %{
+			#{self} t;
+			#{create}(&t);
+		}
+
+		cleanup %{
+			#{destroy}(&t);
+		}
+
+		test :create, %{
+			TEST_TRUE( #{empty}(&t) );
+			TEST_EQUAL( #{size}(&t), 0 );
+		}
+
+		test :copy_empty, %{
+			#{self} r;
+			#{copy}(&r, &t);
+			TEST_TRUE( #{equal}(&r, &t) );
+			#{destroy}(&r);
+		}
+
+		test :copy, %{
+			#{self} r;
+			#{push_front}(&t, 1);
+			#{push_front}(&t, 2);
+			#{push_front}(&t, 3);
+			#{copy}(&r, &t);
+			TEST_TRUE( #{equal}(&r, &t) );
+			#{destroy}(&r);
+		}
+
+		###
+
+		setup %{
+			#{self} t;
+			#{create}(&t);
+			#{push_front}(&t, 1);
+			#{push_front}(&t, 2);
+			#{push_front}(&t, 3);
+		}
+
+		cleanup %{
+			#{destroy}(&t);
+		}
+
+		test :remove_none, %{
+			TEST_FALSE( #{remove_first.(:t, 4)} );
+			TEST_EQUAL( #{size.(:t)}, 3 );
+		}
+
+		test :remove_front, %{
+			TEST_TRUE( #{remove_first.(:t, 3)} );
+			TEST_EQUAL( #{size.(:t)}, 2 );
+			TEST_EQUAL( #{take_front.(:t)}, 2 );
+		}
+
+		test :remove_back, %{
+			TEST_TRUE( #{remove_first.(:t, 1)} );
+			TEST_EQUAL( #{size.(:t)}, 2 );
+		}
+
+		test :remove_middle, %{
+			TEST_TRUE( #{remove_first.(:t, 2)} );
+			TEST_EQUAL( #{size.(:t)}, 2 );
+		}
+
+		###
+		
+		setup %{
+			int i, c = 3;
+			#{self} t1, t2;
+			#{create}(&t1);
+			#{create}(&t2);
+			for(i = 0; i < c; ++i) {
+				#{push_front}(&t1, i);
+				#{push_front}(&t2, i);
+			}
+		}
+
+		cleanup %{
+			#{destroy}(&t1);
+			#{destroy}(&t2);
+		}
+
+		test :equal, %{
+			TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
+			TEST_TRUE( #{equal}(&t1, &t2) );
+			#{push_front}(&t2, -1);
+			TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
+			TEST_FALSE( #{equal}(&t1, &t2) );
+		}
+
+	end
+
+end

data/lib/autoc/scaffold/test_int_vector.rb

@@ -0,0 +1,83 @@
+require 'autoc/vector'
+
+IntVector = type_test(AutoC::Vector, :IntVector, :int) do
+
+  ###
+
+  setup %{
+    #{self} t;
+  }
+
+  cleanup %{
+    #{destroy}(&t);
+  }
+
+  test :create, %{
+    #{default_create.(:t)};
+    TEST_EQUAL( #{size}(&t), 0 );
+  }
+
+  test :create_size, %{
+    #{custom_create.(:t, 100)};
+    TEST_EQUAL( #{size}(&t), 100 );
+  }
+
+  ###
+
+  setup %{
+    #{self} t1, t2;
+    int i, c = 3;
+    #{custom_create.(:t1, :c)};
+    #{custom_create.(:t2, :c)};
+    for(i = 0; i < c; ++i) {
+      #{set}(&t1, i, i);
+      #{set}(&t2, i, i);
+      /* 0,1,2 */
+    }
+  }
+
+  cleanup %{
+    #{destroy}(&t1);
+    #{destroy}(&t2);
+  }
+
+  test :equal_identity, %{
+    TEST_TRUE( #{equal.(:t1, :t1)} );
+    TEST_TRUE( #{equal.(:t2, :t2)} );
+  }
+
+  test :equal, %{
+    TEST_TRUE( #{equal.(:t1, :t2)} );
+  }
+
+  test :not_equal, %{
+    #{set}(&t1, 1, -1);
+    TEST_FALSE( #{equal.(:t1, :t2)} );
+  }
+
+  test :sort_resort, %{
+    #{sort}(&t2, -1);
+    TEST_EQUAL( #{get}(&t2, 0), 2);
+    TEST_FALSE( #{equal.(:t1, :t2)} );
+    #{sort}(&t2, +1);
+    TEST_EQUAL( #{get}(&t2, 0), 0);
+    TEST_TRUE( #{equal.(:t1, :t2)} );
+  }
+
+  test :sort_descend, %{
+    #{sort}(&t2, -1);
+    /* 2,1,0 */
+    TEST_FALSE( #{equal.(:t1, :t2)} );
+    TEST_EQUAL( #{get}(&t2, 0), 2 );
+    TEST_EQUAL( #{get}(&t2, 1), 1 );
+  }
+
+  test :sort_ascend, %{
+    #{sort}(&t2, +1);
+    /* 0,1,2 */
+    TEST_TRUE( #{equal.(:t1, :t2)} );
+    TEST_EQUAL( #{get}(&t2, 0), 0 );
+    TEST_EQUAL( #{get}(&t2, 1), 1 );
+  }
+
+end

data/lib/autoc/scaffold/test_v2v_hash_map.rb

@@ -0,0 +1,83 @@
+require 'autoc/hash_map'
+
+type_test(AutoC::HashMap, :Value2HashMap, Value, Value) do
+
+  ###
+
+  setup %{
+    #{self} t;
+  }
+
+  cleanup %{
+    #{destroy}(&t);
+  }
+
+  test :create_empty, %{
+    #{default_create.(:t)};
+  }
+
+  ###
+
+  setup %{
+    #{self} t;
+    #{element} e;
+    #{default_create.(:t)};
+    TEST_TRUE( #{empty.(:t)} );
+    TEST_EQUAL( #{size.(:t)}, 0 );
+    #{element.custom_create.(:e, -1)};
+  }
+
+  cleanup %{
+    #{destroy.(:t)};
+    #{element.destroy.(:e)};
+  }
+
+  test :put_single_identity, %{
+    #{set.(:t, :e, :e)};
+    TEST_FALSE( #{empty.(:t)} );
+    TEST_EQUAL( #{size.(:t)}, 1 );
+  }
+
+  test :put_repeated_identity, %{
+    #{set.(:t, :e, :e)};
+    #{set.(:t, :e, :e)};
+    TEST_FALSE( #{empty.(:t)} );
+    TEST_EQUAL( #{size.(:t)}, 1 );
+  }
+
+  ###
+
+  setup %{
+    #{self} t;
+    #{element} e1, e2;
+    #{default_create.(:t)};
+    TEST_TRUE( #{empty.(:t)} );
+    TEST_EQUAL( #{size.(:t)}, 0 );
+    #{element.custom_create.(:e1, -1)};
+    #{element.custom_create.(:e2, +1)};
+    #{set.(:t, :e1, :e2)};
+    TEST_EQUAL( #{size.(:t)}, 1 );
+  }
+  
+  cleanup %{
+    #{destroy.(:t)};
+    #{element.destroy.(:e1)};
+    #{element.destroy.(:e2)};
+  }
+
+  test :view_contains, %{
+    TEST_TRUE( #{contains.(:t, :e2)} );
+    TEST_FALSE( #{contains.(:t, :e1)} );
+    TEST_FALSE( #{empty.(:t)} );
+    TEST_EQUAL( #{size.(:t)}, 1 );
+  }
+
+  test :remove, %{
+    TEST_TRUE( #{contains.(:t, :e2)} );
+    TEST_FALSE( #{contains.(:t, :e1)} );
+    TEST_FALSE( #{remove.(:t, :e2)} );
+    TEST_TRUE( #{remove.(:t, :e1)} );
+    TEST_TRUE( #{empty.(:t)} );
+  }
+
+end