autoc 1.2 → 1.3

data/test/test_char_string.rb

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

@@ -0,0 +1,35 @@
+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_vector.rb

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

@@ -0,0 +1,162 @@
+require "value"
+
+type_test(AutoC::HashMap, :ValueMap, 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