Index: kernel/generic/src/console/cmd.c
===================================================================
--- kernel/generic/src/console/cmd.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/generic/src/console/cmd.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -32,6 +32,6 @@
 
 /**
- * @file	cmd.c
- * @brief	Kernel console command wrappers.
+ * @file  cmd.c
+ * @brief Kernel console command wrappers.
  *
  * This file is meant to contain all wrapper functions for
@@ -997,5 +997,6 @@
 	
 	/* Execute the test */
-	char * ret = test->entry(false);
+	test_quiet = false;
+	char *ret = test->entry();
 	
 	/* Update and read thread accounting */
@@ -1049,5 +1050,6 @@
 		
 		/* Execute the test */
-		char * ret = test->entry(true);
+		test_quiet = true;
+		char * ret = test->entry();
 		
 		/* Update and read thread accounting */
@@ -1151,5 +1153,5 @@
 	if (!fnd)
 		printf("Unknown test\n");
-
+	
 	return 1;
 }
Index: kernel/test/atomic/atomic1.c
===================================================================
--- kernel/test/atomic/atomic1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/atomic/atomic1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -32,5 +32,5 @@
 #include <debug.h>
 
-char * test_atomic1(bool quiet)
+char *test_atomic1(void)
 {
 	atomic_t a;
Index: kernel/test/avltree/avltree1.c
===================================================================
--- kernel/test/avltree/avltree1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/avltree/avltree1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -42,5 +42,5 @@
 static avltree_node_t avltree_nodes[NODE_COUNT];
 
-/* 
+/*
  * head of free nodes' list:
  */
@@ -59,9 +59,9 @@
 	if (!node)
 		return NULL;
-
+	
 	if (node->lft) {
 		tmp = test_tree_parents(node->lft);
 		if (tmp != node) {
-			printf("Bad parent pointer key: %" PRIu64
+			TPRINTF("Bad parent pointer key: %" PRIu64
 			    ", address: %p\n", tmp->key, node->lft);
 		}
@@ -70,5 +70,5 @@
 		tmp = test_tree_parents(node->rgt);
 		if (tmp != node) {
-			printf("Bad parent pointer key: %" PRIu64
+			TPRINTF("Bad parent pointer key: %" PRIu64
 			    ", address: %p\n",
 			    tmp->key,node->rgt);
@@ -81,47 +81,48 @@
 {
 	int h1, h2, diff;
-
+	
 	if (!node)
 		return 0;
+	
 	h1 = test_tree_balance(node->lft);
 	h2 = test_tree_balance(node->rgt);
 	diff = h2 - h1;
-	if (diff != node->balance || (diff != -1 && diff != 0 && diff != 1)) {
-		printf("Bad balance\n");
-	}
-	return h1 > h2 ? h1 + 1 : h2 + 1;
+	
+	if ((diff != node->balance) || ((diff != -1) && (diff != 0) && (diff != 1)))
+		TPRINTF("Bad balance\n");
+	
+	return ((h1 > h2) ? (h1 + 1) : (h2 + 1));
 }
 
 /**
  * Prints the structure of the node, which is level levels from the top of the
- * tree. 
- */
-static void
-print_tree_structure_flat(avltree_node_t *node, int level)
+ * tree.
+ */
+static void print_tree_structure_flat(avltree_node_t *node, int level)
 {
 	/*
 	 * You can set the maximum level as high as you like.
-    	 * Most of the time, you'll want to debug code using small trees,
-    	 * so that a large level indicates a loop, which is a bug.
+	 * Most of the time, you'll want to debug code using small trees,
+	 * so that a large level indicates a loop, which is a bug.
 	 */
 	if (level > 16) {
-		printf("[...]");
+		TPRINTF("[...]");
 		return;
 	}
-
+	
 	if (node == NULL)
 		return;
-
-	printf("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
+	
+	TPRINTF("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
 	if (node->lft != NULL || node->rgt != NULL) {
-		printf("(");
-
+		TPRINTF("(");
+		
 		print_tree_structure_flat(node->lft, level + 1);
 		if (node->rgt != NULL) {
-			printf(",");
+			TPRINTF(",");
 			print_tree_structure_flat(node->rgt, level + 1);
 		}
-
-		printf(")");
+		
+		TPRINTF(")");
 	}
 }
@@ -130,8 +131,8 @@
 {
 	int i;
-
-	for (i = 0; i < NODE_COUNT - 1; i++) {
+	
+	for (i = 0; i < NODE_COUNT - 1; i++)
 		avltree_nodes[i].par = &avltree_nodes[i + 1];
-	}
+	
 	avltree_nodes[i].par = NULL;
 	
@@ -140,13 +141,15 @@
 	 * array.
 	 */
-
+	
 	/* First tree node and same key */
 	avltree_nodes[0].key = 60;
 	avltree_nodes[1].key = 60;
 	avltree_nodes[2].key = 60;
+	
 	/* LL rotation */
 	avltree_nodes[3].key = 50;
 	avltree_nodes[4].key = 40;
 	avltree_nodes[5].key = 30;
+	
 	/* LR rotation */
 	avltree_nodes[6].key = 20;
@@ -154,15 +157,20 @@
 	avltree_nodes[8].key = 25;
 	avltree_nodes[9].key = 25;
+	
 	/* LL rotation in lower floor */
 	avltree_nodes[10].key = 35;
+	
 	/* RR rotation */
 	avltree_nodes[11].key = 70;
 	avltree_nodes[12].key = 80;
+	
 	/* RL rotation */
 	avltree_nodes[13].key = 90;
 	avltree_nodes[14].key = 85;
+	
 	/* Insert 0 key */
 	avltree_nodes[15].key = 0;
 	avltree_nodes[16].key = 0;
+	
 	/* Insert reverse */
 	avltree_nodes[17].key = 600;
@@ -170,5 +178,5 @@
 	avltree_nodes[19].key = 400;
 	avltree_nodes[20].key = 300;
-
+	
 	for (i = 21; i < NODE_COUNT; i++)
 		avltree_nodes[i].key = i * 3;
@@ -180,38 +188,33 @@
 {
 	avltree_node_t *node;
-
+	
 	node = first_free_node;
 	first_free_node = first_free_node->par;
-
+	
 	return node;
 }
 
-static void test_tree_insert(avltree_t *tree, count_t node_count, bool quiet) 
+static void test_tree_insert(avltree_t *tree, count_t node_count)
 {
 	unsigned int i;
 	avltree_node_t *newnode;
-
+	
 	avltree_create(tree);
 	
-	if (!quiet)
-		printf("Inserting %" PRIc " nodes...", node_count);
-
+	TPRINTF("Inserting %" PRIc " nodes...", node_count);
+	
 	for (i = 0; i < node_count; i++) {
 		newnode = alloc_avltree_node();
 		
 		avltree_insert(tree, newnode);
-		if (!quiet) {
-			test_tree_parents(tree->root);
-			test_tree_balance(tree->root);
-		}
-	}
-		
-	if (!quiet)
-		printf("done.\n");
-}
-
+		test_tree_parents(tree->root);
+		test_tree_balance(tree->root);
+	}
+	
+	TPRINTF("done.\n");
+}
 
 static void test_tree_delete(avltree_t *tree, count_t node_count,
-    int node_position, bool quiet) 
+    int node_position)
 {
 	avltree_node_t *delnode;
@@ -220,70 +223,60 @@
 	switch (node_position) {
 	case 0:
-		if (!quiet)
-			printf("Deleting root nodes...");
+		TPRINTF("Deleting root nodes...");
+		
 		while (tree->root != NULL) {
 			delnode = tree->root;
 			avltree_delete(tree, delnode);
-			if (!quiet) {
-				test_tree_parents(tree->root);
-				test_tree_balance(tree->root);
-			}
-		} 
+			test_tree_parents(tree->root);
+			test_tree_balance(tree->root);
+		}
 		break;
 	case 1:
-		if (!quiet)
-			printf("Deleting nodes according to creation time...");
+		TPRINTF("Deleting nodes according to creation time...");
+		
 		for (i = 0; i < node_count; i++) {
 			avltree_delete(tree, &avltree_nodes[i]);
-			if (!quiet) {
-				test_tree_parents(tree->root);
-				test_tree_balance(tree->root);
-			}
-		}
-		break;	
-	}
-	
-	if (!quiet)
-		printf("done.\n");
-}
-
-static void test_tree_delmin(avltree_t *tree, count_t node_count, bool quiet)
+			test_tree_parents(tree->root);
+			test_tree_balance(tree->root);
+		}
+		break;
+	}
+	
+	TPRINTF("done.\n");
+}
+
+static void test_tree_delmin(avltree_t *tree, count_t node_count)
 {
 	unsigned int i = 0;
 	
-	if (!quiet)
-		printf("Deleting minimum nodes...");
+	TPRINTF("Deleting minimum nodes...");
 	
 	while (tree->root != NULL) {
 		i++;
 		avltree_delete_min(tree);
-		if (!quiet) {
-			test_tree_parents(tree->root);
-			test_tree_balance(tree->root);
-		}
-	}
-
-	if (!quiet && (i != node_count))
-		printf("Bad node count. Some nodes have been lost!\n");
-
-	if (!quiet)
-		printf("done.\n");
-}
-
-char *test_avltree1(bool quiet)
+		test_tree_parents(tree->root);
+		test_tree_balance(tree->root);
+	}
+	
+	if (i != node_count)
+		TPRINTF("Bad node count. Some nodes have been lost!\n");
+	
+	TPRINTF("done.\n");
+}
+
+char *test_avltree1(void)
 {
 	alloc_avltree_node_prepare();
-	test_tree_insert(&avltree, NODE_COUNT, quiet);
-	test_tree_delete(&avltree, NODE_COUNT, 0, quiet);
-
+	test_tree_insert(&avltree, NODE_COUNT);
+	test_tree_delete(&avltree, NODE_COUNT, 0);
+	
 	alloc_avltree_node_prepare();
-	test_tree_insert(&avltree, NODE_COUNT, quiet);
-	test_tree_delete(&avltree, NODE_COUNT, 1, quiet);
-
+	test_tree_insert(&avltree, NODE_COUNT);
+	test_tree_delete(&avltree, NODE_COUNT, 1);
+	
 	alloc_avltree_node_prepare();
-	test_tree_insert(&avltree, NODE_COUNT, quiet);
-	test_tree_delmin(&avltree, NODE_COUNT, quiet);
-
+	test_tree_insert(&avltree, NODE_COUNT);
+	test_tree_delmin(&avltree, NODE_COUNT);
+	
 	return NULL;
 }
