Changes in tests/exceptions/resume.cfa [3bf9d10:d00d581]

File:

• tests/exceptions/resume.cfa (modified) (8 diffs)

tests/exceptions/resume.cfa

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