Index: Jenkinsfile
===================================================================
--- Jenkinsfile	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ Jenkinsfile	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -31,10 +31,12 @@
 
 		//Run the tests from the tests directory
-		if (full_build) {
-			sh 'make -C src/tests all-tests debug=yes'
-			sh 'make -C src/tests all-tests debug=no'
-		}
-		else {
-			sh 'make -C src/tests'
+		dir ('src/tests') {
+			if (full_build) {
+				sh 'make all-tests debug=yes'
+				sh 'make all-tests debug=no'
+			}
+			else {
+				sh 'make'
+			}
 		}
 
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ src/libcfa/stdlib	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -29,17 +29,17 @@
 
 extern "C" { void * malloc( size_t ); }					// use default C routine for void *
-forall( dtype T | sized(T) ) T * malloc( void );
-forall( dtype T | sized(T) ) T * malloc( char fill );
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size );
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * malloc( void );
+forall( otype T ) T * malloc( char fill );
+forall( otype T ) T * malloc( T * ptr, size_t size );
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill );
 extern "C" { void * calloc( size_t nmemb, size_t size ); } // use default C routine for void *
-forall( dtype T | sized(T) ) T * calloc( size_t nmemb );
+forall( otype T ) T * calloc( size_t nmemb );
 extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void *
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size );
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill );
+forall( otype T ) T * realloc( T * ptr, size_t size );
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill );
 
-forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment );
-forall( dtype T | sized(T) ) T * memalign( size_t alignment );		// deprecated
-forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment );
+forall( otype T ) T * aligned_alloc( size_t alignment );
+forall( otype T ) T * memalign( size_t alignment );		// deprecated
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment );
 
 extern "C" {
@@ -48,5 +48,5 @@
 } // extern "C"
 
-forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );
+forall( otype T, ttype Params | { void ?{}(T *, Params); } ) T * new( Params p );
 forall( dtype T | { void ^?{}(T *); } ) void delete( T * ptr );
 
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ src/libcfa/stdlib.c	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -27,9 +27,9 @@
 } // extern "C"
 