-
Index: kernel/test/btree/btree1.c
===================================================================
--- kernel/test/btree/btree1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/btree/btree1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -34,13 +34,12 @@
 static void *data = (void *) 0xdeadbeef;
 
-char * test_btree1(bool quiet)
+char *test_btree1(void)
 {
 	btree_t t;
 	int i;
-
+	
 	btree_create(&t);
 	
-	if (!quiet)
-		printf("Inserting keys.\n");
+	TPRINTF("Inserting keys.\n");
 	btree_insert(&t, 19, data, NULL);
 	btree_insert(&t, 20, data, NULL);
@@ -79,9 +78,8 @@
 		btree_insert(&t, i, data, NULL);
 	
-	if (!quiet)
+	if (!test_quiet)
 		btree_print(&t);
 	
-	if (!quiet)
-		printf("Removing keys.\n");
+	TPRINTF("Removing keys.\n");
 	btree_remove(&t, 50, NULL);
 	btree_remove(&t, 49, NULL);
@@ -159,5 +157,5 @@
 	btree_remove(&t, 36, NULL);
 	
-	if (!quiet)
+	if (!test_quiet)
 		btree_print(&t);
 	
Index: kernel/test/debug/mips1.c
===================================================================
--- kernel/test/debug/mips1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/debug/mips1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -37,8 +37,7 @@
 #include <arch.h>
 
-char *test_mips1(bool quiet)
+char *test_mips1(void)
 {
-	if (!quiet)
-		printf("If kconsole is compiled in, you should enter debug mode now.\n");
+	TPRINTF("If kconsole is compiled in, you should enter debug mode now.\n");
 	
 	asm volatile (
Index: kernel/test/debug/mips1_skip.c
===================================================================
--- kernel/test/debug/mips1_skip.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/debug/mips1_skip.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -29,5 +29,5 @@
 #include <test.h>
 
-char *test_mips1(bool quiet)
+char *test_mips1(void)
 {
 	return NULL;
Index: kernel/test/fault/fault1.c
===================================================================
--- kernel/test/fault/fault1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fault/fault1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -37,6 +37,5 @@
 #include <arch.h>
 
-
-char * test_fault1(bool quiet)
+char *test_fault1(void)
 {
 	((int *)(0))[1] = 0;
Index: kernel/test/fpu/fpu1_ia64.c
===================================================================
--- kernel/test/fpu/fpu1_ia64.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/fpu1_ia64.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -64,5 +64,4 @@
 static atomic_t threads_fault;
 static waitq_t can_start;
-static bool sh_quiet;
 
 static void e(void *data)
@@ -86,6 +85,5 @@
 		
 		if ((int) (100000000 * e) != E_10e8) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
+			TPRINTF("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
 			atomic_inc(&threads_fault);
 			break;
@@ -120,6 +118,5 @@
 		
 		if ((int) (1000000 * pi) != PI_10e8) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
+			TPRINTF("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
 			atomic_inc(&threads_fault);
 			break;
@@ -129,8 +126,7 @@
 }
 
-char * test_fpu1(bool quiet)
+char *test_fpu1(void)
 {
 	unsigned int i, total = 0;
-	sh_quiet = quiet;
 	
 	waitq_initialize(&can_start);
@@ -138,13 +134,11 @@
 	atomic_set(&threads_fault, 0);
 	
-	if (!quiet)
-		printf("Creating %u threads... ", 2 * THREADS);
+	TPRINTF("Creating %u threads... ", 2 * THREADS);
 	
-	for (i = 0; i < THREADS; i++) {  
+	for (i = 0; i < THREADS; i++) {
 		thread_t *t;
 		
 		if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i);
+			TPRINTF("could not create thread %u\n", 2 * i);
 			break;
 		}
@@ -153,6 +147,5 @@
 		
 		if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i + 1);
+			TPRINTF("could not create thread %u\n", 2 * i + 1);
 			break;
 		}
@@ -161,6 +154,5 @@
 	}
 	
-	if (!quiet)
-		printf("ok\n");
+	TPRINTF("ok\n");
 	
 	thread_sleep(1);
@@ -168,6 +160,5 @@
 	
 	while (atomic_get(&threads_ok) != (long) total) {
-		if (!quiet)
-			printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+		TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok));
 		thread_sleep(1);
 	}
Index: kernel/test/fpu/fpu1_skip.c
===================================================================
--- kernel/test/fpu/fpu1_skip.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/fpu1_skip.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -29,5 +29,5 @@
 #include <test.h>
 
-char * test_fpu1(bool quiet)
+char *test_fpu1(void)
 {
 	return NULL;
Index: kernel/test/fpu/fpu1_x86.c
===================================================================
--- kernel/test/fpu/fpu1_x86.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/fpu1_x86.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -61,5 +61,4 @@
 static atomic_t threads_fault;
 static waitq_t can_start;
-static bool sh_quiet;
 
 static void e(void *data)
@@ -83,6 +82,5 @@
 		
 		if ((int) (100000000 * e) != E_10e8) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
+			TPRINTF("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
 			atomic_inc(&threads_fault);
 			break;
@@ -117,6 +115,5 @@
 		
 		if ((int) (100000000 * pi) != PI_10e8) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
+			TPRINTF("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
 			atomic_inc(&threads_fault);
 			break;
@@ -126,8 +123,7 @@
 }
 
-char * test_fpu1(bool quiet)
+char *test_fpu1(void)
 {
 	unsigned int i, total = 0;
-	sh_quiet = quiet;
 	
 	waitq_initialize(&can_start);
@@ -135,13 +131,11 @@
 	atomic_set(&threads_fault, 0);
 	
-	if (!quiet)
-		printf("Creating %u threads... ", 2 * THREADS);
+	TPRINTF("Creating %u threads... ", 2 * THREADS);
 	
-	for (i = 0; i < THREADS; i++) {  
+	for (i = 0; i < THREADS; i++) {
 		thread_t *t;
 		
 		if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i);
+			TPRINTF("could not create thread %u\n", 2 * i);
 			break;
 		}
@@ -150,6 +144,5 @@
 		
 		if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i + 1);
+			TPRINTF("could not create thread %u\n", 2 * i + 1);
 			break;
 		}
@@ -158,6 +151,5 @@
 	}
 	
-	if (!quiet)
-		printf("ok\n");
+	TPRINTF("ok\n");
 	
 	thread_sleep(1);
@@ -165,6 +157,5 @@
 	
 	while (atomic_get(&threads_ok) != (long) total) {
-		if (!quiet)
-			printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+		TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok));
 		thread_sleep(1);
 	}
Index: kernel/test/fpu/mips2.c
===================================================================
--- kernel/test/fpu/mips2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/mips2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -44,5 +44,4 @@
 static atomic_t threads_fault;
 static waitq_t can_start;
-static bool sh_quiet;
 
 static void testit1(void *data)
@@ -70,6 +69,5 @@
 		
 		if (arg != after_arg) {
-			if (!sh_quiet)
-				printf("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+			TPRINTF("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
 			atomic_inc(&threads_fault);
 			break;
@@ -102,6 +100,5 @@
 		
 		if (arg != after_arg) {
-			if (!sh_quiet)
-				printf("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+			TPRINTF("General reg tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
 			atomic_inc(&threads_fault);
 			break;
@@ -112,8 +109,7 @@
 
 
-char * test_mips2(bool quiet)
+char *test_mips2(void)
 {
 	unsigned int i, total = 0;
-	sh_quiet = quiet;
 	
 	waitq_initialize(&can_start);
@@ -121,6 +117,5 @@
 	atomic_set(&threads_fault, 0);
 	
-	if (!quiet)
-		printf("Creating %u threads... ", 2 * THREADS);
+	TPRINTF("Creating %u threads... ", 2 * THREADS);
 	
 	for (i = 0; i < THREADS; i++) {
@@ -128,6 +123,5 @@
 		
 		if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i);
+			TPRINTF("could not create thread %u\n", 2 * i);
 			break;
 		}
@@ -136,6 +130,5 @@
 		
 		if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i + 1);
+			TPRINTF("could not create thread %u\n", 2 * i + 1);
 			break;
 		}
@@ -144,6 +137,5 @@
 	}
 	
-	if (!quiet)
-		printf("ok\n");
+	TPRINTF("ok\n");
 		
 	thread_sleep(1);
@@ -151,6 +143,5 @@
 	
 	while (atomic_get(&threads_ok) != (long) total) {
-		if (!quiet)
-			printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+		TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok));
 		thread_sleep(1);
 	}
Index: kernel/test/fpu/mips2_skip.c
===================================================================
--- kernel/test/fpu/mips2_skip.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/mips2_skip.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -29,5 +29,5 @@
 #include <test.h>
 
