autoc 1.4 → 2.0.0

data/test/test_value_hash_set.rb

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

@@ -1,193 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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