autoc 1.2 → 1.3

data/test/test_value_vector.rb

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

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

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: autoc
 version: !ruby/object:Gem::Version
-  version: '1.2'
+  version: '1.3'
 platform: ruby
 authors:
 - Oleg A. Khlybov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-22 00:00:00.000000000 Z
+date: 2016-03-17 00:00:00.000000000 Z
 dependencies: []
 description: |2
       AutoC is a collection of Ruby modules related to automatic C source code generation:
       1) Multi-file C module generator.
-      2) Generators for strongly-typed generic collections similar to those from the C++ standard template library.
+      2) Generators for strongly-typed generic collections (Vector, List, Set etc.).
 email: fougas@mail.ru
 executables: []
 extensions: []
@@ -35,6 +35,7 @@ files:
 - doc/AutoC/Priority.html
 - doc/AutoC/Queue.html
 - doc/AutoC/Reference.html
+- doc/AutoC/String.html
 - doc/AutoC/Type.html
 - doc/AutoC/UserDefinedType.html
 - doc/AutoC/Vector.html
@@ -61,12 +62,18 @@ files:
 - lib/autoc/collection/list.rb
 - lib/autoc/collection/queue.rb
 - lib/autoc/collection/vector.rb
+- lib/autoc/string.rb
 - lib/autoc/type.rb
-- test/test.c
-- test/test.h
 - test/test.rb
-- test/test_auto.c
-- test/test_auto.h
+- test/test_char_string.rb
+- test/test_int_list.rb
+- test/test_int_vector.rb
+- test/test_value_hash_map.rb
+- test/test_value_hash_set.rb
+- test/test_value_list.rb
+- test/test_value_queue.rb
+- test/test_value_vector.rb
+- test/value.rb
 homepage: http://autoc.sourceforge.net/
 licenses:
 - BSD
@@ -87,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A host of Ruby modules related to automatic C source code generation

data/test/test.c