-char * test_mips2(bool quiet)
+char *test_mips2(void)
 {
 	return NULL;
Index: kernel/test/fpu/sse1.c
===================================================================
--- kernel/test/fpu/sse1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/sse1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -44,6 +44,4 @@
 static atomic_t threads_fault;
 static waitq_t can_start;
-static bool sh_quiet;
-
 
 static void testit1(void *data)
@@ -52,9 +50,9 @@
 	int arg __attribute__((aligned(16))) = (int) ((unative_t) data);
 	int after_arg __attribute__((aligned(16)));
-
+	
 	thread_detach(THREAD);
 	
 	waitq_sleep(&can_start);
-
+	
 	for (i = 0; i < ATTEMPTS; i++) {
 		asm volatile (
@@ -62,5 +60,5 @@
 			: [arg] "=m" (arg)
 		);
-
+		
 		delay(DELAY);
 		asm volatile (
@@ -70,6 +68,5 @@
 		
 		if (arg != after_arg) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+			TPRINTF("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
 			atomic_inc(&threads_fault);
 			break;
@@ -88,5 +85,5 @@
 	
 	waitq_sleep(&can_start);
-
+	
 	for (i = 0; i < ATTEMPTS; i++) {
 		asm volatile (
@@ -94,5 +91,5 @@
 			: [arg] "=m" (arg)
 		);
-
+		
 		scheduler();
 		asm volatile (
@@ -102,6 +99,5 @@
 		
 		if (arg != after_arg) {
-			if (!sh_quiet)
-				printf("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
+			TPRINTF("tid%" PRIu64 ": arg(%d) != %d\n", THREAD->tid, arg, after_arg);
 			atomic_inc(&threads_fault);
 			break;
@@ -111,9 +107,7 @@
 }
 
-
-char * test_sse1(bool quiet)
+char *test_sse1(void)
 {
 	unsigned int i, total = 0;
-	sh_quiet = quiet;
 	
 	waitq_initialize(&can_start);
@@ -121,13 +115,11 @@
 	atomic_set(&threads_fault, 0);
 	
-	if (!quiet)
-		printf("Creating %u threads... ", 2 * THREADS);
-
+	TPRINTF("Creating %u threads... ", 2 * THREADS);
+	
 	for (i = 0; i < THREADS; i++) {
 		thread_t *t;
 		
 		if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i);
+			TPRINTF("could not create thread %u\n", 2 * i);
 			break;
 		}
@@ -136,6 +128,5 @@
 		
 		if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) {
-			if (!quiet)
-				printf("could not create thread %u\n", 2 * i + 1);
+			TPRINTF("could not create thread %u\n", 2 * i + 1);
 			break;
 		}
@@ -144,13 +135,11 @@
 	}
 	
-	if (!quiet)
-		printf("ok\n");
-		
+	TPRINTF("ok\n");
+	
 	thread_sleep(1);
 	waitq_wakeup(&can_start, WAKEUP_ALL);
 	
 	while (atomic_get(&threads_ok) != (long) total) {
-		if (!quiet)
-			printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+		TPRINTF("Threads left: %d\n", total - atomic_get(&threads_ok));
 		thread_sleep(1);
 	}
Index: kernel/test/fpu/sse1_skip.c
===================================================================
--- kernel/test/fpu/sse1_skip.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/fpu/sse1_skip.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -29,5 +29,5 @@
 #include <test.h>
 
-char * test_sse1(bool quiet)
+char *test_sse1(void)
 {
 	return NULL;
Index: kernel/test/mm/falloc1.c
===================================================================
--- kernel/test/mm/falloc1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/falloc1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -37,10 +37,11 @@
 #include <align.h>
 
-#define MAX_FRAMES 1024
-#define MAX_ORDER 8
-#define TEST_RUNS 2
+#define MAX_FRAMES  1024
+#define MAX_ORDER   8
+#define TEST_RUNS   2
 
-char * test_falloc1(bool quiet) {
-	uintptr_t * frames = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
+char *test_falloc1(void) {
+	uintptr_t *frames
+	    = (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
 	int results[MAX_ORDER + 1];
 	
@@ -53,9 +54,8 @@
 	if (frames == NULL)
 		return "Unable to allocate frames";
-
+	
 	for (run = 0; run < TEST_RUNS; run++) {
 		for (order = 0; order <= MAX_ORDER; order++) {
-			if (!quiet)
-				printf("Allocating %d frames blocks ... ", 1 << order);
+			TPRINTF("Allocating %d frames blocks ... ", 1 << order);
 			
 			allocated = 0;
@@ -64,6 +64,5 @@
 				
 				if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) != frames[allocated]) {
-					if (!quiet)
-						printf("Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10);
+					TPRINTF("Block at address %p (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10);
 					return "Test failed";
 				}
@@ -72,13 +71,11 @@
 					allocated++;
 				else {
-					if (!quiet)
-						printf("done. ");
+					TPRINTF("done. ");
 					break;
 				}
 			}
 			
-			if (!quiet)
-				printf("%d blocks allocated.\n", allocated);
-		
+			TPRINTF("%d blocks allocated.\n", allocated);
+			
 			if (run) {
 				if (results[order] != allocated)
@@ -87,15 +84,13 @@
 				results[order] = allocated;
 			
-			if (!quiet)
-				printf("Deallocating ... ");
+			TPRINTF("Deallocating ... ");
 			
 			for (i = 0; i < allocated; i++)
 				frame_free(KA2PA(frames[i]));
 			
-			if (!quiet)
-				printf("done.\n");
+			TPRINTF("done.\n");
 		}
 	}
-
+	
 	free(frames);
 	
Index: kernel/test/mm/falloc2.c
===================================================================
--- kernel/test/mm/falloc2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/falloc2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -40,15 +40,14 @@
 #include <arch.h>
 
-#define MAX_FRAMES 256
-#define MAX_ORDER 8
+#define MAX_FRAMES  256
+#define MAX_ORDER   8
 
-#define THREAD_RUNS 1
-#define THREADS 8
+#define THREAD_RUNS  1
+#define THREADS      8
 
 static atomic_t thread_count;
 static atomic_t thread_fail;
-static bool sh_quiet;
 
-static void falloc(void * arg)
+static void falloc(void *arg)
 {
 	int order, run, allocated, i;
@@ -58,6 +57,5 @@
 	void **frames =  (void **) malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC);
 	if (frames == NULL) {
-		if (!sh_quiet)
-			printf("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id);
+		TPRINTF("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id);
 		atomic_inc(&thread_fail);
 		atomic_dec(&thread_count);
@@ -66,9 +64,8 @@
 	
 	thread_detach(THREAD);
-
+	
 	for (run = 0; run < THREAD_RUNS; run++) {
 		for (order = 0; order <= MAX_ORDER; order++) {
-			if (!sh_quiet)
-				printf("Thread #%" PRIu64 " (cpu%u): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
+			TPRINTF("Thread #%" PRIu64 " (cpu%u): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
 			
 			allocated = 0;
@@ -82,15 +79,11 @@
 			}
 			
-			if (!sh_quiet)
-				printf("Thread #%" PRIu64 " (cpu%u): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
-			
-			if (!sh_quiet)
-				printf("Thread #%" PRIu64 " (cpu%u): Deallocating ... \n", THREAD->tid, CPU->id);
+			TPRINTF("Thread #%" PRIu64 " (cpu%u): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
+			TPRINTF("Thread #%" PRIu64 " (cpu%u): Deallocating ... \n", THREAD->tid, CPU->id);
 			
 			for (i = 0; i < allocated; i++) {
 				for (k = 0; k <= (((index_t) FRAME_SIZE << order) - 1); k++) {
 					if (((uint8_t *) frames[i])[k] != val) {
-						if (!sh_quiet)
-							printf("Thread #%" PRIu64 " (cpu%u): Unexpected data (%c) in block %p offset %#" PRIi "\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
+						TPRINTF("Thread #%" PRIu64 " (cpu%u): Unexpected data (%c) in block %p offset %#" PRIi "\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
 						atomic_inc(&thread_fail);
 						goto cleanup;
@@ -100,30 +93,26 @@
 			}
 			
-			if (!sh_quiet)
-				printf("Thread #%" PRIu64 " (cpu%u): Finished run.\n", THREAD->tid, CPU->id);
+			TPRINTF("Thread #%" PRIu64 " (cpu%u): Finished run.\n", THREAD->tid, CPU->id);
 		}
 	}
-
-cleanup:	
+	
+cleanup:
 	free(frames);
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " (cpu%u): Exiting\n", THREAD->tid, CPU->id);
+	TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n", THREAD->tid, CPU->id);
 	atomic_dec(&thread_count);
 }
 
-char * test_falloc2(bool quiet)
+char *test_falloc2(void)
 {
 	unsigned int i;
-	sh_quiet = quiet;
-
+	
 	atomic_set(&thread_count, THREADS);
 	atomic_set(&thread_fail, 0);
-		
+	
 	for (i = 0; i < THREADS; i++) {
 		thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
 		if (!thrd) {
-			if (!quiet)
-				printf("Could not create thread %u\n", i);
+			TPRINTF("Could not create thread %u\n", i);
 			break;
 		}
@@ -132,6 +121,5 @@
 	
 	while (atomic_get(&thread_count) > 0) {
-		if (!quiet)
-			printf("Threads left: %ld\n", atomic_get(&thread_count));
+		TPRINTF("Threads left: %ld\n", atomic_get(&thread_count));
 		thread_sleep(1);
 	}
Index: kernel/test/mm/mapping1.c
===================================================================
--- kernel/test/mm/mapping1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/mapping1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -36,38 +36,34 @@
 #include <debug.h>
 
-#define PAGE0	0x10000000
-#define PAGE1	(PAGE0+PAGE_SIZE)
+#define PAGE0  0x10000000
+#define PAGE1  (PAGE0 + PAGE_SIZE)
 
-#define VALUE0	0x01234567
-#define VALUE1	0x89abcdef
+#define VALUE0  0x01234567
+#define VALUE1  0x89abcdef
 
-char * test_mapping1(bool quiet)
+char *test_mapping1(void)
 {
 	uintptr_t frame0, frame1;
 	uint32_t v0, v1;
-
+	
 	frame0 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA);
 	frame1 = (uintptr_t) frame_alloc(ONE_FRAME, FRAME_KA);
 	
-	if (!quiet)
-		printf("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0));
+	TPRINTF("Writing %#x to physical address %p.\n", VALUE0, KA2PA(frame0));
 	*((uint32_t *) frame0) = VALUE0;
-	if (!quiet)
-		printf("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1));
+	
+	TPRINTF("Writing %#x to physical address %p.\n", VALUE1, KA2PA(frame1));
 	*((uint32_t *) frame1) = VALUE1;
 	
-	if (!quiet)
-		printf("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0));
+	TPRINTF("Mapping virtual address %p to physical address %p.\n", PAGE0, KA2PA(frame0));
 	page_mapping_insert(AS_KERNEL, PAGE0, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE);
-	if (!quiet)
-		printf("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1));	
+	
+	TPRINTF("Mapping virtual address %p to physical address %p.\n", PAGE1, KA2PA(frame1));
 	page_mapping_insert(AS_KERNEL, PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE);
 	
 	v0 = *((uint32_t *) PAGE0);
 	v1 = *((uint32_t *) PAGE1);
-	if (!quiet) {
-		printf("Value at virtual address %p is %#x.\n", PAGE0, v0);
-		printf("Value at virtual address %p is %#x.\n", PAGE1, v1);
-	}
+	TPRINTF("Value at virtual address %p is %#x.\n", PAGE0, v0);
+	TPRINTF("Value at virtual address %p is %#x.\n", PAGE1, v1);
 	
 	if (v0 != VALUE0)
@@ -76,19 +72,16 @@
 		return "Value at v1 not equal to VALUE1";
 	
-	if (!quiet)
-		printf("Writing %#x to virtual address %p.\n", 0, PAGE0);
+	TPRINTF("Writing %#x to virtual address %p.\n", 0, PAGE0);
 	*((uint32_t *) PAGE0) = 0;
-	if (!quiet)
-		printf("Writing %#x to virtual address %p.\n", 0, PAGE1);
-	*((uint32_t *) PAGE1) = 0;	
-
+	
+	TPRINTF("Writing %#x to virtual address %p.\n", 0, PAGE1);
+	*((uint32_t *) PAGE1) = 0;
+	
 	v0 = *((uint32_t *) PAGE0);
 	v1 = *((uint32_t *) PAGE1);
 	
-	if (!quiet) {
-		printf("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0));	
-		printf("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1));
-	}
-
+	TPRINTF("Value at virtual address %p is %#x.\n", PAGE0, *((uint32_t *) PAGE0));	
+	TPRINTF("Value at virtual address %p is %#x.\n", PAGE1, *((uint32_t *) PAGE1));
+	
 	if (v0 != 0)
 		return "Value at v0 not equal to 0";
@@ -96,4 +89,4 @@
 		return "Value at v1 not equal to 0";
 	
-	return NULL;	
+	return NULL;
 }
Index: kernel/test/mm/purge1.c
===================================================================
--- kernel/test/mm/purge1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/purge1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -40,5 +40,5 @@
 extern void tlb_invalidate_pages(asid_t asid, uintptr_t va, count_t cnt);
 
-char * test_purge1(bool quiet)
+char *test_purge1(void)
 {
 	tlb_entry_t entryi;
Index: kernel/test/mm/purge1_skip.c
===================================================================
--- kernel/test/mm/purge1_skip.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/purge1_skip.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -29,5 +29,5 @@
 #include <test.h>
 
-char *test_purge1(bool quiet)
+char *test_purge1(void)
 {
 	return NULL;
Index: kernel/test/mm/slab1.c
===================================================================
--- kernel/test/mm/slab1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/slab1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -34,21 +34,19 @@
 #include <memstr.h>
 
-#define VAL_COUNT   1024
+#define VAL_COUNT  1024
 
-static void * data[VAL_COUNT];
+static void *data[VAL_COUNT];
 
-static void testit(int size, int count, bool quiet) 
+static void testit(int size, int count)
 {
 	slab_cache_t *cache;
 	int i;
 	
-	if (!quiet)
-		printf("Creating cache, object size: %d.\n", size);
+	TPRINTF("Creating cache, object size: %d.\n", size);
 	
 	cache = slab_cache_create("test_cache", size, 0, NULL, NULL,
-				SLAB_CACHE_NOMAGAZINE);
+	    SLAB_CACHE_NOMAGAZINE);
 	
-	if (!quiet)
-		printf("Allocating %d items...", count);
+	TPRINTF("Allocating %d items...", count);
 	
 	for (i = 0; i < count; i++) {
@@ -57,16 +55,14 @@
 	}
 	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Freeing %d items...", count);
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Freeing %d items...", count);
 	
 	for (i = 0; i < count; i++)
 		slab_free(cache, data[i]);
 	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Allocating %d items...", count);
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Allocating %d items...", count);
 	
 	for (i = 0; i < count; i++) {
@@ -75,16 +71,14 @@
 	}
 	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Freeing %d items...", count / 2);
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Freeing %d items...", count / 2);
 	
 	for (i = count - 1; i >= count / 2; i--)
 		slab_free(cache, data[i]);
 	
-	if (!quiet) {
-		printf("done.\n");	
-		printf("Allocating %d items...", count / 2);
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Allocating %d items...", count / 2);
 	
 	for (i = count / 2; i < count; i++) {
@@ -93,40 +87,37 @@
 	}
 	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Freeing %d items...", count);
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Freeing %d items...", count);
 	
 	for (i = 0; i < count; i++)
 		slab_free(cache, data[i]);
 	
-	if (!quiet)
-		printf("done.\n");	
+	TPRINTF("done.\n");
+	
 	slab_cache_destroy(cache);
 	
-	if (!quiet)
-		printf("Test complete.\n");
+	TPRINTF("Test complete.\n");
 }
 
-static void testsimple(bool quiet)
+static void testsimple(void)
 {
-	testit(100, VAL_COUNT, quiet);
-	testit(200, VAL_COUNT, quiet);
-	testit(1024, VAL_COUNT, quiet);
-	testit(2048, 512, quiet);
-	testit(4000, 128, quiet);
-	testit(8192, 128, quiet);
-	testit(16384, 128, quiet);
-	testit(16385, 128, quiet);
+	testit(100, VAL_COUNT);
+	testit(200, VAL_COUNT);
+	testit(1024, VAL_COUNT);
+	testit(2048, 512);
+	testit(4000, 128);
+	testit(8192, 128);
+	testit(16384, 128);
+	testit(16385, 128);
 }
 
-#define THREADS     6
-#define THR_MEM_COUNT   1024
-#define THR_MEM_SIZE    128
+#define THREADS        6
+#define THR_MEM_COUNT  1024
+#define THR_MEM_SIZE   128
 
-static void * thr_data[THREADS][THR_MEM_COUNT];
+static void *thr_data[THREADS][THR_MEM_COUNT];
 static slab_cache_t *thr_cache;
 static semaphore_t thr_sem;
-static bool sh_quiet;
 
 static void slabtest(void *data)
@@ -137,6 +128,5 @@
 	thread_detach(THREAD);
 	
-	if (!sh_quiet)
-		printf("Starting thread #%" PRIu64 "...\n", THREAD->tid);
+	TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid);
 	
 	for (j = 0; j < 10; j++) {
@@ -151,22 +141,21 @@
 	}
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " finished\n", THREAD->tid);
+	TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
 	
 	semaphore_up(&thr_sem);
 }
 
-static void testthreads(bool quiet)
+static void testthreads(void)
 {
 	thread_t *t;
 	int i;
-
+	
 	thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0, NULL, NULL,
-					SLAB_CACHE_NOMAGAZINE);
+	    SLAB_CACHE_NOMAGAZINE);
+	
 	semaphore_initialize(&thr_sem, 0);
 	for (i = 0; i < THREADS; i++) {  
 		if (!(t = thread_create(slabtest, (void *) (unative_t) i, TASK, 0, "slabtest", false))) {
-			if (!quiet)
-				printf("Could not create thread %d\n", i);
+			TPRINTF("Could not create thread %d\n", i);
 		} else
 			thread_ready(t);
@@ -178,14 +167,11 @@
 	slab_cache_destroy(thr_cache);
 	
-	if (!quiet)
-		printf("Test complete.\n");
+	TPRINTF("Test complete.\n");
 }
 
-char * test_slab1(bool quiet)
+char *test_slab1(void)
 {
-	sh_quiet = quiet;
-	
-	testsimple(quiet);
-	testthreads(quiet);
+	testsimple();
+	testthreads();
 	
 	return NULL;
Index: kernel/test/mm/slab2.c
===================================================================
--- kernel/test/mm/slab2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/mm/slab2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -37,5 +37,5 @@
 #include <synch/mutex.h>
 
-#define ITEM_SIZE 256
+#define ITEM_SIZE  256
 
 /** Fill memory with 2 caches, when allocation fails,
@@ -43,10 +43,10 @@
  *  now allocation should clean magazines and allow for full allocation.
  */
-static void totalmemtest(bool quiet)
+static void totalmemtest(void)
 {
 	slab_cache_t *cache1;
 	slab_cache_t *cache2;
 	int i;
-
+	
 	void *data1, *data2;
 	void *olddata1 = NULL, *olddata2 = NULL;
@@ -55,6 +55,5 @@
 	cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
 	
-	if (!quiet)
-		printf("Allocating...");
+	TPRINTF("Allocating...");
 	
 	/* Use atomic alloc, so that we find end of memory */
@@ -75,10 +74,9 @@
 		olddata1 = data1;
 		olddata2 = data2;
-	} while (1);
-	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Deallocating cache2...");
-	}
+	} while (true);
+	
+	TPRINTF("done.\n");
+	
+	TPRINTF("Deallocating cache2...");
 	
 	/* We do not have memory - now deallocate cache2 */
@@ -89,14 +87,12 @@
 	}
 	
-	if (!quiet) {
-		printf("done.\n");
-		printf("Allocating to cache1...\n");
-	}
+	TPRINTF("done.\n");
+	
+	TPRINTF("Allocating to cache1...\n");
 	
 	for (i = 0; i < 30; i++) {
 		data1 = slab_alloc(cache1, FRAME_ATOMIC);
 		if (!data1) {
-			if (!quiet)
-				printf("Incorrect memory size - use another test.");
+			TPRINTF("Incorrect memory size - use another test.");
 			return;
 		}
@@ -105,5 +101,5 @@
 		olddata1 = data1;
 	}
-	while (1) {
+	while (true) {
 		data1 = slab_alloc(cache1, FRAME_ATOMIC);
 		if (!data1)
@@ -114,6 +110,5 @@
 	}
 	
-	if (!quiet)
-		printf("Deallocating cache1...");
+	TPRINTF("Deallocating cache1...");
 	
 	while (olddata1) {
@@ -123,8 +118,7 @@
 	}
 	
-	if (!quiet) {
-		printf("done.\n");
-		slab_print_list();
-	}
+	TPRINTF("done.\n");
+	
+	slab_print_list();
 	
 	slab_cache_destroy(cache1);
@@ -136,7 +130,6 @@
 static condvar_t thread_starter;
 static mutex_t starter_mutex;
-static bool sh_quiet;
-
-#define THREADS 8
+
+#define THREADS  8
 
 static void slabtest(void *priv)
@@ -150,12 +143,10 @@
 	mutex_unlock(&starter_mutex);
 	
-	if (!sh_quiet)
-		printf("Starting thread #%" PRIu64 "...\n", THREAD->tid);
+	TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid);
 
 	/* Alloc all */
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
-	
-	while (1) {
+	TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
+	
+	while (true) {
 		/* Call with atomic to detect end of memory */
 		new = slab_alloc(thr_cache, FRAME_ATOMIC);
@@ -166,6 +157,5 @@
 	}
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
+	TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
 	
 	while (data) {
@@ -176,8 +166,7 @@
 	}
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
-	
-	while (1) {
+	TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
+	
+	while (true) {
 		/* Call with atomic to detect end of memory */
 		new = slab_alloc(thr_cache, FRAME_ATOMIC);
@@ -188,6 +177,5 @@
 	}
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
+	TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
 	
 	while (data) {
@@ -198,6 +186,5 @@
 	}
 	
-	if (!sh_quiet)
-		printf("Thread #%" PRIu64 " finished\n", THREAD->tid);
+	TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
 	
 	slab_print_list();
@@ -205,5 +192,5 @@
 }
 
-static void multitest(int size, bool quiet)
+static void multitest(int size)
 {
 	/* Start 8 threads that just allocate as much as possible,
@@ -213,16 +200,14 @@
 	int i;
 	
-	if (!quiet)
-		printf("Running stress test with size %d\n", size);
+	TPRINTF("Running stress test with size %d\n", size);
 	
 	condvar_initialize(&thread_starter);
 	mutex_initialize(&starter_mutex, MUTEX_PASSIVE);
-
+	
 	thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
 	semaphore_initialize(&thr_sem,0);
 	for (i = 0; i < THREADS; i++) {  
 		if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
-			if (!quiet)
-				printf("Could not create thread %d\n", i);
+			TPRINTF("Could not create thread %d\n", i);
 		} else
 			thread_ready(t);
@@ -230,29 +215,25 @@
 	thread_sleep(1);
 	condvar_broadcast(&thread_starter);
-
+	
 	for (i = 0; i < THREADS; i++)
 		semaphore_down(&thr_sem);
 	
 	slab_cache_destroy(thr_cache);
-	if (!quiet)
-		printf("Stress test complete.\n");
-}
-
-char * test_slab2(bool quiet)
-{
-	sh_quiet = quiet;
-	
-	if (!quiet)
-		printf("Running reclaim single-thread test .. pass 1\n");
-	totalmemtest(quiet);
-	if (!quiet)
-		printf("Running reclaim single-thread test .. pass 2\n");
-	totalmemtest(quiet);
-	if (!quiet)
-		printf("Reclaim test OK.\n");
-	
-	multitest(128, quiet);
-	multitest(2048, quiet);
-	multitest(8192, quiet);
+	TPRINTF("Stress test complete.\n");
+}
+
+char *test_slab2(void)
+{
+	TPRINTF("Running reclaim single-thread test .. pass 1\n");
+	totalmemtest();
+	
+	TPRINTF("Running reclaim single-thread test .. pass 2\n");
+	totalmemtest();
+	
+	TPRINTF("Reclaim test OK.\n");
+	
+	multitest(128);
+	multitest(2048);
+	multitest(8192);
 	
 	return NULL;
Index: kernel/test/print/print1.c
===================================================================
--- kernel/test/print/print1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/print/print1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -30,27 +30,25 @@
 #include <test.h>
 
-char *test_print1(bool quiet)
+char *test_print1(void)
 {
-	if (!quiet) {
-		printf("Testing printf(\"%%*.*s\", 5, 3, \"text\"):\n");
-		printf("Expected output: \"  tex\"\n");
-		printf("Real output:     \"%*.*s\"\n\n", 5, 3, "text");
-		
-		printf("Testing printf(\"%%10.8s\", \"very long text\"):\n");
-		printf("Expected output: \"  very lon\"\n");
-		printf("Real output:     \"%10.8s\"\n\n", "very long text");
-		
-		printf("Testing printf(\"%%8.10s\", \"text\"):\n");
-		printf("Expected output: \"text\"\n");
-		printf("Real output:     \"%8.10s\"\n\n", "text");
-		
-		printf("Testing printf(\"%%8.10s\", \"very long text\"):\n");
-		printf("Expected output: \"very long \"\n");
-		printf("Real output:     \"%8.10s\"\n\n", "very long text");
-		
-		printf("Testing printf(\"%%s\", NULL):\n");
-		printf("Expected output: \"(NULL)\"\n");
-		printf("Real output:     \"%s\"\n\n", NULL);
-	}
+	TPRINTF("Testing printf(\"%%*.*s\", 5, 3, \"text\"):\n");
+	TPRINTF("Expected output: \"  tex\"\n");
+	TPRINTF("Real output:     \"%*.*s\"\n\n", 5, 3, "text");
+	
+	TPRINTF("Testing printf(\"%%10.8s\", \"very long text\"):\n");
+	TPRINTF("Expected output: \"  very lon\"\n");
+	TPRINTF("Real output:     \"%10.8s\"\n\n", "very long text");
+	
+	TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n");
+	TPRINTF("Expected output: \"text\"\n");
+	TPRINTF("Real output:     \"%8.10s\"\n\n", "text");
+	
+	TPRINTF("Testing printf(\"%%8.10s\", \"very long text\"):\n");
+	TPRINTF("Expected output: \"very long \"\n");
+	TPRINTF("Real output:     \"%8.10s\"\n\n", "very long text");
+	
+	TPRINTF("Testing printf(\"%%s\", NULL):\n");
+	TPRINTF("Expected output: \"(NULL)\"\n");
+	TPRINTF("Real output:     \"%s\"\n\n", NULL);
 	
 	return NULL;
Index: kernel/test/print/print2.c
===================================================================
--- kernel/test/print/print2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/print/print2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -30,29 +30,27 @@
 #include <test.h>
 
-char *test_print2(bool quiet)
+char *test_print2(void)
 {
-	if (!quiet) {
-		printf("Testing printf(\"%%c %%3.2c %%-3.2c %%2.3c %%-2.3c\", 'a', 'b', 'c', 'd', 'e'):\n");
-		printf("Expected output: [a] [  b] [c  ] [ d] [e ]\n");
-		printf("Real output:     [%c] [%3.2c] [%-3.2c] [%2.3c] [%-2.3c]\n\n", 'a', 'b', 'c', 'd', 'e');
-		
-		printf("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", 1, 2, 3, 4, 5):\n");
-		printf("Expected output: [1] [ 02] [03 ] [004] [005]\n");
-		printf("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", 1, 2, 3, 4, 5);
-		
-		printf("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", -1, -2, -3, -4, -5):\n");
-		printf("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
-		printf("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
-		
-		printf("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
-		printf("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
-		printf("Real output:     [%#x] [%#5.3x] [%#-5.3x] [%#3.5x] [%#-3.5x]\n\n", 17, 18, 19, 20, 21);
-		
-		unative_t nat = 0x12345678u;
-		
-		printf("Testing printf(\"%%#" PRIx64 " %%#" PRIx32 " %%#" PRIx16 " %%#" PRIx8 " %%#" PRIxn " %%#" PRIx64 " %%s\", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, \"Lovely string\"):\n");
-		printf("Expected output: [0x1234567887654321] [0x12345678] [0x1234] [0x12] [0x12345678] [0x1234567887654321] \"Lovely string\"\n");
-		printf("Real output:     [%#" PRIx64 "] [%#" PRIx32 "] [%#" PRIx16 "] [%#" PRIx8 "] [%#" PRIxn "] [%#" PRIx64 "] \"%s\"\n\n", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, "Lovely string");
-	}
+	TPRINTF("Testing printf(\"%%c %%3.2c %%-3.2c %%2.3c %%-2.3c\", 'a', 'b', 'c', 'd', 'e'):\n");
+	TPRINTF("Expected output: [a] [  b] [c  ] [ d] [e ]\n");
+	TPRINTF("Real output:     [%c] [%3.2c] [%-3.2c] [%2.3c] [%-2.3c]\n\n", 'a', 'b', 'c', 'd', 'e');
+	
+	TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", 1, 2, 3, 4, 5):\n");
+	TPRINTF("Expected output: [1] [ 02] [03 ] [004] [005]\n");
+	TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", 1, 2, 3, 4, 5);
+	
+	TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", -1, -2, -3, -4, -5):\n");
+	TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
+	TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
+	
+	TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
+	TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
+	TPRINTF("Real output:     [%#x] [%#5.3x] [%#-5.3x] [%#3.5x] [%#-3.5x]\n\n", 17, 18, 19, 20, 21);
+	
+	unative_t nat = 0x12345678u;
+	
+	TPRINTF("Testing printf(\"%%#" PRIx64 " %%#" PRIx32 " %%#" PRIx16 " %%#" PRIx8 " %%#" PRIxn " %%#" PRIx64 " %%s\", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, \"Lovely string\"):\n");
+	TPRINTF("Expected output: [0x1234567887654321] [0x12345678] [0x1234] [0x12] [0x12345678] [0x1234567887654321] \"Lovely string\"\n");
+	TPRINTF("Real output:     [%#" PRIx64 "] [%#" PRIx32 "] [%#" PRIx16 "] [%#" PRIx8 "] [%#" PRIxn "] [%#" PRIx64 "] \"%s\"\n\n", 0x1234567887654321ll, 0x12345678, 0x1234, 0x12, nat, 0x1234567887654321ull, "Lovely string");
 	
 	return NULL;
Index: kernel/test/print/print3.c
===================================================================
--- kernel/test/print/print3.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/print/print3.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -33,30 +33,28 @@
 #define BUFFER_SIZE  32
 
-char *test_print3(bool quiet)
+char *test_print3(void)
 {
-	if (!quiet) {
-		char buffer[BUFFER_SIZE];
-		int retval;
-		
-		printf("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short text without parameters.\"):\n");
-		printf("Expected result: retval=30 buffer=\"Short text without parameters.\"\n");
-		retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
-		printf("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
-		
-		printf("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very very very long text without parameters.\"):\n");
-		printf("Expected result: retval=44 buffer=\"Very very very long text withou\"\n");
-		retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
-		printf("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
-		
-		printf("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short %%s.\", \"text\"):\n");
-		printf("Expected result: retval=11 buffer=\"Short text.\"\n");
-		retval = snprintf(buffer, BUFFER_SIZE, "Short %s.", "text");
-		printf("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
-		
-		printf("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very long %%s. This text's length is more than %%d. We are interested in the result.\", \"text\", " STRING(BUFFER_SIZE) "):\n");
-		printf("Expected result: retval=84 buffer=\"Very long text. This text's len\"\n");
-		retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text's length is more than %d. We are interested in the result.", "text", BUFFER_SIZE);
-		printf("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
-	}
+	char buffer[BUFFER_SIZE];
+	int retval;
+	
+	TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short text without parameters.\"):\n");
+	TPRINTF("Expected result: retval=30 buffer=\"Short text without parameters.\"\n");
+	retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
+	TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
+	
+	TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very very very long text without parameters.\"):\n");
+	TPRINTF("Expected result: retval=44 buffer=\"Very very very long text withou\"\n");
+	retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
+	TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
+	
+	TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short %%s.\", \"text\"):\n");
+	TPRINTF("Expected result: retval=11 buffer=\"Short text.\"\n");
+	retval = snprintf(buffer, BUFFER_SIZE, "Short %s.", "text");
+	TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
+	
+	TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very long %%s. This text's length is more than %%d. We are interested in the result.\", \"text\", " STRING(BUFFER_SIZE) "):\n");
+	TPRINTF("Expected result: retval=84 buffer=\"Very long text. This text's len\"\n");
+	retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text's length is more than %d. We are interested in the result.", "text", BUFFER_SIZE);
+	TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
 	
 	return NULL;
Index: kernel/test/print/print4.c
===================================================================
--- kernel/test/print/print4.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/print/print4.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -30,54 +30,52 @@
 #include <test.h>
 
-char *test_print4(bool quiet)
+char *test_print4(void)
 {
-	if (!quiet) {
-		printf("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n");
+	TPRINTF("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n");
+	
+	uint8_t group;
+	for (group = 1; group < 4; group++) {
+		TPRINTF("%#" PRIx8 ": ", group << 5);
 		
-		uint8_t group;
-		for (group = 1; group < 4; group++) {
-			printf("%#" PRIx8 ": ", group << 5);
-			
-			uint8_t index;
-			for (index = 0; index < 32; index++)
-				printf("%c", (char) ((group << 5) + index));
-			
-			printf("  ");
-			for (index = 0; index < 32; index++)
-				printf("%lc", (wchar_t) ((group << 5) + index));
-			
-			printf("\n");
-		}
+		uint8_t index;
+		for (index = 0; index < 32; index++)
+			TPRINTF("%c", (char) ((group << 5) + index));
 		
-		printf("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
+		TPRINTF("  ");
+		for (index = 0; index < 32; index++)
+			TPRINTF("%lc", (wchar_t) ((group << 5) + index));
 		
-		for (group = 4; group < 8; group++) {
-			printf("%#" PRIx8 ": ", group << 5);
-			
-			uint8_t index;
-			for (index = 0; index < 32; index++)
-				printf("%lc", (wchar_t) ((group << 5) + index));
-			
-			printf("\n");
-		}
+		TPRINTF("\n");
+	}
+	
+	TPRINTF("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
+	
+	for (group = 4; group < 8; group++) {
+		TPRINTF("%#" PRIx8 ": ", group << 5);
 		
-		printf("\nUTF-8 strings using printf(\"%%s\"):\n");
-		printf("English:  %s\n", "Quick brown fox jumps over the lazy dog");
-		printf("Czech:    %s\n", "Příliš žluťoučký kůň úpěl ďábelské ódy");
-		printf("Greek:    %s\n", "Ὦ ξεῖν’, ἀγγέλλειν Λακεδαιμονίοις ὅτι τῇδε");
-		printf("Hebrew:   %s\n", "משוואת ברנולי היא משוואה בהידרודינמיקה");
-		printf("Arabic:   %s\n", "التوزيع الجغرافي للحمل العنقودي");
-		printf("Russian:  %s\n", "Леннон познакомился с художницей-авангардисткой");
-		printf("Armenian: %s\n", "Սկսեց հրատարակվել Երուսաղեմի հայկական");
+		uint8_t index;
+		for (index = 0; index < 32; index++)
+			TPRINTF("%lc", (wchar_t) ((group << 5) + index));
 		
-		printf("\nUTF-32 strings using printf(\"%%ls\"):\n");
-		printf("English:  %ls\n", L"Quick brown fox jumps over the lazy dog");
-		printf("Czech:    %ls\n", L"Příliš žluťoučký kůň úpěl ďábelské ódy");
-		printf("Greek:    %ls\n", L"Ὦ ξεῖν’, ἀγγέλλειν Λακεδαιμονίοις ὅτι τῇδε");
-		printf("Hebrew:   %ls\n", L"משוואת ברנולי היא משוואה בהידרודינמיקה");
-		printf("Arabic:   %ls\n", L"التوزيع الجغرافي للحمل العنقودي");
-		printf("Russian:  %ls\n", L"Леннон познакомился с художницей-авангардисткой");
-		printf("Armenian: %ls\n", L"Սկսեց հրատարակվել Երուսաղեմի հայկական");
+		TPRINTF("\n");
 	}
+	
+	TPRINTF("\nUTF-8 strings using printf(\"%%s\"):\n");
+	TPRINTF("English:  %s\n", "Quick brown fox jumps over the lazy dog");
+	TPRINTF("Czech:    %s\n", "Příliš žluťoučký kůň úpěl ďábelské ódy");
+	TPRINTF("Greek:    %s\n", "Ὦ ξεῖν’, ἀγγέλλειν Λακεδαιμονίοις ὅτι τῇδε");
+	TPRINTF("Hebrew:   %s\n", "משוואת ברנולי היא משוואה בהידרודינמיקה");
+	TPRINTF("Arabic:   %s\n", "التوزيع الجغرافي للحمل العنقودي");
+	TPRINTF("Russian:  %s\n", "Леннон познакомился с художницей-авангардисткой");
+	TPRINTF("Armenian: %s\n", "Սկսեց հրատարակվել Երուսաղեմի հայկական");
+	
+	TPRINTF("\nUTF-32 strings using printf(\"%%ls\"):\n");
+	TPRINTF("English:  %ls\n", L"Quick brown fox jumps over the lazy dog");
+	TPRINTF("Czech:    %ls\n", L"Příliš žluťoučký kůň úpěl ďábelské ódy");
+	TPRINTF("Greek:    %ls\n", L"Ὦ ξεῖν’, ἀγγέλλειν Λακεδαιμονίοις ὅτι τῇδε");
+	TPRINTF("Hebrew:   %ls\n", L"משוואת ברנולי היא משוואה בהידרודינמיקה");
+	TPRINTF("Arabic:   %ls\n", L"التوزيع الجغرافي للحمل العنقودي");
+	TPRINTF("Russian:  %ls\n", L"Леннон познакомился с художницей-авангардисткой");
+	TPRINTF("Armenian: %ls\n", L"Սկսեց հրատարակվել Երուսաղեմի հայկական");
 	
 	return NULL;
Index: kernel/test/synch/rwlock1.c
===================================================================
--- kernel/test/synch/rwlock1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/rwlock1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -36,24 +36,24 @@
 #include <synch/rwlock.h>
 
-#define READERS		50
-#define WRITERS		50
+#define READERS  50
+#define WRITERS  50
 
 static rwlock_t rwlock;
 
-char * test_rwlock1(bool quiet)
+char *test_rwlock1(void)
 {
 	rwlock_initialize(&rwlock);
-
+	
 	rwlock_write_lock(&rwlock);
-	rwlock_write_unlock(&rwlock);	
-
-	rwlock_read_lock(&rwlock);
-	rwlock_read_lock(&rwlock);	
+	rwlock_write_unlock(&rwlock);
+	
 	rwlock_read_lock(&rwlock);
 	rwlock_read_lock(&rwlock);
 	rwlock_read_lock(&rwlock);
-
+	rwlock_read_lock(&rwlock);
+	rwlock_read_lock(&rwlock);
+	
 	rwlock_read_unlock(&rwlock);
-	rwlock_read_unlock(&rwlock);	
+	rwlock_read_unlock(&rwlock);
 	rwlock_read_unlock(&rwlock);
 	rwlock_read_unlock(&rwlock);
@@ -61,12 +61,12 @@
 	
 	rwlock_write_lock(&rwlock);
-	rwlock_write_unlock(&rwlock);	
-
+	rwlock_write_unlock(&rwlock);
+	
 	rwlock_read_lock(&rwlock);
 	rwlock_read_unlock(&rwlock);
-
+	
 	rwlock_write_lock(&rwlock);
-	rwlock_write_unlock(&rwlock);	
-
+	rwlock_write_unlock(&rwlock);
+	
 	rwlock_read_lock(&rwlock);
 	rwlock_read_unlock(&rwlock);
Index: kernel/test/synch/rwlock2.c
===================================================================
--- kernel/test/synch/rwlock2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/rwlock2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -35,36 +35,32 @@
 #include <synch/rwlock.h>
 
-#define READERS		50
-#define WRITERS		50
+#define READERS  50
+#define WRITERS  50
 
 static rwlock_t rwlock;
-static bool sh_quiet;
 
 static void writer(void *arg)
 {
-	if (!sh_quiet)
-		printf("Trying to lock rwlock for writing....\n");
+	TPRINTF("Trying to lock rwlock for writing....\n");
 	
 	rwlock_write_lock(&rwlock);
 	rwlock_write_unlock(&rwlock);
 	
-	if (!sh_quiet)
-		printf("Trying to lock rwlock for reading....\n");
+	TPRINTF("Trying to lock rwlock for reading....\n");
 	
 	rwlock_read_lock(&rwlock);
-	rwlock_read_unlock(&rwlock);	
+	rwlock_read_unlock(&rwlock);
 }
 
-char * test_rwlock2(bool quiet)
+char *test_rwlock2(void)
 {
 	thread_t *thrd;
-	sh_quiet = quiet;
 	
 	rwlock_initialize(&rwlock);
-
+	
 	rwlock_read_lock(&rwlock);
 	rwlock_read_lock(&rwlock);
 	rwlock_read_lock(&rwlock);
-	rwlock_read_lock(&rwlock);	
+	rwlock_read_lock(&rwlock);
 	
 	thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
@@ -73,5 +69,5 @@
 	else
 		return "Could not create thread";
-
+	
 	thread_sleep(1);
 	
Index: kernel/test/synch/rwlock3.c
===================================================================
--- kernel/test/synch/rwlock3.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/rwlock3.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -35,9 +35,8 @@
 #include <synch/rwlock.h>
 
-#define THREADS	4
+#define THREADS  4
 
 static atomic_t thread_count;
 static rwlock_t rwlock;
-static bool sh_quiet;
 
 static void reader(void *arg)
@@ -45,29 +44,24 @@
 	thread_detach(THREAD);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 ": trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for reading....\n", CPU->id, THREAD->tid);
 	
 	rwlock_read_lock(&rwlock);
 	rwlock_read_unlock(&rwlock);
 	
-	if (!sh_quiet) {
-		printf("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);    		
-		printf("cpu%u, tid %" PRIu64 ": trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);    	
-	}
-
+	TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 ": trying to lock rwlock for writing....\n", CPU->id, THREAD->tid);
+	
 	rwlock_write_lock(&rwlock);
 	rwlock_write_unlock(&rwlock);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 ": success\n", CPU->id, THREAD->tid);
 	
 	atomic_dec(&thread_count);
 }
 
-char * test_rwlock3(bool quiet)
+char *test_rwlock3(void)
 {
 	int i;
 	thread_t *thrd;
-	sh_quiet = quiet;
 	
 	atomic_set(&thread_count, THREADS);
@@ -80,14 +74,13 @@
 		if (thrd)
 			thread_ready(thrd);
-		else if (!quiet)
-			printf("Could not create reader %d\n", i);
+		else
+			TPRINTF("Could not create reader %d\n", i);
 	}
-
+	
 	thread_sleep(1);
 	rwlock_write_unlock(&rwlock);
 	
 	while (atomic_get(&thread_count) > 0) {
-		if (!quiet)
-			printf("Threads left: %ld\n", atomic_get(&thread_count));
+		TPRINTF("Threads left: %ld\n", atomic_get(&thread_count));
 		thread_sleep(1);
 	}
Index: kernel/test/synch/rwlock4.c
===================================================================
--- kernel/test/synch/rwlock4.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/rwlock4.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -41,11 +41,10 @@
 #include <synch/spinlock.h>
 
-#define READERS		50
-#define WRITERS		50
+#define READERS  50
+#define WRITERS  50
 
 static atomic_t thread_count;
 static rwlock_t rwlock;
 static atomic_t threads_fault;
-static bool sh_quiet;
 
 SPINLOCK_INITIALIZE(rw_lock);
@@ -58,6 +57,6 @@
 {
 	uint32_t rc;
-
-	spinlock_lock(&rw_lock);	
+	
+	spinlock_lock(&rw_lock);
 	rc = seed % max;
 	seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc;
@@ -71,41 +70,37 @@
 	thread_detach(THREAD);
 	waitq_sleep(&can_start);
-
+	
 	to = random(40000);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " w+ (%d)\n", CPU->id, THREAD->tid, to);
+	TPRINTF("cpu%u, tid %" PRIu64 " w+ (%d)\n", CPU->id, THREAD->tid, to);
 	
 	rc = rwlock_write_lock_timeout(&rwlock, to);
 	if (SYNCH_FAILED(rc)) {
-		if (!sh_quiet)
-			printf("cpu%u, tid %" PRIu64 " w!\n", CPU->id, THREAD->tid);
+		TPRINTF("cpu%u, tid %" PRIu64 " w!\n", CPU->id, THREAD->tid);
 		atomic_dec(&thread_count);
 		return;
 	}
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " w=\n", CPU->id, THREAD->tid);
-
+	TPRINTF("cpu%u, tid %" PRIu64 " w=\n", CPU->id, THREAD->tid);
+	
 	if (rwlock.readers_in) {
-		if (!sh_quiet)
-			printf("Oops.");
+		TPRINTF("Oops.\n");
 		atomic_inc(&threads_fault);
 		atomic_dec(&thread_count);
 		return;
 	}
+	
 	thread_usleep(random(1000000));
+	
 	if (rwlock.readers_in) {
-		if (!sh_quiet)
-			printf("Oops.");	
+		TPRINTF("Oops.\n");
 		atomic_inc(&threads_fault);
 		atomic_dec(&thread_count);
 		return;
 	}
-
+	
 	rwlock_write_unlock(&rwlock);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " w-\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 " w-\n", CPU->id, THREAD->tid);
 	atomic_dec(&thread_count);
 }
@@ -119,31 +114,26 @@
 	to = random(2000);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " r+ (%d)\n", CPU->id, THREAD->tid, to);
+	TPRINTF("cpu%u, tid %" PRIu64 " r+ (%d)\n", CPU->id, THREAD->tid, to);
 	
 	rc = rwlock_read_lock_timeout(&rwlock, to);
 	if (SYNCH_FAILED(rc)) {
-		if (!sh_quiet)
-			printf("cpu%u, tid %" PRIu64 " r!\n", CPU->id, THREAD->tid);
+		TPRINTF("cpu%u, tid %" PRIu64 " r!\n", CPU->id, THREAD->tid);
 		atomic_dec(&thread_count);
 		return;
 	}
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " r=\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 " r=\n", CPU->id, THREAD->tid);
 	
 	thread_usleep(30000);
 	rwlock_read_unlock(&rwlock);
 	
-	if (!sh_quiet)
-		printf("cpu%u, tid %" PRIu64 " r-\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 " r-\n", CPU->id, THREAD->tid);
 	atomic_dec(&thread_count);
 }
 
-char * test_rwlock4(bool quiet)
+char *test_rwlock4(void)
 {
 	context_t ctx;
 	uint32_t i;
-	sh_quiet = quiet;
 	
 	waitq_initialize(&can_start);
@@ -159,8 +149,6 @@
 	
 	context_save(&ctx);
-	if (!quiet) {
-		printf("sp=%#x, readers_in=%" PRIc "\n", ctx.sp, rwlock.readers_in);
-		printf("Creating %" PRIu32 " readers\n", rd);
-	}
+	TPRINTF("sp=%#x, readers_in=%" PRIc "\n", ctx.sp, rwlock.readers_in);
+	TPRINTF("Creating %" PRIu32 " readers\n", rd);
 	
 	for (i = 0; i < rd; i++) {
@@ -168,10 +156,9 @@
 		if (thrd)
 			thread_ready(thrd);
-		else if (!quiet)
-			printf("Could not create reader %" PRIu32 "\n", i);
+		else
+			TPRINTF("Could not create reader %" PRIu32 "\n", i);
 	}
-
-	if (!quiet)
-		printf("Creating %" PRIu32 " writers\n", wr);
+	
+	TPRINTF("Creating %" PRIu32 " writers\n", wr);
 	
 	for (i = 0; i < wr; i++) {
@@ -179,6 +166,6 @@
 		if (thrd)
 			thread_ready(thrd);
-		else if (!quiet)
-			printf("Could not create writer %" PRIu32 "\n", i);
+		else
+			TPRINTF("Could not create writer %" PRIu32 "\n", i);
 	}
 	
@@ -187,6 +174,5 @@
 	
 	while (atomic_get(&thread_count) > 0) {
-		if (!quiet)
-			printf("Threads left: %ld\n", atomic_get(&thread_count));
+		TPRINTF("Threads left: %ld\n", atomic_get(&thread_count));
 		thread_sleep(1);
 	}
Index: kernel/test/synch/rwlock5.c
===================================================================
--- kernel/test/synch/rwlock5.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/rwlock5.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -36,6 +36,6 @@
 #include <synch/rwlock.h>
 
-#define READERS		50
-#define WRITERS		50
+#define READERS  50
+#define WRITERS  50
 
 static rwlock_t rwlock;
@@ -48,7 +48,7 @@
 {
 	thread_detach(THREAD);
-
+	
 	waitq_sleep(&can_start);
-
+	
 	rwlock_write_lock(&rwlock);
 	atomic_inc(&items_written);
@@ -59,5 +59,5 @@
 {
 	thread_detach(THREAD);
-
+	
 	waitq_sleep(&can_start);
 	
@@ -67,5 +67,5 @@
 }
 
-char * test_rwlock5(bool quiet)
+char *test_rwlock5(void)
 {
 	int i, j, k;
@@ -77,12 +77,12 @@
 	for (i = 1; i <= 3; i++) {
 		thread_t *thrd;
-
+		
 		atomic_set(&items_read, 0);
 		atomic_set(&items_written, 0);
-
+		
 		readers = i * READERS;
 		writers = (4 - i) * WRITERS;
-
-		printf("Creating %ld readers and %ld writers...", readers, writers);
+		
+		TPRINTF("Creating %ld readers and %ld writers...", readers, writers);
 		
 		for (j = 0; j < (READERS + WRITERS) / 2; j++) {
@@ -92,5 +92,5 @@
 					thread_ready(thrd);
 				else
-					printf("Could not create reader %d\n", k);
+					TPRINTF("Could not create reader %d\n", k);
 			}
 			for (k = 0; k < (4 - i); k++) {
@@ -99,15 +99,15 @@
 					thread_ready(thrd);
 				else
-					printf("Could not create writer %d\n", k);
+					TPRINTF("Could not create writer %d\n", k);
 			}
 		}
-
-		printf("ok\n");
-
+		
+		TPRINTF("ok\n");
+		
 		thread_sleep(1);
 		waitq_wakeup(&can_start, WAKEUP_ALL);
-	
+		
 		while ((items_read.count != readers) || (items_written.count != writers)) {
-			printf("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in);
+			TPRINTF("%d readers remaining, %d writers remaining, readers_in=%d\n", readers - items_read.count, writers - items_written.count, rwlock.readers_in);
 			thread_usleep(100000);
 		}
Index: kernel/test/synch/semaphore1.c
===================================================================
--- kernel/test/synch/semaphore1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/semaphore1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -36,7 +36,7 @@
 #include <synch/semaphore.h>
 
-#define AT_ONCE			3
-#define PRODUCERS		50
-#define CONSUMERS		50
+#define AT_ONCE    3
+#define PRODUCERS  50
+#define CONSUMERS  50
 
 static semaphore_t sem;
@@ -48,8 +48,8 @@
 static void producer(void *arg)
 {
-	thread_detach(THREAD);	
-
+	thread_detach(THREAD);
+	
 	waitq_sleep(&can_start);
-	    
+	
 	semaphore_down(&sem);
 	atomic_inc(&items_produced);
@@ -60,5 +60,5 @@
 static void consumer(void *arg)
 {
-	thread_detach(THREAD);	
+	thread_detach(THREAD);
 	
 	waitq_sleep(&can_start);
@@ -70,5 +70,5 @@
 }
 
-char * test_semaphore1(bool quiet)
+char *test_semaphore1(void)
 {
 	int i, j, k;
@@ -77,8 +77,8 @@
 	waitq_initialize(&can_start);
 	semaphore_initialize(&sem, AT_ONCE);
-
+	
 	for (i = 1; i <= 3; i++) {
 		thread_t *thrd;
-
+		
 		atomic_set(&items_produced, 0);
 		atomic_set(&items_consumed, 0);
@@ -87,6 +87,6 @@
 		producers = (4 - i) * PRODUCERS;
 		
-		printf("Creating %d consumers and %d producers...", consumers, producers);
-	
+		TPRINTF("Creating %d consumers and %d producers...", consumers, producers);
+		
 		for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
 			for (k = 0; k < i; k++) {
@@ -95,5 +95,5 @@
 					thread_ready(thrd);
 				else
-					printf("could not create consumer %d\n", i);
+					TPRINTF("could not create consumer %d\n", i);
 			}
 			for (k = 0; k < (4 - i); k++) {
@@ -102,15 +102,15 @@
 					thread_ready(thrd);
 				else
-					printf("could not create producer %d\n", i);
+					TPRINTF("could not create producer %d\n", i);
 			}
 		}
-
-		printf("ok\n");
-
+		
+		TPRINTF("ok\n");
+		
 		thread_sleep(1);
 		waitq_wakeup(&can_start, WAKEUP_ALL);
-	
+		
 		while ((items_consumed.count != consumers) || (items_produced.count != producers)) {
-			printf("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count);
+			TPRINTF("%d consumers remaining, %d producers remaining\n", consumers - items_consumed.count, producers - items_produced.count);
 			thread_sleep(1);
 		}
Index: kernel/test/synch/semaphore2.c
===================================================================
--- kernel/test/synch/semaphore2.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/synch/semaphore2.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -51,6 +51,6 @@
 {
 	uint32_t rc;
-
-	spinlock_lock(&sem_lock);	
+	
+	spinlock_lock(&sem_lock);
 	rc = seed % max;
 	seed = (((seed << 2) ^ (seed >> 2)) * 487) + rc;
@@ -68,19 +68,19 @@
 	
 	to = random(20000);
-	printf("cpu%u, tid %" PRIu64 " down+ (%d)\n", CPU->id, THREAD->tid, to);
+	TPRINTF("cpu%u, tid %" PRIu64 " down+ (%d)\n", CPU->id, THREAD->tid, to);
 	rc = semaphore_down_timeout(&sem, to);
 	if (SYNCH_FAILED(rc)) {
-		printf("cpu%u, tid %" PRIu64 " down!\n", CPU->id, THREAD->tid);
+		TPRINTF("cpu%u, tid %" PRIu64 " down!\n", CPU->id, THREAD->tid);
 		return;
 	}
 	
-	printf("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid);	
+	TPRINTF("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid);	
 	thread_usleep(random(30000));
 	
 	semaphore_up(&sem);
-	printf("cpu%u, tid %" PRIu64 " up\n", CPU->id, THREAD->tid);
+	TPRINTF("cpu%u, tid %" PRIu64 " up\n", CPU->id, THREAD->tid);
 }
 
-char * test_semaphore2(bool quiet)
+char *test_semaphore2(void)
 {
 	uint32_t i, k;
@@ -92,5 +92,5 @@
 	
 	k = random(7) + 1;
-	printf("Creating %" PRIu32 " consumers\n", k);
+	TPRINTF("Creating %" PRIu32 " consumers\n", k);
 	for (i = 0; i < k; i++) {
 		thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
@@ -98,5 +98,5 @@
 			thread_ready(thrd);
 		else
-			printf("Error creating thread\n");
+			TPRINTF("Error creating thread\n");
 	}
 	
Index: kernel/test/sysinfo/sysinfo1.c
===================================================================
--- kernel/test/sysinfo/sysinfo1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/sysinfo/sysinfo1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -33,7 +33,7 @@
 #include <sysinfo/sysinfo.h>
 
-char * test_sysinfo1(bool quiet)
+char *test_sysinfo1(void)
 {
-	if (!quiet)
+	if (!test_quiet)
 		sysinfo_dump(NULL, 0);
 	return NULL;
Index: kernel/test/test.c
===================================================================
--- kernel/test/test.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/test.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -34,4 +34,6 @@
 
 #include <test.h>
+
+bool test_quiet;
 
 test_t tests[] = {
Index: kernel/test/test.h
===================================================================
--- kernel/test/test.h	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/test.h	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -39,5 +39,14 @@
 #include <typedefs.h>
 
-typedef char *(*test_entry_t)(bool);
+extern bool test_quiet;
+
+#define TPRINTF(format, ...) \
+	{ \
+		if (!test_quiet) { \
+			printf(format, ##__VA_ARGS__); \
+		} \
+	}
+
+typedef char *(*test_entry_t)(void);
 
 typedef struct {
@@ -48,31 +57,31 @@
 } test_t;
 
-extern char *test_atomic1(bool quiet);
-extern char *test_avltree1(bool quiet);
-extern char *test_btree1(bool quiet);
-extern char *test_mips1(bool quiet);
-extern char *test_fault1(bool quiet);
-extern char *test_fpu1(bool quiet);
-extern char *test_sse1(bool quiet);
-extern char *test_mips2(bool quiet);
-extern char *test_falloc1(bool quiet);
-extern char *test_falloc2(bool quiet);
-extern char *test_mapping1(bool quiet);
-extern char *test_purge1(bool quiet);
-extern char *test_slab1(bool quiet);
-extern char *test_slab2(bool quiet);
-extern char *test_rwlock1(bool quiet);
-extern char *test_rwlock2(bool quiet);
-extern char *test_rwlock3(bool quiet);
-extern char *test_rwlock4(bool quiet);
-extern char *test_rwlock5(bool quiet);
-extern char *test_semaphore1(bool quiet);
-extern char *test_semaphore2(bool quiet);
-extern char *test_print1(bool quiet);
-extern char *test_print2(bool quiet);
-extern char *test_print3(bool quiet);
-extern char *test_print4(bool quiet);
-extern char *test_thread1(bool quiet);
-extern char *test_sysinfo1(bool quiet);
+extern char *test_atomic1(void);
+extern char *test_avltree1(void);
+extern char *test_btree1(void);
+extern char *test_mips1(void);
+extern char *test_fault1(void);
+extern char *test_fpu1(void);
+extern char *test_sse1(void);
+extern char *test_mips2(void);
+extern char *test_falloc1(void);
+extern char *test_falloc2(void);
+extern char *test_mapping1(void);
+extern char *test_purge1(void);
+extern char *test_slab1(void);
+extern char *test_slab2(void);
+extern char *test_rwlock1(void);
+extern char *test_rwlock2(void);
+extern char *test_rwlock3(void);
+extern char *test_rwlock4(void);
+extern char *test_rwlock5(void);
+extern char *test_semaphore1(void);
+extern char *test_semaphore2(void);
+extern char *test_print1(void);
+extern char *test_print2(void);
+extern char *test_print3(void);
+extern char *test_print4(void);
+extern char *test_thread1(void);
+extern char *test_sysinfo1(void);
 
 extern test_t tests[];
Index: kernel/test/thread/thread1.c
===================================================================
--- kernel/test/thread/thread1.c	(revision 171f9a1fe9f611d6f72a49a47ddb0eaefd93ccbd)
+++ kernel/test/thread/thread1.c	(revision cb01e1ee9f069d7d14148e3efc3cb37d1011b8de)
@@ -37,17 +37,15 @@
 #include <arch.h>
 
-#define THREADS 5
+#define THREADS  5
 
 static atomic_t finish;
 static atomic_t threads_finished;
-static bool sh_quiet;
 
 static void threadtest(void *data)
 {
-	thread_detach(THREAD);	
-
+	thread_detach(THREAD);
+	
 	while (atomic_get(&finish)) {
-		if (!sh_quiet)
-			printf("%" PRIu64 " ", THREAD->tid);
+		TPRINTF("%" PRIu64 " ", THREAD->tid);
 		thread_usleep(100000);
 	}
@@ -55,17 +53,15 @@
 }
 
-char * test_thread1(bool quiet)
+char *test_thread1(void)
 {
 	unsigned int i, total = 0;
-	sh_quiet = quiet;
 	
 	atomic_set(&finish, 1);
 	atomic_set(&threads_finished, 0);
-
+	
 	for (i = 0; i < THREADS; i++) {  
 		thread_t *t;
 		if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) {
-			if (!quiet)
-				printf("Could not create thread %d\n", i);
+			TPRINTF("Could not create thread %d\n", i);
 			break;
 		}
@@ -74,12 +70,10 @@
 	}
 	
-	if (!quiet)
-		printf("Running threads for 10 seconds...\n");
+	TPRINTF("Running threads for 10 seconds...\n");
 	thread_sleep(10);
 	
 	atomic_set(&finish, 0);
 	while (atomic_get(&threads_finished) < ((long) total)) {
-		if (!quiet)
-			printf("Threads left: %d\n", total - atomic_get(&threads_finished));
+		TPRINTF("Threads left: %d\n", total - atomic_get(&threads_finished));
 		thread_sleep(1);
 	}