autoc 1.2 → 1.3

data/test/test_value_hash_set.rb

@@ -0,0 +1,173 @@
+require "value"
+
+type_test(AutoC::HashSet, :ValueSet, 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

data/test/test_value_list.rb

@@ -0,0 +1,193 @@
+require "value"
+
+type_test(AutoC::List, :ValueList, Value) do
+  
+setup %~#{type} t;~
+cleanup %~#{dtor}(&t);~
+
+  test :create, %~
+    #{ctor}(&t);
+    TEST_EQUAL( #{size}(&t), 0 );
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+setup %~
+  /* [0,1,2] */
+  #{type} t;
+  #{element.type} e;
+  int i, c = 3;
+  #{ctor}(&t);
+  for(i = 0; i < c; ++i) {
+    #{element.ctorEx}(e, i);
+    #{push}(&t, e);
+    #{element.dtor(:e)};
+  }
+~
+cleanup %~#{dtor}(&t);~
+
+	test :copy, %~
+		#{type} t2;
+		#{copy}(&t2, &t);
+		TEST_TRUE( #{equal}(&t2, &t) );
+		{
+			#{it} it;
+			#{itCtor}(&it, &t);
+			while(#{itMove}(&it)) {
+        #{element.get}(e = #{itGet}(&it));
+        #{element.dtor(:e)};
+			}
+		}
+		#{dtor}(&t2);
+	~
+
+  test :iterate, %~
+    #{it} it;
+    #{itCtor}(&it, &t);
+    i = #{size}(&t)-1;
+    while(#{itMove}(&it)) {
+      e = #{itGet}(&it);
+      TEST_EQUAL( #{element.get}(e), i-- );
+      #{element.dtor(:e)};
+    }
+  ~
+
+  test :purge, %~
+    TEST_FALSE( #{empty}(&t) );
+    #{purge}(&t);
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+  test :peek, %~
+    size_t s1 = #{size}(&t);
+    e = #{peek}(&t);
+    TEST_EQUAL( #{element.get}(e), 2 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1, s2 );
+  ~
+
+  test :pop, %~
+    size_t s1 = #{size}(&t);
+    e = #{pop}(&t);
+    TEST_EQUAL( #{element.get}(e), 2 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1-1, s2 );
+  ~
+
+  test :push, %~
+    size_t s1 = #{size}(&t);
+    #{element.ctorEx}(e, -1);
+    #{push}(&t, e);
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1+1, s2 );
+    e = #{peek}(&t);
+    TEST_EQUAL( #{element.get}(e), -1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :contains, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{contains}(&t, e) );
+    #{element.set}(e, 1);
+    TEST_TRUE( #{contains}(&t, e) );
+    #{element.dtor(:e)};
+  ~
+
+  test :find, %~
+    #{element.type} e2;
+    #{element.ctorEx}(e, 1);
+    e2 = #{find}(&t, e);
+    TEST_TRUE( #{element.equal}(e, e2) );
+    #{element.dtor(:e)};
+    #{element.dtor(:e2)};
+  ~
+
+setup %~
+  /* [0,1,2,0] */
+  #{type} t1, t2;
+  #{element.type} e;
+  int i, c = 3;
+  #{ctor}(&t1);
+  #{ctor}(&t2);
+  TEST_TRUE( #{equal}(&t1, &t2) );
+  for(i = 0; i < c; ++i) {
+    #{element.ctorEx}(e, i);
+    #{push}(&t1, e);
+    #{push}(&t2, e);
+    #{element.dtor(:e)};
+  }
+  #{element.ctorEx}(e, 0);
+  #{push}(&t1, e);
+  #{push}(&t2, e);
+  #{element.dtor(:e)};
+  TEST_TRUE( #{equal}(&t1, &t2) );
+  ~
+cleanup %~
+  #{dtor}(&t1);
+  #{dtor}(&t2);
+~
+
+  test :equal, %~
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.ctorEx}(e, -1);
+    #{push}(&t2, e);
+    #{element.dtor(:e)};
+    TEST_FALSE( #{equal}(&t1, &t2) );
+  ~
+
+  test :replaceNone, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{replace}(&t2, e) );
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replace}(&t2, e), 1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceExactOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replaceEx}(&t2, e, 1), 1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceAll, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replaceAll}(&t2, e), 2 );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeNone, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{remove}(&t2, e) );
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{remove}(&t2, e), 1 );
+    TEST_EQUAL( #{size}(&t1)-1, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeExactOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{removeEx}(&t2, e, 1), 1 );
+    TEST_EQUAL( #{size}(&t1)-1, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeAll, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{removeAll}(&t2, e), 2 );
+    TEST_EQUAL( #{size}(&t1)-2, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+end

data/test/test_value_queue.rb

@@ -0,0 +1,275 @@
+require "value"
+
+type_test(AutoC::Queue, :ValueQueue, Value) do
+  
+setup %~#{type} t;~
+cleanup %~#{dtor}(&t);~
+
+  test :create, %~
+    #{ctor}(&t);
+    TEST_EQUAL( #{size}(&t), 0 );
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+setup %~
+  /* [0,1,2] */
+  #{type} t;
+  #{element.type} e;
+  int i, c = 3;
+  #{ctor}(&t);
+  for(i = 0; i < c; ++i) {
+    #{element.ctorEx}(e, i);
+    #{push}(&t, e);
+    #{element.dtor(:e)};
+  }
+~
+cleanup %~#{dtor}(&t);~
+
+	test :copy, %~
+		#{type} t2;
+		#{copy}(&t2, &t);
+		TEST_TRUE( #{equal}(&t2, &t) );
+		{
+			#{it} it;
+			#{itCtor}(&it, &t);
+			while(#{itMove}(&it)) {
+        #{element.get}(e = #{itGet}(&it));
+        #{element.dtor(:e)};
+			}
+		}
+		#{dtor}(&t2);
+	~
+
+  test :iterateForward, %~
+    #{it} it;
+    #{itCtor}(&it, &t);
+    i = 0;
+    while(#{itMove}(&it)) {
+      e = #{itGet}(&it);
+      TEST_EQUAL( #{element.get}(e), i++ );
+      #{element.dtor}(e);
+    }
+  ~
+
+  test :iterateExactForward, %~
+    #{it} it;
+    #{itCtorEx}(&it, &t, 1);
+    i = 0;
+    while(#{itMove}(&it)) {
+      e = #{itGet}(&it);
+      TEST_EQUAL( #{element.get}(e), i++ );
+      #{element.dtor}(e);
+    }
+  ~
+
+  test :iterateBackward, %~
+    #{it} it;
+    #{itCtorEx}(&it, &t, 0);
+    i = #{size}(&t)-1;
+    while(#{itMove}(&it)) {
+      e = #{itGet}(&it);
+      TEST_EQUAL( #{element.get}(e), i-- );
+      #{element.dtor(:e)};
+    }
+  ~
+
+  test :purge, %~
+    TEST_FALSE( #{empty}(&t) );
+    #{purge}(&t);
+    TEST_TRUE( #{empty}(&t) );
+  ~
+
+  test :peek, %~
+    size_t s1 = #{size}(&t);
+    e = #{peek}(&t);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1, s2 );
+  ~
+
+  test :peekHead, %~
+    size_t s1 = #{size}(&t);
+    e = #{peekHead}(&t);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1, s2 );
+  ~
+
+  test :peekTail, %~
+    size_t s1 = #{size}(&t);
+    e = #{peekTail}(&t);
+    TEST_EQUAL( #{element.get}(e), 2 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1, s2 );
+  ~
+
+  test :pop, %~
+    size_t s1 = #{size}(&t);
+    e = #{pop}(&t);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1-1, s2 );
+  ~
+
+  test :popHead, %~
+    size_t s1 = #{size}(&t);
+    e = #{popHead}(&t);
+    TEST_EQUAL( #{element.get}(e), 0 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1-1, s2 );
+  ~
+
+  test :popTail, %~
+    size_t s1 = #{size}(&t);
+    e = #{popTail}(&t);
+    TEST_EQUAL( #{element.get}(e), 2 );
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1-1, s2 );
+  ~
+
+  test :push, %~
+    size_t s1 = #{size}(&t);
+    #{element.ctorEx}(e, -1);
+    #{push}(&t, e);
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1+1, s2 );
+    e = #{peekTail}(&t);
+    TEST_EQUAL( #{element.get}(e), -1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :pushTail, %~
+    size_t s1 = #{size}(&t);
+    #{element.ctorEx}(e, -1);
+    #{pushTail}(&t, e);
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1+1, s2 );
+    e = #{peekTail}(&t);
+    TEST_EQUAL( #{element.get}(e), -1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :pushHead, %~
+    size_t s1 = #{size}(&t);
+    #{element.ctorEx}(e, -1);
+    #{pushHead}(&t, e);
+    #{element.dtor(:e)};
+    size_t s2 = #{size}(&t);
+    TEST_EQUAL( s1+1, s2 );
+    e = #{peekHead}(&t);
+    TEST_EQUAL( #{element.get}(e), -1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :contains, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{contains}(&t, e) );
+    #{element.set}(e, 1);
+    TEST_TRUE( #{contains}(&t, e) );
+    #{element.dtor(:e)};
+  ~
+
+  test :find, %~
+    #{element.type} e2;
+    #{element.ctorEx}(e, 1);
+    e2 = #{find}(&t, e);
+    TEST_TRUE( #{element.equal}(e, e2) );
+    #{element.dtor(:e)};
+    #{element.dtor(:e2)};
+  ~
+
+setup %~
+  /* [0,1,2,0] */
+  #{type} t1, t2;
+  #{element.type} e;
+  int i, c = 3;
+  #{ctor}(&t1);
+  #{ctor}(&t2);
+  TEST_TRUE( #{equal}(&t1, &t2) );
+  for(i = 0; i < c; ++i) {
+    #{element.ctorEx}(e, i);
+    #{push}(&t1, e);
+    #{push}(&t2, e);
+    #{element.dtor(:e)};
+  }
+  #{element.ctorEx}(e, 0);
+  #{push}(&t1, e);
+  #{push}(&t2, e);
+  #{element.dtor(:e)};
+  TEST_TRUE( #{equal}(&t1, &t2) );
+  ~
+cleanup %~
+  #{dtor}(&t1);
+  #{dtor}(&t2);
+~
+
+  test :equal, %~
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.ctorEx}(e, -1);
+    #{push}(&t2, e);
+    #{element.dtor(:e)};
+    TEST_FALSE( #{equal}(&t1, &t2) );
+  ~
+
+  test :replaceNone, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{replace}(&t2, e) );
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replace}(&t2, e), 1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceExactOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replaceEx}(&t2, e, 1), 1 );
+    #{element.dtor(:e)};
+  ~
+
+  test :replaceAll, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{replaceAll}(&t2, e), 2 );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeNone, %~
+    #{element.ctorEx}(e, -1);
+    TEST_FALSE( #{remove}(&t2, e) );
+    TEST_TRUE( #{equal}(&t1, &t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{remove}(&t2, e), 1 );
+    TEST_EQUAL( #{size}(&t1)-1, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeExactOne, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{removeEx}(&t2, e, 1), 1 );
+    TEST_EQUAL( #{size}(&t1)-1, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+  test :removeAll, %~
+    #{element.ctorEx}(e, 0);
+    TEST_EQUAL( #{removeAll}(&t2, e), 2 );
+    TEST_EQUAL( #{size}(&t1)-2, #{size}(&t2) );
+    #{element.dtor(:e)};
+  ~
+
+end