autoc 0.8 → 1.0

data/test/test.c

@@ -1,396 +1,921 @@
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-
-#include "test_auto.h"
-
-
-void PrintIntVector(IntVector* vec) {
-    IntVectorIt it;
-    IntVectorItCtor(&it, vec);
-    while(IntVectorItHasNext(&it)) {
-        printf("%d ", IntVectorItNext(&it));
-    }
-    printf("\n");
-}
-
-
-void IntVectorTest() {
-    IntVector* vec;
-    printf("\n*** IntVector\n");
-    vec = IntVectorAssign(IntVectorNew(10));
-    printf("size = %d\n", IntVectorSize(vec));
-    IntVectorSet(vec, 0, 3);
-    IntVectorSet(vec, 1, 11);
-    IntVectorSet(vec, 2, 4);
-    IntVectorSet(vec, 3, 0);
-    IntVectorSet(vec, 4, 5);
-    IntVectorSet(vec, 5, 99);
-    IntVectorSet(vec, 6, 2);
-    IntVectorSet(vec, 7, 7);
-    IntVectorSet(vec, 8, 6);
-    IntVectorSet(vec, 9, 8);
-    PrintIntVector(vec);
-    printf("vec[0] == %d\n", IntVectorGet(vec, 0));
-    IntVectorSort(vec);
-    PrintIntVector(vec);
-    IntVectorDestroy(vec);
-}
-
-
-void IntSetTest() {
-    IntSet set;
-    IntSetIt it;
-    printf("\n*** IntSet\n");
-    IntSetCtor(&set);
-    printf("size = %d\n", IntSetSize(&set));
-    IntSetPut(&set, -1);
-    IntSetPut(&set, 3);
-    IntSetPut(&set, 0);
-    IntSetPut(&set, 3);
-    printf("size = %d\n", IntSetSize(&set));
-    IntSetPut(&set, 7);
-    printf("size = %d\n", IntSetSize(&set));
-    IntSetItCtor(&it, &set);
-    while(IntSetItHasNext(&it)) {
-        printf("- %d\n", IntSetItNext(&it));
-    }
-    IntSetDtor(&set);
-}
-
-
-size_t PCharHash(const char* s) {
-    size_t h = 0;
-    while(*s++) {
-        h += *s;
-    }
-    return h;
-}
-
-
-int PCharEqual(const char* lt, const char* rt) {
-    return strcmp(lt, rt) == 0;
-}
-
-
-void PrintPCharSet(PCharSet* set) {
-    PCharSetIt it;
-    PCharSetItCtor(&it, set);
-    while(PCharSetItHasNext(&it)) {
-        printf("%s ", PCharSetItNext(&it));
-    }
-    printf("\n");
-}
-
-
-void PCharSetTest() {
-    PCharSet set;
-    PCharSetIt it;
-    printf("\n*** PCharSet (I)\n");
-    PCharSetCtor(&set);
-    printf("size = %d\n", PCharSetSize(&set));
-    PCharSetPut(&set, "cat");
-    PCharSetPut(&set, "dog");
-    PCharSetPut(&set, "cat");
-    printf("size = %d\n", PCharSetSize(&set));
-    PCharSetPut(&set, "pig");
-    printf("size = %d\n", PCharSetSize(&set));
-    PCharSetItCtor(&it, &set);
-    while(PCharSetItHasNext(&it)) {
-        printf("- %s\n", PCharSetItNext(&it));
-    }
-    printf("contains(pig) == %d\n", PCharSetContains(&set, "pig"));
-    printf("contains(snake) == %d\n", PCharSetContains(&set, "snake"));
-    PCharSetPurge(&set);
-    PCharSetDtor(&set);
-}
-
-
-void PCharSetTest2() {
-    PCharSet *a, *b, *c;
-    printf("\n*** PCharSet (II)\n");
-    a = PCharSetAssign(PCharSetNew());
-    b = PCharSetAssign(PCharSetNew());
-    c = PCharSetAssign(PCharSetNew());
-    PCharSetPut(a, "cat");
-    PCharSetPut(a, "dog");
-    PCharSetPut(a, "pig");
-    PCharSetPut(a, "rat");
-    PCharSetPut(b, "mouse");
-    PCharSetPut(b, "snake");
-    PCharSetPut(b, "rat");
-
-    PCharSetPurge(c);
-    PCharSetOr(c, a);
-    PCharSetAnd(c, b);
-    PrintPCharSet(c);
-
-    PCharSetPurge(c);
-    PCharSetOr(c, a);
-    PCharSetOr(c, b);
-    PrintPCharSet(c);
-
-    PCharSetPurge(c);
-    PCharSetOr(c, a);
-    PCharSetXor(c, b);
-    PrintPCharSet(c);
-
-    PCharSetDestroy(a);
-    PCharSetDestroy(b);
-    PCharSetDestroy(c);
-}
-
-
-void PChar2IntMapTest() {
-    PChar2IntMap* map;
-    PChar2IntMapIt it;
-    printf("\n*** PChar2IntMap\n");
-    map = PChar2IntMapAssign(PChar2IntMapNew());
-    PChar2IntMapPut(map, "cat", 1);
-    PChar2IntMapPut(map, "dog", 2);
-    PChar2IntMapPut(map, "cat", 0);
-    PChar2IntMapPut(map, "pig", 0);
-    printf("size = %d\n", PChar2IntMapSize(map));
-    PChar2IntMapItCtor(&it, map);
-    while(PChar2IntMapItHasNext(&it)) {
-        PChar2IntMapEntry entry = PChar2IntMapItNext(&it);
-        printf("- %s --> %d\n", entry.key, entry.value);
-    }
-    PChar2IntMapPurge(map);
-    PChar2IntMapDestroy(map);
-}
-
-
-struct Box {
-    size_t refs;
-    int contents;
-};
-
-
-Box* BoxNew() {
-    Box* box = (Box*)malloc(sizeof(Box));
-    box->refs = 0;
-    box->contents = -1;
-    return box;
-}
-
-
-Box* BoxMake(int contents) {
-    Box* box = BoxNew();
-    box->contents = contents;
-    return box;
-}
-
-
-Box* BoxAssign(Box* box) {
-    assert(box);
-    ++box->refs;
-    return box;
-}
-
-
-int BoxEqual(Box* lt, Box* rt) {
-    assert(lt);
-    assert(rt);
-    return lt->contents == rt->contents;
-}
-
-
-size_t BoxHash(Box* box) {
-    assert(box);
-    return box->contents;
-}
-
-
-void BoxDestroy(Box* box) {
-    assert(box);
-    if(!--box->refs) free(box);
-}
-
-
-void BoxSetTest() {
-    int i;
-    BoxSet* set;
-    Box *b1, *b2, *b4;
-    printf("\n*** BoxSet\n");
-    b1 = BoxAssign(BoxMake(1));
-    b2 = BoxAssign(BoxMake(2));
-    b4 = BoxAssign(b2);
-    set = BoxSetAssign(BoxSetNew());
-    BoxSetPut(set, b1);
-    BoxSetPut(set, BoxMake(3));
-    BoxSetPut(set, b2);
-    BoxSetPut(set, b1);
-    printf("size = %d\n", BoxSetSize(set));
-    BoxDestroy(b1);
-    for(i = 0; i < 100; ++i) {
-        BoxSetPut(set, BoxMake(i));
-    }
-    printf("size = %d\n", BoxSetSize(set));
-    BoxSetPurge(set);
-    BoxSetDestroy(set);
-    BoxDestroy(b2);
-    BoxDestroy(b4);
-}
-
-
-void BoxVectorTest() {
-    BoxVector* vec;
-    Box* b1;
-    printf("\n*** BoxVector\n");
-    b1 = BoxAssign(BoxNew());
-    vec = BoxVectorAssign(BoxVectorNew(10));
-    printf("size = %d\n", BoxVectorSize(vec));
-    BoxVectorSet(vec, 7, b1);
-    BoxVectorResize(vec, 5);
-    printf("size = %d\n", BoxVectorSize(vec));
-    BoxVectorSet(vec, 3, BoxNew());
-    BoxVectorResize(vec, 10);
-    printf("size = %d\n", BoxVectorSize(vec));
-    BoxVectorDestroy(vec);
-    BoxDestroy(b1);
-}
-
-
-void BoxListTest() {
-    BoxList* list;
-    Box *b1,*b2;
-    printf("\n*** BoxList\n");
-    list = BoxListAssign(BoxListNew());
-    b1 = BoxAssign(BoxNew());
-    BoxListAdd(list, BoxMake(2));
-    BoxListAdd(list, BoxMake(1));
-    printf("size = %d\n", BoxListSize(list));
-    printf("contains([-1]) == %d\n", BoxListContains(list, b1));
-    BoxListChop(list);
-    BoxListRemove(list, BoxMake(1));
-    BoxListRemove(list, BoxMake(2));
-    BoxListRemove(list, BoxMake(3));
-    printf("size = %d\n", BoxListSize(list));
-    BoxListPurge(list);
-    BoxListAdd(list, BoxMake(7));
-    BoxListAdd(list, b1);
-    BoxListAdd(list, b1);
-    b2 = BoxAssign(BoxMake(3));
-    printf("size = %d\n", BoxListSize(list));
-    printf("contains([-1]) == %d\n", BoxListContains(list, b1));
-    BoxListReplaceAll(list, b1, b2);
-    printf("contains([-1]) == %d\n", BoxListContains(list, b1));
-    printf("contains([3]) == %d\n", BoxListContains(list, b2));
-    BoxListChop(list);
-    printf("size = %d\n", BoxListSize(list));
-    BoxListDestroy(list);
-    BoxDestroy(b1);
-    BoxDestroy(b2);
-}
-
-
-void Box2BoxMapTest() {
-    int i;
-    Box2BoxMap* map, *map2;
-    Box *b1, *b2;
-    printf("\n*** Box2BoxMap\n");
-    map = Box2BoxMapAssign(Box2BoxMapNew());
-    b1 = BoxAssign(BoxMake(-1));
-    b2 = BoxAssign(b1);
-    Box2BoxMapContainsKey(map, BoxMake(3));
-    Box2BoxMapContainsKey(map, b1);
-    Box2BoxMapReplace(map, BoxMake(-1), BoxMake(-1));
-    Box2BoxMapReplace(map, BoxMake(-2), BoxMake(-2));
-    Box2BoxMapPut(map, b1, BoxMake(3));
-    Box2BoxMapPut(map, BoxMake(2), BoxMake(2));
-    Box2BoxMapPut(map, BoxMake(1), BoxMake(1));
-    Box2BoxMapReplace(map, BoxMake(1), BoxMake(-3));
-    printf("size = %d\n", Box2BoxMapSize(map));
-    for(i = 0; i < 100; ++i) {
-        Box2BoxMapPut(map, BoxMake(i), BoxMake(-i));
-    }
-    printf("size = %d\n", Box2BoxMapSize(map));
-    i = -2; printf("map[Box(%d)] == Box(%d)\n", i, Box2BoxMapGet(map, BoxMake(i))->contents);
-    i = 3; printf("map[Box(%d)] == Box(%d)\n", i, Box2BoxMapGet(map, BoxMake(i))->contents);
-    printf("contains([99]) == %d\n", Box2BoxMapContainsKey(map, BoxMake(+99)));
-    Box2BoxMapRemove(map, BoxMake(+99));
-    printf("contains([99]) == %d\n", Box2BoxMapContainsKey(map, BoxMake(+99)));
-    map2 = Box2BoxMapAssign(map);
-    Box2BoxMapRemove(map2, BoxMake(-99));
-    Box2BoxMapPurge(map);
-    Box2BoxMapPut(map2, BoxMake(3), b2);
-    BoxDestroy(b2);
-    printf("size = %d\n", Box2BoxMapSize(map2));
-    Box2BoxMapDestroy(map2);
-    Box2BoxMapDestroy(map);
-    BoxDestroy(b1);
-}
-
-
-void PChar2IntVectorMapTest() {
-    size_t i;
-    PChar2IntVectorMap* map;
-    IntVector* vec;
-    printf("\n*** PChar2IntVectorMap\n");
-    map = PChar2IntVectorMapAssign(PChar2IntVectorMapNew());
-    PChar2IntVectorMapPut(map, "zero", IntVectorNew(3));
-    PChar2IntVectorMapPut(map, "one", IntVectorNew(3));
-    vec = PChar2IntVectorMapGet(map, "one"); for(i = 0; i < IntVectorSize(vec); ++i) {
-        IntVectorSet(vec, i, i);
-    }
-    printf("size = %d\n", IntVectorSize(vec));
-    PrintIntVector(vec);
-    IntVectorResize(PChar2IntVectorMapGet(map, "one"), 5);
-    printf("size = %d\n", IntVectorSize(vec));
-    PrintIntVector(vec);
-    PChar2IntVectorMapDestroy(map);
-}
-
-
-void PrintPCharQueue(PCharQueue* queue, int fwd) {
-    PCharQueueIt it;
-    PCharQueueItCtor(&it, queue, fwd);
-    while(PCharQueueItHasNext(&it)) {
-        printf("%s ", PCharQueueItNext(&it));
-    }
-    printf("\n");
-}
-
-
-void PCharQueueTest() {
-    PCharQueue* queue;
-    printf("\n*** PCharQueue\n");
-    queue = PCharQueueAssign(PCharQueueNew());
-    PCharQueuePrepend(queue, "one");
-    PCharQueuePrepend(queue, "zero");
-    PCharQueueAppend(queue, "two");
-    PCharQueueAppend(queue, "three");
-    printf("contains(zero) == %d\n", PCharQueueContains(queue, "zero"));
-    printf("contains(four) == %d\n", PCharQueueContains(queue, "four"));
-    PrintPCharQueue(queue, 1);
-    PrintPCharQueue(queue, 0);
-    PCharQueueRemove(queue, "two");
-    printf("head = %s\n", PCharQueueHead(queue));
-    printf("tail = %s\n", PCharQueueTail(queue));
-    PCharQueueChopTail(queue);
-    PCharQueueChopHead(queue);
-    PrintPCharQueue(queue, 1);
-    PCharQueuePurge(queue);
-    PCharQueueAppend(queue, "zero");
-    printf("head = %s\n", PCharQueueHead(queue));
-    printf("tail = %s\n", PCharQueueTail(queue));
-    PCharQueueDestroy(queue);
-}
-
-
-int main(int argc, char** argv) {
-    IntVectorTest();
-    IntSetTest();
-    PCharSetTest();
-    PCharSetTest2();
-    PChar2IntMapTest();
-    BoxSetTest();
-    BoxVectorTest();
-    BoxListTest();
-    Box2BoxMapTest();
-    PChar2IntVectorMapTest();
-    PCharQueueTest();
-    return 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);
+}
+
+
+int main(int argc, char** argv) {
+    ValueTypeVectorTest();
+    ValueTypeListTest();
+    ValueTypeQueueTest();
+    ValueTypeSetTest();
+    ValueTypeMapTest();
+    IntSetTestAnd();
+    IntSetTestOr();
+    IntSetTestXor();
+    IntSetTestNot1();
+    IntSetTestNot2();
+    IntStrMapTest();
+    return 0;
+}