Index: tests/exceptions/resume.cfa
===================================================================
--- tests/exceptions/resume.cfa	(revision d00d58175bd0e1df5524a7109ec9127ccb133764)
+++ tests/exceptions/resume.cfa	(revision 3df4cd95d31b16667c378d2fdb5bca5d9c22f2bc)
@@ -1,4 +1,5 @@
 // Resumption Exception Tests
 
+#include <fstream.hfa>
 #include "except-io.hfa"
 
@@ -21,12 +22,12 @@
 	try {
 		loud_exit a = "simple try clause";
-		printf("simple throw\n");
+		sout | "simple throw";
 		throwResume a_zen;
-		printf("end of try clause\n");
+		sout | "end of try clause";
 	} catchResume (zen * error) {
 		loud_exit a = "simple catch clause";
-		printf("simple catch\n");
+		sout | "simple catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw catch-all test.
@@ -34,7 +35,7 @@
 		throwResume a_zen;
 	} catchResume (exception_t * error) {
-		printf("catch-all\n");
+		sout | "catch-all";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Don't catch if handler does not match exception.
@@ -43,12 +44,12 @@
 			throwResume a_yin;
 		} catchResume (zen *) {
-			printf("caught yin as zen\n");
+			sout | "caught yin as zen";
 		}
 	} catchResume (yang *) {
-		printf("caught yin as yang\n");
+		sout | "caught yin as yang";
 	} catchResume (yin *) {
-		printf("caught yin as yin\n");
+		sout | "caught yin as yin";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Test rethrowing an exception.
@@ -56,16 +57,16 @@
 		try {
 			loud_exit a = "rethrow inner try";
-			printf("rethrow inner try\n");
+			sout | "rethrow inner try";
 			throwResume a_zen;
 		} catchResume (zen *) {
 			loud_exit a = "rethrowing catch clause";
-			printf("caught throw, will rethrow\n");
+			sout | "caught throw, will rethrow";
 			throwResume;
 		}
 	} catchResume (zen *) {
 		loud_exit a = "rethrow catch clause";
-		printf("caught rethrow\n");
+		sout | "caught rethrow";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw a different exception in a catch.
@@ -74,35 +75,35 @@
 			throwResume a_yin;
 		} catchResume (yin *) {
-			printf("caught yin, will throw yang\n");
+			sout | "caught yin, will throw yang";
 			throwResume a_yang;
 		} catchResume (yang *) {
-			printf("caught exception from same try\n");
+			sout | "caught exception from same try";
 		}
 	} catchResume (yang *) {
-		printf("caught yang\n");
+		sout | "caught yang";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Another throw in the catch does not interfere.
 	try {
 		try {
-			printf("throwing first exception\n");
+			sout | "throwing first exception";
 			throwResume a_yin;
 		} catchResume (yin *) {
-			printf("caught first exception\n");
+			sout | "caught first exception";
 			try {
-				printf("throwing second exception\n");
+				sout | "throwing second exception";
 				throwResume a_yang;
 			} catchResume (yang *) {
-				printf("caught second exception\n");
+				sout | "caught second exception";
 			}
 			throwResume;
 		}
 	} catchResume (yin *) {
-		printf("recaught first exception\n");
+		sout | "recaught first exception";
 	} catchResume (yang *) {
-		printf("caught second exception (bad location)\n");
+		sout | "caught second exception (bad location)";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Check successive operations.
@@ -112,11 +113,11 @@
 			throwResume a_zen;
 		} catchResume (zen *) {
-			printf("inner catch\n");
+			sout | "inner catch";
 		}
 		throwResume a_zen;
 	} catchResume (zen *) {
-		printf("outer catch\n");
+		sout | "outer catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	in_void();
@@ -128,12 +129,12 @@
 	try {
 		try {
-			printf("throw\n");
+			sout | "throw";
 			throwResume a_zen;
 		} catchResume (zen *) {
-			printf("rethrow\n");
+			sout | "rethrow";
 			throwResume;
 		}
 	} catchResume (zen *) {
-		printf("handle\n");
+		sout | "handle";
 	}
 }