autoc 1.3 → 1.4

data/test/test_int_tree_set.rb

@@ -0,0 +1,111 @@
+type_test(AutoC::TreeSet, :IntTreeSet, :int) do
+
+setup %~#{type} t; #{ctor}(&t);~
+cleanup %~#{dtor}(&t);~
+
+	test :create, %~
+		TEST_TRUE( #{empty}(&t) );
+		TEST_EQUAL( #{size}(&t), 0 );
+	~
+
+	test :put, %~
+		TEST_EQUAL( #{size}(&t), 0 );
+		TEST_FALSE( #{contains}(&t, 1) );
+		TEST_TRUE( #{put}(&t, 1) );
+		TEST_TRUE( #{contains}(&t, 1) );
+		TEST_FALSE( #{put}(&t, 1) );
+		TEST_EQUAL( #{size}(&t), 1 );
+		TEST_TRUE( #{put}(&t, -1) );
+		TEST_TRUE( #{put}(&t, 2) );
+		TEST_EQUAL( #{size}(&t), 3 );
+		TEST_FALSE( #{contains}(&t, 0) );
+	~
+
+setup %~
+	int i, c = 3;
+	#{type} t1, t2;
+	#{ctor}(&t1);
+	#{ctor}(&t2);
+	for(i = 0; i < c; ++i) {
+		#{put}(&t1, i);
+		#{put}(&t2, i);
+	}
+~
+cleanup %~
+	#{dtor}(&t1);
+	#{dtor}(&t2);
+~
+
+	test :equal, %~
+		TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
+		TEST_TRUE( #{equal}(&t1, &t2) );
+		#{put}(&t2, -1);
+		TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
+		TEST_FALSE( #{equal}(&t1, &t2) );
+	~
+
+setup %~
+	int values[] = {2,-6,7,-6,1,2,5,7,4,3,1,-6,0};
+	int* p = values;
+	#{type} t;
+	#{ctor}(&t);
+	while(*p != 0) {
+		#{put}(&t, *p);
+		TEST_TRUE( #{contains}(&t, *p) );
+		++p;
+	}
+~
+cleanup %~
+	#{dtor}(&t);
+~
+
+	test :size, %~
+		TEST_EQUAL( #{size}(&t), 7 );
+	~
+
+	test :contains, %~
+		TEST_TRUE( #{contains}(&t, 1) );
+		TEST_FALSE( #{contains}(&t, -1) );
+	~
+
+	test :iterateAscending, %~
+		int cur, pre, start = 1;
+		#{it} it;
+		#{itCtorEx}(&it, &t, 1);
+		cur = pre = #{peekLowest}(&t);
+		while(#{itMove}(&it)) {
+			cur = #{itGet}(&it);
+			if(start) {
+				start = 0;
+			} else {
+				TEST_TRUE( pre < cur );
+				pre = cur;
+			}
+		}
+	~
+
+	test :iterateDescending, %~
+		int cur, pre, start = 1;
+		#{it} it;
+		#{itCtorEx}(&it, &t, 0);
+		cur = pre = #{peekHighest}(&t);
+		while(#{itMove}(&it)) {
+			cur = #{itGet}(&it);
+			if(start) {
+				start = 0;
+			} else {
+				TEST_TRUE( pre > cur );
+				pre = cur;
+			}
+		}
+	~
+
+	test :peekHighest, %~
+		TEST_EQUAL( #{peekHighest}(&t), 7 );
+	~
+
+	test :peekLowest, %~
+		TEST_EQUAL( #{peekLowest}(&t), -6 );
+	~
+
+end

data/test/test_value_hash_map.rb

@@ -1,6 +1,6 @@
 require "value"
 
-type_test(AutoC::HashMap, :ValueMap, Value, Value) do
+type_test(AutoC::HashMap, :ValueHashMap, Value, Value) do
   
 	def write_defs(stream)
 		stream << %~

data/test/test_value_hash_set.rb

@@ -1,6 +1,6 @@
 require "value"
 
-type_test(AutoC::HashSet, :ValueSet, Value) do
+type_test(AutoC::HashSet, :ValueHashSet, Value) do
   
 	def write_defs(stream)
 		stream << %~

data/test/test_value_tree_map.rb

@@ -0,0 +1,176 @@
+require "value"
+
+type_test(AutoC::TreeMap, :ValueTreeMap, Value, Value) do
+  
+	def write_defs(stream)
+		stream << %~
+			#undef PUT
+			#define PUT(t, k, v) {#{key.type} ek; #{value.type} ev; #{key.ctorEx}(ek, k); #{value.ctorEx}(ev, v); #{put}(t, ek, ev); #{key.dtor}(ek); #{value.dtor}(ev);}
+		~
+		super
+	end
+
+setup %~#{type} t;~
+cleanup %~#{dtor}(&t);~
+
+	test :create, %~
+		#{ctor}(&t);
+		TEST_EQUAL( #{size}(&t), 0 );
+		TEST_TRUE( #{empty}(&t) );
+	~
+
+	test :purge, %~
+		#{ctor}(&t);
+		PUT(&t, 0, 0);
+		TEST_FALSE( #{empty}(&t) );
+		#{purge}(&t);
+		TEST_TRUE( #{empty}(&t) );
+	~
+
+	test :empty, %~
+		#{ctor}(&t);
+		TEST_TRUE( #{empty}(&t) );
+		PUT(&t, 1, -1);
+		TEST_FALSE( #{empty}(&t) );
+	~
+
+	test :size, %~
+		#{ctor}(&t);
+		TEST_TRUE( #{empty}(&t) );
+		TEST_EQUAL( #{size}(&t), 0 );
+		PUT(&t, 1, -1);
+		TEST_FALSE( #{empty}(&t) );
+		TEST_EQUAL( #{size}(&t), 1 );
+	~
+
+setup %~
+	/* {i => -i} */
+	int i, c = 3;
+	#{type} t;
+	#{key.type} k;
+	#{element.type} v;
+	#{ctor}(&t);
+	for(i = 1; i <= c; i++) {
+		PUT(&t, i, -i);
+	}
+~
+cleanup %~
+	#{dtor}(&t);
+~
+
+	test :copy, %~
+		#{type} t2;
+		#{copy}(&t2, &t);
+		TEST_TRUE( #{equal}(&t2, &t) );
+		#{dtor}(&t2);
+	~
+
+	test :equal, %~
+		#{type} t2;
+		#{copy}(&t2, &t);
+		TEST_TRUE( #{equal}(&t2, &t) );
+		PUT(&t2, -1, 1);
+		TEST_FALSE( #{equal}(&t2, &t) );
+		#{dtor}(&t2);
+	~
+
+	test :containsKey, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 0);
+		TEST_FALSE( #{containsKey}(&t, k) );
+		#{element.set}(k, 1);
+		TEST_TRUE( #{containsKey}(&t, k) );
+		#{element.dtor(:k)};
+	~
+
+	test :get, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 3);
+		TEST_TRUE( #{containsKey}(&t, k) );
+		v = #{get}(&t, k);
+		TEST_EQUAL( #{element.get}(v), -3 );
+		#{element.dtor(:v)};
+		#{element.dtor(:k)};
+	~
+
+	test :putNew, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 0);
+		TEST_FALSE( #{containsKey}(&t, k) );
+		TEST_TRUE( #{put}(&t, k, k) ) ;
+		#{element.dtor(:k)};
+	~
+
+	test :putExisting, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 1);
+		TEST_TRUE( #{containsKey}(&t, k) );
+		TEST_FALSE( #{put}(&t, k, k) ) ;
+		#{element.dtor(:k)};
+	~
+
+	test :remove, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 1);
+		TEST_TRUE( #{containsKey}(&t, k) );
+		TEST_TRUE( #{remove}(&t, k) ) ;
+		TEST_FALSE( #{containsKey}(&t, k) );
+		#{element.dtor(:k)};
+	~
+
+	test :removeNone, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 0);
+		TEST_FALSE( #{containsKey}(&t, k) );
+		TEST_FALSE( #{remove}(&t, k) ) ;
+		TEST_FALSE( #{containsKey}(&t, k) );
+		#{element.dtor(:k)};
+	~
+
+	test :replace, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 1);
+		TEST_TRUE( #{containsKey}(&t, k) );
+		TEST_TRUE( #{replace}(&t, k, k) ) ;
+		TEST_TRUE( #{containsKey}(&t, k) );
+		#{element.dtor(:k)};
+	~
+
+	test :replaceNone, %~
+		#{element.ctor(:k)};
+		#{element.set}(k, 0);
+		TEST_FALSE( #{containsKey}(&t, k) );
+		TEST_FALSE( #{replace}(&t, k, k) ) ;
+		TEST_FALSE( #{containsKey}(&t, k) );
+		#{element.dtor(:k)};
+	~
+
+	test :iterateAscending, %~
+		#{it} it;
+		#{itCtor}(&it, &t);
+		while(#{itMove}(&it)) {
+			#{key.type} k;
+			#{element.type} v;
+			k = #{itGetKey}(&it);
+			v = #{itGetElement}(&it);
+			TEST_EQUAL( #{key.get}(k), -#{value.get}(v) );
+			#{key.dtor}(k);
+			#{value.dtor}(v);
+		}
+	~
+
+	test :iterateDescending, %~
+		#{it} it;
+		#{itCtorEx}(&it, &t, 0);
+		while(#{itMove}(&it)) {
+			#{key.type} k;
+			#{element.type} v;
+			k = #{itGetKey}(&it);
+			v = #{itGetElement}(&it);
+			TEST_EQUAL( #{key.get}(k), -#{value.get}(v) );
+			#{key.dtor}(k);
+			#{value.dtor}(v);
+		}
+	~
+
+end

data/test/test_value_tree_set.rb

@@ -0,0 +1,173 @@
+require "value"
+
+type_test(AutoC::TreeSet, :ValueTreeSet, Value) do
+  
+  def write_defs(stream)
+    stream << %~
+      #undef PUT
+      #define PUT(t, v) {#{element.type} e; #{element.ctorEx}(e, v); #{put}(t, e); #{element.dtor}(e);}
+    ~
+    super
+  end
+
+setup %~#{type} t;~
+cleanup %~#{dtor}(&t);~
+
+  test :create, %~
+    #{ctor}(&t);
+    TEST_EQUAL( #{size}(&t), 0 );
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+  test :purge, %~
+    #{ctor}(&t);
+    PUT(&t, 0);
+    TEST_FALSE( #{empty}(&t) );
+    #{purge}(&t);
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+setup %~
+  /* a: [1,2,3], e: 0 */
+  #{type} a;
+  #{element.type} e;
+  #{element.ctor(:e)};
+  #{ctor}(&a);
+  PUT(&a, 1); PUT(&a, 2); PUT(&a, 3);
+~
+cleanup %~
+  #{dtor}(&a);
+  #{element.dtor(:e)};
+~
+
+  test :contains, %~
+    TEST_FALSE( #{contains}(&a, e) );
+    #{element.set}(e, 1);
+    TEST_TRUE( #{contains}(&a, e) );
+  ~
+
+  test :get, %~
+    #{element.type} e2;
+    #{element.set}(e, -1);
+    #{put}(&a, e);
+    e2 = #{get}(&a, e);
+    TEST_TRUE( #{element.equal}(e, e2) );
+    #{element.dtor(:e2)};
+  ~
+
+  test :putNew, %~
+    #{element.set}(e, -1);
+    TEST_FALSE( #{contains}(&a, e) );
+    TEST_TRUE( #{put}(&a, e) );
+    TEST_TRUE( #{contains}(&a, e) );
+  ~
+
+  test :putExisting, %~
+    #{element.set}(e, -1);
+    TEST_FALSE( #{contains}(&a, e) );
+    TEST_TRUE( #{put}(&a, e) );
+    TEST_TRUE( #{contains}(&a, e) );
+    TEST_FALSE( #{put}(&a, e) );
+  ~
+
+  test :replace, %~
+    #{element.set}(e, 1);
+    TEST_TRUE( #{contains}(&a, e) );
+    TEST_TRUE( #{replace}(&a, e) );
+    TEST_TRUE( #{contains}(&a, e) );
+  ~
+
+  test :replaceNone, %~
+    #{element.set}(e, -1);
+    TEST_FALSE( #{contains}(&a, e) );
+    TEST_FALSE( #{replace}(&a, e) );
+    TEST_FALSE( #{contains}(&a, e) );
+  ~
+
+  test :remove, %~
+    #{element.set}(e, 1);
+    TEST_TRUE( #{contains}(&a, e) );
+    TEST_TRUE( #{remove}(&a, e) );
+    TEST_FALSE( #{contains}(&a, e) );
+  ~
+
+  test :removeNone, %~
+    #{element.set}(e, -1);
+    TEST_FALSE( #{contains}(&a, e) );
+    TEST_FALSE( #{remove}(&a, e) );
+  ~
+
+  test :iterate, %~
+    #{it} it;
+    size_t i = 0;
+    #{itCtor}(&it, &a);
+    while(#{itMove}(&it)) {
+      #{element.type} e2 = #{itGet}(&it);
+      #{element.dtor(:e2)};
+      i++;
+    }
+    TEST_EQUAL( #{size}(&a), i );
+  ~
+
+setup %~
+  /* a: [1,2,3] */
+  #{type} a, b;
+  #{ctor}(&a);
+  PUT(&a, 1); PUT(&a, 2); PUT(&a, 3);
+~
+cleanup %~
+  #{dtor}(&a);
+  #{dtor}(&b);
+~
+
+  test :copy, %~
+    #{copy}(&b, &a);
+    TEST_TRUE( #{equal}(&a, &b) );
+  ~
+
+  test :empty, %~
+    #{ctor}(&b);
+    TEST_FALSE( #{empty}(&a) );
+    TEST_TRUE( #{empty}(&b) );
+  ~
+
+setup %~
+  /* a: [1,2,3], b: [2,3,4] */
+  #{type} a, b, c;
+  #{ctor}(&a);
+  #{ctor}(&b);
+  #{ctor}(&c);
+  PUT(&a, 1); PUT(&a, 2); PUT(&a, 3);
+  PUT(&b, 4); PUT(&b, 2); PUT(&b, 3);
+~
+cleanup %~
+  #{dtor}(&a);
+  #{dtor}(&b);
+  #{dtor}(&c);
+~
+
+  test :exclude, %~
+    PUT(&c, 1);
+    #{exclude}(&a, &b);
+    TEST_TRUE( #{equal}(&a, &c) );
+  ~
+
+  test :include, %~
+    PUT(&c, 1); PUT(&c, 2); PUT(&c, 3); PUT(&c, 4);
+    #{include}(&a, &b);
+    TEST_TRUE( #{equal}(&a, &c) );
+  ~
+
+  test :invert, %~
+    PUT(&c, 1); PUT(&c, 4);
+    #{invert}(&a, &b);
+    TEST_TRUE( #{equal}(&a, &c) );
+  ~
+
+  test :retain, %~
+    PUT(&c, 2); PUT(&c, 3);
+    #{retain}(&a, &b);
+    TEST_TRUE( #{equal}(&a, &c) );
+  ~
+
+end