@@ -1,1041 +0,0 @@
-/*
- * This test is intended to be run under memory debugger such as Valgrind or Dr.Memory.
- * Normally it should complete without errors and should exhibit no memory-related issues.
- * The test should be compilable with any ANSI C compiler.
- * 
- * > cc test.c test_auto.c
-*/
-
-
-#include <assert.h>
-#include <memory.h>
-#include <stdio.h>
-
-
-#include "test.h"
-#include "test_auto.h"
-
-
-#define SIZE 16
-void ValueTypeCtorEx(ValueType* self, int value) {
-    assert(self);
-    self->value = value;
-    self->block = malloc(SIZE); assert(self->block);
-}
-
-
-void ValueTypeCtorRef(ValueType* self) {
-    ValueTypeCtorEx(self, 0);
-}
-
-
-void ValueTypeDtorRef(ValueType* self) {
-    assert(self);
-    free(self->block);
-}
-
-
-void ValueTypeCopyRef(ValueType* dst, ValueType* src) {
-    assert(src);
-    assert(dst);
-    dst->block = malloc(SIZE); assert(dst->block);
-    dst->value = src->value;
-    memcpy(dst->block, src->block, SIZE);
-}
-
-
-int ValueTypeEqualRef(ValueType* lt, ValueType* rt) {
-    assert(lt);
-    assert(rt);
-    return lt->value == rt->value;
-}
-
-
-int ValueTypeLessRef(ValueType* lt, ValueType* rt) {
-    assert(lt);
-    assert(rt);
-    return lt->value < rt->value;
-}
-
-
-size_t ValueTypeIdentifyRef(ValueType* self) {
-    assert(self);
-    return (size_t)self->value;
-}
-
-
-#undef element
-#define element(x) ValueType##x
-
-
-#undef Type
-#define Type ValueTypeVector
-#undef TypeIt
-#define TypeIt ValueTypeVectorIt
-#undef type
-#define type(x) ValueTypeVector##x
-#undef it
-#define it(x) ValueTypeVectorIt##x
-
-
-static void type(Test)() {
-    ValueType e1, e2;
-    Type c1, c2;
-    TypeIt it;
-    
-    type(Ctor)(&c1, 3);
-    type(Copy)(&c2, &c1);
-    
-    type(Resize)(&c1, 5);
-    type(Size)(&c1);
-    type(Equal)(&c1, &c2);
-    type(Resize)(&c1, 3);
-    type(Size)(&c1);
-    type(Equal)(&c1, &c2);
-    
-    type(Within)(&c1, 0);
-    type(Within)(&c1, 10);
-    
-    element(CtorEx)(&e1, -1);
-    element(CtorEx)(&e2, +1);
-    type(Set)(&c1, 2, e1);
-    type(Set)(&c1, 0, e2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-    
-    it(CtorEx)(&it, &c2, 0);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-
-    type(Sort)(&c1);
-    type(Sort)(&c2);
-    
-    type(Identify)(&c1);
-    type(Identify)(&c2);
-    
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type ValueTypeList
-#undef TypeIt
-#define TypeIt ValueTypeListIt
-#undef type
-#define type(x) ValueTypeList##x
-#undef it
-#define it(x) ValueTypeListIt##x
-
-
-static void type(Test)() {
-    ValueType e1, e2, e3;
-    Type c1, c2;
-    TypeIt it;
-    
-    type(Ctor)(&c1);
-    type(Copy)(&c2, &c1);
-    
-    type(Equal)(&c1, &c2);
-    type(Empty)(&c1);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-    
-    element(CtorEx)(&e1, -1);
-    element(CtorEx)(&e2, +1);
-    
-    type(Push)(&c1, e1);
-    type(Push)(&c2, e2);
-    type(Contains)(&c1, e1);
-    type(Contains)(&c2, e1);
-    type(Push)(&c1, e2);
-    type(Push)(&c2, e1);
-    type(Empty)(&c1);
-    
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-
-    e1 = type(Peek)(&c1);
-    e2 = type(Peek)(&c2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-
-    type(Identify)(&c1);
-    type(Identify)(&c2);
-
-    e1 = type(Pop)(&c1);
-    e2 = type(Pop)(&c2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-
-    type(Purge)(&c1);
-    type(Purge)(&c2);
-
-    element(CtorEx)(&e1, 3);
-    element(CtorEx)(&e2, -3);
-    element(Copy)(e3, e2);
-    type(Push)(&c1, e1);
-    type(Push)(&c1, e2);
-    type(Push)(&c1, e1);
-    type(Push)(&c2, e2);
-    type(Push)(&c2, e2);
-    type(Push)(&c2, e2);
-    type(Replace)(&c2, e3);
-    type(ReplaceAll)(&c2, e3);
-    type(Remove)(&c1, e2);
-    type(Remove)(&c1, e1);
-    type(Remove)(&c2, e1);
-    type(RemoveAll)(&c2, e2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    element(Dtor)(e3);
-
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type ValueTypeQueue
-#undef TypeIt
-#define TypeIt ValueTypeQueueIt
-#undef type
-#define type(x) ValueTypeQueue##x
-#undef it
-#define it(x) ValueTypeQueueIt##x
-
-
-/*
- * Queue is a non-strict superset of List
- * so the test case for the latter can be reused as-is 
- */
-static void type(Test)() {
-    ValueType e1, e2, e3;
-    Type c1, c2;
-    TypeIt it;
-    
-    type(Ctor)(&c1);
-    type(Copy)(&c2, &c1);
-    
-    type(Equal)(&c1, &c2);
-    type(Empty)(&c1);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-    
-    element(CtorEx)(&e1, -1);
-    element(CtorEx)(&e2, +1);
-    
-    type(Push)(&c1, e1);
-    type(Push)(&c2, e2);
-    type(Contains)(&c1, e1);
-    type(Contains)(&c2, e1);
-    type(Push)(&c1, e2);
-    type(Push)(&c2, e1);
-    type(Empty)(&c1);
-    
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-
-    e1 = type(Peek)(&c1);
-    e2 = type(Peek)(&c2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-
-    type(Identify)(&c1);
-    type(Identify)(&c2);
-
-    e1 = type(Pop)(&c1);
-    e2 = type(Pop)(&c2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-
-    type(Purge)(&c1);
-    type(Purge)(&c2);
-
-    element(CtorEx)(&e1, 3);
-    element(CtorEx)(&e2, -3);
-    element(Copy)(e3, e2);
-    type(Push)(&c1, e1);
-    type(Push)(&c1, e2);
-    type(Push)(&c1, e1);
-    type(Push)(&c2, e2);
-    type(Push)(&c2, e2);
-    type(Push)(&c2, e2);
-    type(Replace)(&c2, e3);
-    type(ReplaceAll)(&c2, e3);
-    type(Remove)(&c1, e2);
-    type(Remove)(&c1, e1);
-    type(Remove)(&c2, e1);
-    type(RemoveAll)(&c2, e2);
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    element(Dtor)(e3);
-
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type ValueTypeSet
-#undef TypeIt
-#define TypeIt ValueTypeSetIt
-#undef type
-#define type(x) ValueTypeSet##x
-#undef it
-#define it(x) ValueTypeSetIt##x
-
-
-static void type(Test)() {
-    ValueType e1, e2, e3;
-    Type c1, c2, cc1, cc2;
-    TypeIt it;
-    
-    type(Ctor)(&c1);
-    type(Copy)(&c2, &c1);
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType e = it(Get)(&it);
-        element(Dtor)(e);
-    }
-
-    type(Equal)(&c1, &c2);
-    type(Empty)(&c1);
-    type(Size)(&c1);
-    
-    element(CtorEx)(&e1, -1);
-    element(CtorEx)(&e2, +1);
-    element(CtorEx)(&e3, 0);
-
-    type(Put)(&c1, e1);
-    type(Put)(&c2, e1);
-    type(Equal)(&c1, &c2);
-    type(Put)(&c1, e2);
-    type(Put)(&c2, e3);
-    type(Equal)(&c1, &c2);
-    type(Contains)(&c1, e1);
-    type(Contains)(&c2, e2);
-    {
-        ValueType e = type(Get)(&c2, e3);
-        element(Dtor)(e);
-    }
-    type(Replace)(&c1, e2);
-
-    type(Put)(&c2, e1);
-    type(Put)(&c2, e2);
-    type(Put)(&c2, e3);
-    
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    element(Dtor)(e3);
-    
-    {
-        int i;
-        ValueType e;
-        for(i = 0; i < 100; ++i) {
-            element(CtorEx)(&e, i);
-            type(Put)(&c1, e);
-            element(Dtor)(e);
-        }
-        for(i = 0; i < 100; i += 2) {
-            element(CtorEx)(&e, i);
-            type(Remove)(&c1, e);
-            element(Dtor)(e);
-        }
-        it(Ctor)(&it, &c1);
-        while(it(Move)(&it)) {
-            ValueType e = it(Get)(&it);
-            element(Dtor)(e);
-        }
-    }
-    
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Retain)(&cc1, &cc2);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-    
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Retain)(&cc2, &cc1);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Include)(&cc1, &cc2);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-    
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Include)(&cc2, &cc1);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Exclude)(&cc1, &cc2);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-    
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Exclude)(&cc2, &cc1);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Invert)(&cc1, &cc2);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-    
-    {
-        type(Copy)(&cc1, &c1);
-        type(Copy)(&cc2, &c2);
-        type(Invert)(&cc2, &cc1);
-        type(Dtor)(&cc1);
-        type(Dtor)(&cc2);
-    }
-
-    type(Identify)(&c1);
-    type(Identify)(&c2);
-
-    type(Purge)(&c1);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type ValueTypeMap
-#undef TypeIt
-#define TypeIt ValueTypeMapIt
-#undef type
-#define type(x) ValueTypeMap##x
-#undef it
-#define it(x) ValueTypeMapIt##x
-
-
-static void type(Test)() {
-    ValueType e1, e2, e3;
-    Type c1, c2;
-    TypeIt it;
-    
-    element(CtorEx)(&e1, -1);
-    element(CtorEx)(&e2, +1);
-    element(CtorEx)(&e3, 0);
-
-    type(Ctor)(&c1);
-    type(Put)(&c1, e1, e3);
-    type(Put)(&c1, e2, e3);
-    type(Copy)(&c2, &c1);
-    
-    type(Put)(&c1, e1, e2);
-    type(Put)(&c2, e2, e1);
-
-    {
-        int i;
-        ValueType e;
-        for(i = 0; i < 100; ++i) {
-            element(CtorEx)(&e, i);
-            type(Put)(&c1, e, e);
-            element(Dtor)(e);
-        }
-        for(i = 0; i < 100; i += 2) {
-            element(CtorEx)(&e, i);
-            type(Remove)(&c1, e);
-            element(Dtor)(e);
-        }
-        for(i = 1; i < 10; ++i) {
-            ValueType k;
-            element(CtorEx)(&k, i);
-            element(CtorEx)(&e, -i);
-            type(Replace)(&c1, k, e);
-            element(Dtor)(k);
-            element(Dtor)(e);
-        }
-    }
-    
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        ValueType k = it(GetKey)(&it), e = it(GetElement)(&it);
-        element(Dtor)(k);
-        element(Dtor)(e);
-    }
-
-    element(Dtor)(e1);
-    element(Dtor)(e2);
-    element(Dtor)(e3);
-
-    type(Equal)(&c1, &c2);
-    type(Empty)(&c1);
-    type(Size)(&c1);
-    
-    type(Identify)(&c1);
-    type(Identify)(&c2);
-
-    type(Purge)(&c1);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type IntSet
-#undef TypeIt
-#define TypeIt IntSetIt
-#undef type
-#define type(x) IntSet##x
-#undef it
-#define it(x) IntSetIt##x
-
-
-/* {1,2,3} & {2,3,4} == {2,3} */
-static void type(TestAnd)() {
-    Type r, c1, c2, cc1, cc2;
-    
-    type(Ctor)(&r);
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-
-    type(Put)(&c1, 1); type(Put)(&c1, 3);
-    type(Put)(&c1, 2);
-    type(Put)(&c1, 3); type(Put)(&c1, 1);
-
-    assert(type(Size)(&c1) == 3);
-
-    type(Copy)(&cc1, &c1);
-
-    type(Put)(&c2, 2);
-    type(Put)(&c2, 3);
-    type(Put)(&c2, 4);
-
-    assert(type(Size)(&c2) == 3);
-
-    type(Copy)(&cc2, &c2);
-
-    assert(!type(Equal)(&c1, &c2));
-    assert(!type(Equal)(&c2, &c1));
-
-    type(Retain)(&c1, &c2);
-    type(Retain)(&cc2, &cc1);
-
-    assert(type(Size)(&c1) == 2);
-    assert(type(Size)(&cc2) == 2);
-
-    type(Put)(&r, 3);
-    type(Put)(&r, 2);
-
-    assert(type(Size)(&r) == 2);
-
-    assert(!type(Empty)(&r));
-    assert(!type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-
-    assert(type(Equal)(&c1, &r));
-    assert(type(Equal)(&r, &c1));
-
-    assert(type(Equal)(&cc2, &c1));
-    assert(type(Equal)(&c1, &cc2));
-
-    type(Dtor)(&r);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-    type(Dtor)(&cc1);
-    type(Dtor)(&cc2);
-}
-
-
-/* {1,2,3} | {2,3,4} == {1,2,3,4} */
-static void type(TestOr)() {
-    Type r, c1, c2, cc1, cc2;
-    
-    type(Ctor)(&r);
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-
-    type(Put)(&c1, 1); type(Put)(&c1, 3);
-    type(Put)(&c1, 2);
-    type(Put)(&c1, 3); type(Put)(&c1, 1);
-
-    assert(type(Size)(&c1) == 3);
-
-    type(Copy)(&cc1, &c1);
-
-    type(Put)(&c2, 2);
-    type(Put)(&c2, 3);
-    type(Put)(&c2, 4);
-
-    assert(type(Size)(&c2) == 3);
-
-    type(Copy)(&cc2, &c2);
-
-    assert(!type(Equal)(&c1, &c2));
-    assert(!type(Equal)(&c2, &c1));
-
-    type(Include)(&c1, &c2);
-    type(Include)(&cc2, &cc1);
-
-    assert(type(Size)(&c1) == 4);
-    assert(type(Size)(&cc2) == 4);
-
-    type(Put)(&r, 3);
-    type(Put)(&r, 2);
-    type(Put)(&r, 1);
-    type(Put)(&r, 4);
-
-    assert(type(Size)(&r) == 4);
-
-    assert(!type(Empty)(&r));
-    assert(!type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-
-    assert(type(Equal)(&c1, &r));
-    assert(type(Equal)(&r, &c1));
-
-    assert(type(Equal)(&cc2, &c1));
-    assert(type(Equal)(&c1, &cc2));
-
-    type(Dtor)(&r);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-    type(Dtor)(&cc1);
-    type(Dtor)(&cc2);
-}
-
-
-/* {1,2,3} ^ {2,3,4} == {1,4} */
-static void type(TestXor)() {
-    Type r, c1, c2, cc1, cc2;
-    
-    type(Ctor)(&r);
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-
-    type(Put)(&c1, 1); type(Put)(&c1, 3);
-    type(Put)(&c1, 2);
-    type(Put)(&c1, 3); type(Put)(&c1, 1);
-
-    assert(type(Size)(&c1) == 3);
-
-    type(Copy)(&cc1, &c1);
-
-    type(Put)(&c2, 2);
-    type(Put)(&c2, 3);
-    type(Put)(&c2, 4);
-
-    assert(type(Size)(&c2) == 3);
-
-    type(Copy)(&cc2, &c2);
-
-    assert(!type(Equal)(&c1, &c2));
-    assert(!type(Equal)(&c2, &c1));
-
-    type(Invert)(&c1, &c2);
-    type(Invert)(&cc2, &cc1);
-
-    assert(type(Size)(&c1) == 2);
-    assert(type(Size)(&cc2) == 2);
-
-    type(Put)(&r, 4);
-    type(Put)(&r, 1);
-
-    assert(type(Size)(&r) == 2);
-
-    assert(!type(Empty)(&r));
-    assert(!type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-
-    assert(type(Equal)(&c1, &r));
-    assert(type(Equal)(&r, &c1));
-
-    assert(type(Equal)(&cc2, &c1));
-    assert(type(Equal)(&c1, &cc2));
-
-    type(Dtor)(&r);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-    type(Dtor)(&cc1);
-    type(Dtor)(&cc2);
-}
-
-
-/* {1,2,3} - {2,3,4} == {1} */
-static void type(TestNot1)() {
-    Type r, c1, c2, cc1, cc2;
-    
-    type(Ctor)(&r);
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-
-    type(Put)(&c1, 1); type(Put)(&c1, 3);
-    type(Put)(&c1, 2);
-    type(Put)(&c1, 3); type(Put)(&c1, 1);
-
-    assert(type(Size)(&c1) == 3);
-
-    type(Copy)(&cc1, &c1);
-
-    type(Put)(&c2, 2);
-    type(Put)(&c2, 3);
-    type(Put)(&c2, 4);
-
-    assert(type(Size)(&c2) == 3);
-
-    type(Copy)(&cc2, &c2);
-
-    assert(!type(Equal)(&c1, &c2));
-    assert(!type(Equal)(&c2, &c1));
-
-    type(Exclude)(&c1, &c2);
-    type(Exclude)(&cc2, &cc1);
-
-    assert(type(Size)(&c1) == 1);
-    assert(type(Size)(&cc2) == 1);
-
-    type(Put)(&r, 1);
-
-    assert(type(Size)(&r) == 1);
-
-    assert(!type(Empty)(&r));
-    assert(!type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-
-    assert(type(Equal)(&c1, &r));
-    assert(type(Equal)(&r, &c1));
-
-    assert(!type(Equal)(&cc2, &c1));
-    assert(!type(Equal)(&c1, &cc2));
-
-    type(Dtor)(&r);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-    type(Dtor)(&cc1);
-    type(Dtor)(&cc2);
-}
-
-
-/* {1,2,3} - {1,2,3,4} == {} */
-static void type(TestNot2)() {
-    Type r, c1, c2;
-    
-    type(Ctor)(&r);
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-
-    type(Put)(&c1, 1); type(Put)(&c1, 3);
-    type(Put)(&c1, 2);
-    type(Put)(&c1, 3); type(Put)(&c1, 1);
-
-    assert(type(Size)(&c1) == 3);
-
-    type(Put)(&c2, 1);
-    type(Put)(&c2, 2);
-    type(Put)(&c2, 3);
-    type(Put)(&c2, 4);
-
-    assert(type(Size)(&c2) == 4);
-
-    assert(!type(Equal)(&c1, &c2));
-    assert(!type(Equal)(&c2, &c1));
-
-    type(Exclude)(&c1, &c2);
-
-    assert(type(Size)(&c1) == 0);
-
-    assert(type(Size)(&r) == 0);
-
-    assert(type(Empty)(&r));
-    assert(type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-
-    assert(type(Equal)(&c1, &r));
-    assert(type(Equal)(&r, &c1));
-
-    type(Dtor)(&r);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type IntStrMap
-#undef TypeIt
-#define TypeIt IntStrMapIt
-#undef type
-#define type(x) IntStrMap##x
-#undef it
-#define it(x) IntStrMapIt##x
-
-
-static const char* zero = "zero";
-static const char* one = "one";
-static const char* two = "two";
-
-
-static void type(Test)() {
-    Type c1, c2;
-    TypeIt it;
-    int i;
-    
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-
-    assert(type(Empty)(&c1));
-    assert(type(Empty)(&c2));
-    assert(type(Equal)(&c1, &c2));
-    
-    assert(type(Put)(&c1, 0, zero));
-    assert(type(Put)(&c1, 1, one));
-    assert(type(Put)(&c1, 2, two));
-    assert(!type(Put)(&c1, 2, two));
-    
-    assert(type(Put)(&c2, 2, two));
-    assert(type(Put)(&c2, 0, zero));
-    assert(type(Put)(&c2, 1, one));
-    assert(!type(Put)(&c2, 0, zero));
-
-    assert(!type(Empty)(&c1));
-    assert(!type(Empty)(&c2));
-    assert(type(Size)(&c1) == type(Size)(&c2));
-    assert(type(Equal)(&c1, &c2));
-    
-    assert(type(ContainsKey)(&c1, 0));
-    assert(type(Remove)(&c1, 0));
-    assert(!type(Remove)(&c1, 0));
-    assert(!type(ContainsKey)(&c1, 0));
-    assert(type(ContainsKey)(&c2, 2));
-    assert(type(Remove)(&c2, 2));
-    assert(!type(ContainsKey)(&c2, 2));
-    assert(type(Size)(&c1) == type(Size)(&c2));
-    assert(!type(Equal)(&c1, &c2));
-
-    type(Purge)(&c1);
-    
-    assert(type(Put)(&c1, 0, zero));
-    assert(type(Put)(&c1, 1, one));
-    assert(type(Put)(&c1, 2, two));
-
-    assert(type(Replace)(&c1, 0, two));
-    assert(type(Replace)(&c1, 2, zero));
-    
-    assert(type(Get)(&c1, 0) == two);
-    assert(type(Get)(&c1, 2) == zero);
-    assert(type(Get)(&c1, 1) == one);
-    
-    i = 0;
-    it(Ctor)(&it, &c1);
-    while(it(Move)(&it)) {
-        int k;
-        const char* e;
-        k = it(GetKey)(&it);
-        e = it(Get)(&it);
-        ++i;
-    }
-    assert(i == 3);
-    
-    type(Purge)(&c2);
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type ListIntSet
-#undef TypeIt
-#define TypeIt ListIntSetIt
-#undef type
-#define type(x) ListIntSet##x
-#undef it
-#define it(x) ListIntSetIt##x
-#undef Element
-#define Element IntSet
-#undef element
-#define element(x) IntSet##x
-
-
-static void type(Test)() {
-    Type c1, c2;
-    Element e;
-    
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-    
-    element(Ctor)(&e);
-    type(Push)(&c1, e);
-    element(Put)(&e, 3);
-    element(Put)(&e, 2);
-    element(Put)(&e, 1);
-    type(Push)(&c2, e);
-    element(Dtor)(&e);
-    
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-}
-
-
-#undef Type
-#define Type Int
-#undef type
-#define type(x) Int##x
-
-
-static void PIntTest() {
-    int *c1, *c2;
-    c1 = type(New)(); *c1 = 1;
-    c2 = type(New)(); *c2 = 2;
-    assert(*c1 != *c2);
-    type(Free)(c2);
-    c2 = type(Ref)(c1);
-    assert(*c1 == *c2);
-    type(Free)(c1);
-    type(Free)(c2);
-}
-
-
-#undef Type
-#define Type ValueType
-#undef type
-#define type(x) ValueType##x
-
-
-static void PValueTypeTest() {
-    ValueType *c1, *c2;
-    c1 = type(New)();
-    c2 = type(New)();
-    type(Free)(c2);
-    c2 = type(Ref)(c1);
-    type(Free)(c1);
-    type(Free)(c2);
-}
-
-
-/* List<Vector<ValueType*>*> */
-#undef Type
-#define Type ListPVectorValue
-#undef TypeIt
-#define TypeIt ListPVectorValueIt
-#undef type
-#define type(x) ListPVectorValue##x
-#undef it
-#define it(x) ListPVectorValueIt##x
-#undef Element
-#define Element PVectorValue
-#undef element
-#define element(x) PVectorValue##x
-
-
-static void type(Test)() {
-    Type c1, c2;
-    Element *e1, *e2;
-    ValueType *v1, *v2;
-    
-    type(Ctor)(&c1);
-    type(Ctor)(&c2);
-    
-    e1 = element(New)(3);
-    
-    element(Set)(e1, 1, v1 = ValueTypeNew());
-    
-    e2 = element(Ref)(e1);
-    
-    assert(element(Equal)(e1, e2));
-    
-    element(Set)(e2, 0, v2 = ValueTypeRef(v1));
-    
-    type(Push)(&c1, e1);
-    
-    element(Free)(e1);
-    element(Free)(e2);
-    
-    type(Dtor)(&c1);
-    type(Dtor)(&c2);
-    
-    ValueTypeFree(v1);
-    ValueTypeFree(v2);
-}
-
-
-int main(int argc, char** argv) {
-    ValueTypeVectorTest();
-    ValueTypeListTest();
-    ValueTypeQueueTest();
-    ValueTypeSetTest();
-    ValueTypeMapTest();
-    IntSetTestAnd();
-    IntSetTestOr();
-    IntSetTestXor();
-    IntSetTestNot1();
-    IntSetTestNot2();
-    IntStrMapTest();
-    ListIntSetTest();
-    PIntTest();
-    PValueTypeTest();
-    ListPVectorValueTest();
-    return 0;
-}