-forall( dtype T | sized(T) ) T * malloc( void ) {
+forall( otype T ) T * malloc( void ) {
 	//printf( "malloc1\n" );
     return (T *)malloc( sizeof(T) );
 } // malloc
-forall( dtype T | sized(T) ) T * malloc( char fill ) {
+forall( otype T ) T * malloc( char fill ) {
 	//printf( "malloc3\n" );
 	T * ptr = (T *)malloc( sizeof(T) );
@@ -37,14 +37,14 @@
 } // malloc
 
-forall( dtype T | sized(T) ) T * calloc( size_t nmemb ) {
+forall( otype T ) T * calloc( size_t nmemb ) {
 	//printf( "calloc\n" );
     return (T *)calloc( nmemb, sizeof(T) );
 } // calloc
 
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) {
+forall( otype T ) T * realloc( T * ptr, size_t size ) {
 	//printf( "realloc1\n" );
     return (T *)(void *)realloc( (void *)ptr, size );
 } // realloc
-forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * realloc( T * ptr, size_t size, unsigned char fill ) {
 	//printf( "realloc2\n" );
     char * nptr = (T *)(void *)realloc( (void *)ptr, size );
@@ -54,29 +54,29 @@
 } // realloc
 
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) {
+forall( otype T ) T * malloc( T * ptr, size_t size ) {
 	//printf( "malloc4\n" );
     return (T *)realloc( ptr, size );
 } // malloc
-forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
+forall( otype T ) T * malloc( T * ptr, size_t size, unsigned char fill ) {
 	//printf( "malloc5\n" );
     return (T *)realloc( ptr, size, fill );
 } // malloc
 
-forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) {
+forall( otype T ) T * aligned_alloc( size_t alignment ) {
 	//printf( "aligned_alloc\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // aligned_alloc
 
-forall( dtype T | sized(T) ) T * memalign( size_t alignment ) {
+forall( otype T ) T * memalign( size_t alignment ) {
 	//printf( "memalign\n" );
     return (T *)memalign( alignment, sizeof(T) );
 } // memalign
 
-forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) {
+forall( otype T ) int posix_memalign( T ** ptr, size_t alignment ) {
 	//printf( "posix_memalign\n" );
     return posix_memalign( (void **)ptr, alignment, sizeof(T) );
 } // posix_memalign
 
-forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } )
+forall( otype T, ttype Params | { void ?{}(T *, Params); } )
 T * new( Params p ) {
 	return ((T*)malloc()){ p };
Index: src/tests/dtor-early-exit.c
===================================================================
--- src/tests/dtor-early-exit.c	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ src/tests/dtor-early-exit.c	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -28,9 +28,9 @@
 // don't want these called
 void ?{}(A * a) { assert( false ); }
-void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
+void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = malloc(); }
 void ?{}(A * a, char * name, int * ptr) { assert( false ); }
 
 A ?=?(A * a, A a) {  sout | "assign " | a->name | " " | a.name; return a; }
-void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = (int*)malloc(); }
+void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = malloc(); }
 void ^?{}(A * a) { sout | "destruct " | a->name | endl; free(a->x); }
 
Index: src/tests/test.py
===================================================================
--- src/tests/test.py	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ src/tests/test.py	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -168,34 +168,30 @@
 
 def run_test_instance(t, generate, dry_run, debug) :
-	try :
-		# print formated name
-		name_txt = "%20s  " % t.name
-
-		#run the test instance and collect the result
-		test_failed, error = run_single_test(t, generate, dry_run, debug)
-
-		# update output based on current action
-		if generate :
-			failed_txt = "ERROR"
-			success_txt = "Done"
-		else :
-			failed_txt = "FAILED"
-			success_txt = "PASSED"
-
-		#print result with error if needed
-		text = name_txt + (failed_txt if test_failed else success_txt)
-		out = sys.stdout
-		if error :
-			text = text + "\n" + error
-			out = sys.stderr
-
-		print(text, file = out);
-		sys.stdout.flush()
-		sys.stderr.flush()
-		return test_failed
-	
-	except KeyboardInterrupt:
-		test_failed = True
-
+	# print formated name
+	name_txt = "%20s  " % t.name
+
+	#run the test instance and collect the result
+	test_failed, error = run_single_test(t, generate, dry_run, debug)
+
+	# update output based on current action
+	if generate :
+		failed_txt = "ERROR"
+		success_txt = "Done"
+	else :
+		failed_txt = "FAILED"
+		success_txt = "PASSED"
+
+	#print result with error if needed
+	text = name_txt + (failed_txt if test_failed else success_txt)
+	out = sys.stdout
+	if error :
+		text = text + "\n" + error
+		out = sys.stderr
+
+	print(text, file = out);
+	sys.stdout.flush()
+	sys.stderr.flush()
+
+	return test_failed
 
 # run the given list of tests with the given parameters
@@ -213,5 +209,5 @@
 	pool = Pool(jobs)
 	try :
-		results = pool.map_async(partial(run_test_instance, generate=generate, dry_run=dry_run, debug=debug), tests ).get(9999)
+		results = pool.map_async(partial(run_test_instance, generate=generate, dry_run=dry_run, debug=debug), tests ).get(99999999)
 	except KeyboardInterrupt:
 		pool.terminate()
Index: src/tests/tupleVariadic.c
===================================================================
--- src/tests/tupleVariadic.c	(revision 059531a68fa2cdde9d256ef7ebd70ebcc93be6a2)
+++ src/tests/tupleVariadic.c	(revision 863b34fc4ded3e787586389ab27770d2cdb64ed3)
@@ -29,5 +29,5 @@
 }
 
-forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } )
+forall(otype T, ttype Params | { void ?{}(T *, Params); })
 T * new(Params p);
 
