autoc 1.4 → 2.0.0

data/test/test_value_tree_map.rb

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

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

data/test/test_value_vector.rb

@@ -1,155 +0,0 @@
-require "value"
-
-
-type_test(AutoC::Vector, :ValueVector, Value) do
-  
-setup %~#{type} t;~
-cleanup %~#{dtor}(&t);~
-
-  test :createSmallest, %~
-    #{ctor}(&t, 1);
-    TEST_EQUAL( #{size}(&t), 1 );
-  ~
-    
-  test :createLarge, %~
-    #{ctor}(&t, 1024);
-    TEST_EQUAL( #{size}(&t), 1024 );
-  ~
-    
-setup %~
-  #{type} t;
-  #{element.type} e;
-  int i, c = 3;
-  #{ctor}(&t, c);
-  for(i = 0; i < c; ++i) {
-    #{element.ctorEx}(e, i);
-    #{set}(&t, i, e);
-    #{element.dtor}(e);
-  }
-~
-cleanup %~#{dtor}(&t);~
-
-
-  test :get, %~
-    #{element.type} e2;
-    #{element.ctorEx}(e, 2);
-    e2 = #{get}(&t, 2);
-    TEST_TRUE( #{element.equal}(e, e2) );
-    #{element.dtor}(e);
-    #{element.dtor}(e2);
-  ~
-
-  test :set, %~
-    #{element.type} e2;
-    #{element.ctorEx}(e, -1);
-    #{set}(&t, 2, e);
-    e2 = #{get}(&t, 2);
-    TEST_TRUE( #{element.equal}(e, e2) );
-    #{element.dtor}(e);
-    #{element.dtor}(e2);
-  ~
-
-  test :within, %~
-    TEST_TRUE( #{within}(&t, 0) );
-    TEST_TRUE( #{within}(&t, 2) );
-    TEST_FALSE( #{within}(&t, 3) );
-  ~
-
-  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 = c-1;
-    while(#{itMove}(&it)) {
-      e = #{itGet}(&it);
-      TEST_EQUAL( #{element.get}(e), i-- );
-      #{element.dtor}(e);
-    }
-  ~
-
-setup %~
-  #{type} t1, t2;
-  #{element.type} e;
-  int i, c = 3;
-  #{ctor}(&t1, c);
-  #{ctor}(&t2, c);
-  TEST_TRUE( #{equal}(&t1, &t2) );
-  for(i = 0; i < c; ++i) {
-    #{element.ctorEx}(e, i);
-    #{set}(&t1, i, e);
-    #{set}(&t2, i, e);
-    #{element.dtor}(e);
-  }
-  TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-cleanup %~
-  #{dtor}(&t1);
-  #{dtor}(&t2);
-~
-
-  test :size, %~
-    TEST_EQUAL( #{size}(&t1), 3 );
-    TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
-    #{resize}(&t2, 1);
-    TEST_EQUAL( #{size}(&t2), 1 );
-    TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
-  ~
-
-  test :equal, %~
-    #{element.ctorEx}(e, -1);
-    #{set}(&t1, 0, e);
-    #{element.dtor}(e);
-    TEST_FALSE( #{equal}(&t1, &t2) );
-  ~
-
-  test :resizeShrink, %~
-    #{resize}(&t2, 2);
-    TEST_EQUAL( #{size}(&t2), 2 );
-    TEST_FALSE( #{equal}(&t1, &t2) );
-  ~
-
-  test :resizeExpand, %~
-    #{resize}(&t2, 4);
-    TEST_EQUAL( #{size}(&t2), 4 );
-    TEST_FALSE( #{equal}(&t1, &t2) );
-    e = #{get}(&t2, 3);
-    TEST_EQUAL( #{element.get}(e), 0 );
-    TEST_NOT_EQUAL( #{element.get}(e), 1 );
-    #{element.dtor}(e);
-  ~
-
-  test :sort, %~
-    #{sort}(&t2);
-    TEST_TRUE( #{equal}(&t1, &t2) );
-    e = #{get}(&t2, 0);
-    TEST_EQUAL( #{element.get}(e), 0 );
-    #{element.dtor}(e);
-    #{sortEx}(&t2, 0);
-    TEST_FALSE( #{equal}(&t1, &t2) );
-    e = #{get}(&t2, 0);
-    TEST_EQUAL( #{element.get}(e), 2 );
-    #{element.dtor}(e);
-  ~
-
-end

data/test/value.rb

@@ -1,80 +0,0 @@
-require "autoc"
-
-
-Value = Class.new(AutoC::UserDefinedType) do
-  def write_intf(stream)
-    super
-    stream << %~
-      typedef struct {
-        int* value;
-      } Value;
-      #define ValueCtor(self) _ValueCtor(&self)
-      #define ValueCtorEx(self, v) _ValueCtorEx(&self, v)
-      #define ValueDtor(self) _ValueDtor(&self)
-      #define ValueCopy(dst, src) _ValueCopy(&dst, &src)
-      #define ValueEqual(lt, rt) _ValueEqual(&lt, &rt)
-      #define ValueLess(lt, rt) _ValueLess(&lt, &rt)
-      #define ValueIdentify(self) _ValueIdentify(&self)
-      #define ValueGet(self) *(self).value
-      #define ValueSet(self, x) *(self).value = (x)
-      void _ValueCtor(Value*);
-      void _ValueCtorEx(Value*, int);
-      void _ValueDtor(Value*);
-      void _ValueCopy(Value*, Value*);
-      int _ValueEqual(Value*, Value*);
-      int _ValueLess(Value*, Value*);
-      size_t _ValueIdentify(Value*);
-    ~
-  end
-  def write_defs(stream)
-    super
-    stream << %~
-      void _ValueCtor(Value* self) {
-        #{assert}(self);
-        self->value = #{calloc}(1, sizeof(int)); #{assert}(self->value);
-      }
-      void _ValueCtorEx(Value* self, int value) {
-        #{assert}(self);
-        ValueCtor(*self);
-        *self->value = value;
-      }
-      void _ValueDtor(Value* self) {
-        #{assert}(self);
-        #{free}(self->value);
-      }
-      void _ValueCopy(Value* dst, Value* src) {
-        #{assert}(src);
-        #{assert}(dst);
-        #{assert}(src->value);
-        ValueCtorEx(*dst, *src->value);
-      }
-      int _ValueEqual(Value* lt, Value* rt) {
-        #{assert}(lt);
-        #{assert}(rt);
-        #{assert}(lt->value);
-        #{assert}(rt->value);
-        return *lt->value == *rt->value;
-      }
-      int _ValueLess(Value* lt, Value* rt) {
-        #{assert}(lt);
-        #{assert}(rt);
-      #{assert}(lt->value);
-      #{assert}(rt->value);
-        return *lt->value < *rt->value;
-      }
-      size_t _ValueIdentify(Value* self) {
-        #{assert}(self);
-        #{assert}(self->value);
-        return *self->value ^ 0xAAAA;
-      }
-    ~
-  end
-end.new(
-  :type => :Value,
-  :ctor => :ValueCtor,
-  :dtor => :ValueDtor,
-  :copy => :ValueCopy,
-  :equal => :ValueEqual,
-  :less => :ValueLess,
-  :identify => :ValueIdentify
-)