autoc 1.4 → 2.0.0

data/test/test_char_string.rb

@@ -1,270 +0,0 @@
-type_test(AutoC::String, :CharString) do
-
-setup %~#{type} t;~
-cleanup %~#{dtor}(&t);~
-  
-  test :create, %~
-    #{ctor}(&t, "XYZ");
-  ~
-  
-  test :createWithNULL, %~
-    #{ctor}(&t, NULL);
-    TEST_TRUE( #{empty}(&t) );
-  ~
-  
-  test :createWithEmptyChars, %~
-    #{ctor}(&t, "");
-    TEST_TRUE( #{empty}(&t) );
-  ~
-
-  test :hash, %~
-    #{ctor}(&t, "XYZ");
-    #{identify}(&t);
-  ~
-  
-  test :within, %~
-    #{ctor}(&t, "XYZ");
-    TEST_FALSE( #{empty}(&t) );
-    TEST_TRUE( #{within}(&t, 0) );
-    TEST_TRUE( #{within}(&t, 2) );
-    TEST_FALSE( #{within}(&t, 3) );
-  ~
-  
-  test :withinNULLString, %~
-    #{ctor}(&t, NULL);
-    TEST_TRUE( #{empty}(&t) );
-    TEST_FALSE( #{within}(&t, 0) );
-    TEST_FALSE( #{within}(&t, 1) );
-  ~
-
-  test :withinEmptyString, %~
-    #{ctor}(&t, "");
-    TEST_TRUE( #{empty}(&t) );
-    TEST_FALSE( #{within}(&t, 0) );
-    TEST_FALSE( #{within}(&t, 1) );
-  ~
-  test :stringSize, %~
-    #{ctor}(&t, "XYZ");
-    TEST_EQUAL( #{size}(&t), 3 );
-  ~
-
-  test :emptyStringSize, %~
-    #{ctor}(&t, "");
-    TEST_TRUE( #{empty}(&t) );
-    TEST_EQUAL( #{size}(&t), 0 );
-  ~
-  
-  test :NULLStringSize, %~
-    #{ctor}(&t, NULL);
-    TEST_TRUE( #{empty}(&t) );
-    TEST_EQUAL( #{size}(&t), 0 );
-  ~
-  
-  test :chars, %~
-    #{ctor}(&t, "XYZ");
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-    TEST_NOT_EQUAL_CHARS( #{chars}(&t), "xyz" );
-  ~
-  
-  test :getChar, %~
-    #{ctor}(&t, "XYZ");
-    TEST_EQUAL( #{get}(&t, 2), 'Z' );
-  ~
-  
-  test :setChar, %~
-    #{ctor}(&t, "XYZ");
-    TEST_NOT_EQUAL( #{get}(&t, 0), 'x' );
-    #{set}(&t, 0, 'x');
-    TEST_EQUAL( #{get}(&t, 0), 'x' );
-  ~
-  
-  test :pushChars, %~
-    #{ctor}(&t, "X");
-    #{pushChars}(&t, "Y");
-    #{pushChars}(&t, "Z");
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-  ~
-  
-  test :pushEmptyChars, %~
-    #{ctor}(&t, "XYZ");
-    #{pushChars}(&t, "");
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-  ~
-  
-  test :pushCharsToNULL, %~
-    #{ctor}(&t, NULL);
-    #{pushChars}(&t, "XY");
-    #{pushChars}(&t, "Z");
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-  ~
-  
-  test :pushCharsToEmpty, %~
-    #{ctor}(&t, "");
-    #{pushChars}(&t, "X");
-    #{pushChars}(&t, "YZ");
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-  ~
-  
-  test :pushString, %~
-    #{type} s;
-    #{ctor}(&s, "YZ");
-    #{ctor}(&t, "X");
-    #{pushString}(&t, &s);
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-    #{dtor}(&s);
-  ~
-  
-  test :pushChar, %~
-    #{ctor}(&t, "XY");
-    #{pushChar}(&t, 'Z');
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ" );
-  ~
-  
-  test :pushInt, %~
-    #{ctor}(&t, "XYZ");
-    #{pushInt}(&t, -123);
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ-123" );
-  ~
-  
-  test :pushFloat, %~
-    #{ctor}(&t, "XYZ");
-    #{pushFloat}(&t, -1.23);
-  ~
-
-  test :pushPtr, %~
-    #{ctor}(&t, "XYZ");
-    #{pushPtr}(&t, &t);
-  ~
-  
-  test :pushNULLPtr, %~
-    #{ctor}(&t, "XYZ");
-    #{pushPtr}(&t, NULL);
-  ~
-  
-  test :pushFormat, %~
-    #{ctor}(&t, NULL);
-    #{pushFormat}(&t, "%s%c%d", "XY", 'Z', -123);
-    TEST_EQUAL_CHARS( #{chars}(&t), "XYZ-123" );
-  ~
-  
-  setup %~
-    #{type} t;
-    #{char_type}* b = #{malloc}(#{_bufferSize}*sizeof(#{char_type})); #{assert}(b);
-    memset(b, '*', _#{bufferSize});
-    b[#{_bufferSize}-1] = '\\0';
-  ~
-  cleanup %~
-    #{free}(b);
-    #{dtor}(&t);
-  ~
-  
-  test :pushFormatExactBuffer, %~
-    #{ctor}(&t, NULL);
-    #{pushFormat}(&t, "%s", b);
-    TEST_EQUAL_CHARS( #{chars}(&t), b );
-  ~
-
-  test :pushFormatOverBuffer, %~
-    #{ctor}(&t, "-");
-    #ifdef AUTOC_VSNPRINTF
-      #{pushFormat}(&t, "%s-", b);
-      TEST_EQUAL(#{size}(&t), #{_bufferSize}+1);
-    #else
-      TEST_MESSAGE("vsnprintf() is not used, skipping")
-    #endif
-  ~
-    
-setup %~
-  #{type} t;
-  #{it} it;
-~
-cleanup %~#{dtor}(&t);~
-
-  test :iterateOverNULL, %~
-    #{ctor}(&t, NULL);
-    #{itCtor}(&it, &t);
-    TEST_FALSE( #{itMove}(&it) );
-  ~
-  
-  test :iterateOverEmpty, %~
-    #{ctor}(&t, "");
-    #{itCtor}(&it, &t);
-    TEST_FALSE( #{itMove}(&it) );
-  ~
-  
-  test :iterateForward, %~
-    #{ctor}(&t, "XYZ");
-    #{itCtor}(&it, &t);
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'X' );
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'Y' );
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'Z' );
-    TEST_FALSE( #{itMove}(&it) );
-  ~
-  
-  test :iterateBackward, %~
-    #{ctor}(&t, "ZYX");
-    #{itCtorEx}(&it, &t, 0);
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'X' );
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'Y' );
-    TEST_TRUE( #{itMove}(&it) );
-    TEST_EQUAL( #{itGet}(&it), 'Z' );
-    TEST_FALSE( #{itMove}(&it) );
-  ~
-
-setup %~#{type} t1, t2;~
-cleanup %~#{dtor}(&t1); #{dtor}(&t2);~
-  
-  test :copy, %~
-    #{ctor}(&t1, "XYZ");
-    #{copy}(&t2, &t1);
-    TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-  
-  test :copyNULL, %~
-    #{ctor}(&t1, NULL);
-    #{copy}(&t2, &t1);
-    TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-  
-  test :copyEmpty, %~
-    #{ctor}(&t1, "");
-    #{copy}(&t2, &t1);
-    TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-  
-  test :copyFullRange, %~
-    #{ctor}(&t1, "XYZ");
-    #{copyRange}(&t2, &t1, 0, 2);
-    TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-  
-  test :copyPartialRange, %~
-    #{ctor}(&t1, "_XYZ_");
-    #{copyRange}(&t2, &t1, 1, 3);
-    TEST_EQUAL_CHARS( #{chars}(&t2), "XYZ" );
-  ~
-  
-  test :copySingleCharRange, %~
-    #{ctor}(&t1, "XYZ");
-    #{copyRange}(&t2, &t1, 1, 1);
-    TEST_EQUAL_CHARS( #{chars}(&t2), "Y" );
-  ~
-  
-  test :equal, %~
-    #{ctor}(&t1, "XYZ");
-    #{ctor}(&t2, "XYZ");
-    TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-  
-  test :notEqual, %~
-    #{ctor}(&t1, "-XYZ");
-    #{ctor}(&t2, "XYZ-");
-    TEST_FALSE( #{equal}(&t1, &t2) );
-  ~
-  
-end

data/test/test_int_list.rb

@@ -1,35 +0,0 @@
-type_test(AutoC::List, :IntList, :int) do
-
-setup %~#{type} t;~
-cleanup %~#{dtor}(&t);~
-
-	test :create, %~
-		#{ctor}(&t);
-		TEST_TRUE( #{empty}(&t) );
-		TEST_EQUAL( #{size}(&t), 0 );
-	~
-
-setup %~
-	int i, c = 3;
-	#{type} t1, t2;
-	#{ctor}(&t1);
-	#{ctor}(&t2);
-	for(i = 0; i < c; ++i) {
-		#{push}(&t1, i);
-		#{push}(&t2, i);
-	}
-~
-cleanup %~
-	#{dtor}(&t1);
-	#{dtor}(&t2);
-~
-
-	test :equal, %~
-		TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
-		TEST_TRUE( #{equal}(&t1, &t2) );
-		#{push}(&t2, -1);
-		TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
-		TEST_FALSE( #{equal}(&t1, &t2) );
-	~
-
-end

data/test/test_int_tree_set.rb

@@ -1,111 +0,0 @@
-type_test(AutoC::TreeSet, :IntTreeSet, :int) do
-
-setup %~#{type} t; #{ctor}(&t);~
-cleanup %~#{dtor}(&t);~
-
-	test :create, %~
-		TEST_TRUE( #{empty}(&t) );
-		TEST_EQUAL( #{size}(&t), 0 );
-	~
-
-	test :put, %~
-		TEST_EQUAL( #{size}(&t), 0 );
-		TEST_FALSE( #{contains}(&t, 1) );
-		TEST_TRUE( #{put}(&t, 1) );
-		TEST_TRUE( #{contains}(&t, 1) );
-		TEST_FALSE( #{put}(&t, 1) );
-		TEST_EQUAL( #{size}(&t), 1 );
-		TEST_TRUE( #{put}(&t, -1) );
-		TEST_TRUE( #{put}(&t, 2) );
-		TEST_EQUAL( #{size}(&t), 3 );
-		TEST_FALSE( #{contains}(&t, 0) );
-	~
-
-setup %~
-	int i, c = 3;
-	#{type} t1, t2;
-	#{ctor}(&t1);
-	#{ctor}(&t2);
-	for(i = 0; i < c; ++i) {
-		#{put}(&t1, i);
-		#{put}(&t2, i);
-	}
-~
-cleanup %~
-	#{dtor}(&t1);
-	#{dtor}(&t2);
-~
-
-	test :equal, %~
-		TEST_EQUAL( #{size}(&t1), #{size}(&t2) );
-		TEST_TRUE( #{equal}(&t1, &t2) );
-		#{put}(&t2, -1);
-		TEST_NOT_EQUAL( #{size}(&t1), #{size}(&t2) );
-		TEST_FALSE( #{equal}(&t1, &t2) );
-	~
-
-setup %~
-	int values[] = {2,-6,7,-6,1,2,5,7,4,3,1,-6,0};
-	int* p = values;
-	#{type} t;
-	#{ctor}(&t);
-	while(*p != 0) {
-		#{put}(&t, *p);
-		TEST_TRUE( #{contains}(&t, *p) );
-		++p;
-	}
-~
-cleanup %~
-	#{dtor}(&t);
-~
-
-	test :size, %~
-		TEST_EQUAL( #{size}(&t), 7 );
-	~
-
-	test :contains, %~
-		TEST_TRUE( #{contains}(&t, 1) );
-		TEST_FALSE( #{contains}(&t, -1) );
-	~
-
-	test :iterateAscending, %~
-		int cur, pre, start = 1;
-		#{it} it;
-		#{itCtorEx}(&it, &t, 1);
-		cur = pre = #{peekLowest}(&t);
-		while(#{itMove}(&it)) {
-			cur = #{itGet}(&it);
-			if(start) {
-				start = 0;
-			} else {
-				TEST_TRUE( pre < cur );
-				pre = cur;
-			}
-		}
-	~
-
-	test :iterateDescending, %~
-		int cur, pre, start = 1;
-		#{it} it;
-		#{itCtorEx}(&it, &t, 0);
-		cur = pre = #{peekHighest}(&t);
-		while(#{itMove}(&it)) {
-			cur = #{itGet}(&it);
-			if(start) {
-				start = 0;
-			} else {
-				TEST_TRUE( pre > cur );
-				pre = cur;
-			}
-		}
-	~
-
-	test :peekHighest, %~
-		TEST_EQUAL( #{peekHighest}(&t), 7 );
-	~
-
-	test :peekLowest, %~
-		TEST_EQUAL( #{peekLowest}(&t), -6 );
-	~
-
-end

data/test/test_int_vector.rb

@@ -1,34 +0,0 @@
-type_test(AutoC::Vector, :IntVector, :int) do
-
-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) {
-    #{set}(&t1, i, i);
-    #{set}(&t2, i, i);
-  }
-  TEST_TRUE( #{equal}(&t1, &t2) );
-  ~
-cleanup %~
-  #{dtor}(&t1);
-  #{dtor}(&t2);
-~
-
-test :sort, %~
-	#{sortEx}(&t2, 0);
-	/* 2,1,0 */
-	TEST_FALSE( #{equal}(&t1, &t2) );
-	TEST_EQUAL( #{get}(&t2, 0), 2 );
-	TEST_EQUAL( #{get}(&t2, 1), 1 );
-	#{sortEx}(&t2, 1);
-	/* 0,1,2 */
-	TEST_TRUE( #{equal}(&t1, &t2) );
-	TEST_EQUAL( #{get}(&t2, 0), 0 );
-	TEST_EQUAL( #{get}(&t2, 1), 1 );
-~
-
-end

data/test/test_value_hash_map.rb

@@ -1,162 +0,0 @@
-require "value"
-
-type_test(AutoC::HashMap, :ValueHashMap, 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 :iterate, %~
-		#{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);
-		}
-	~
-
-end