Changeset 18571 in vbox

Timestamp:

Mar 31, 2009 1:08:16 PM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

45465

Message:

tstUtf8: Converted to RTTest (awful lot of work) and added RTStrStr and RTStrIStr tests.

File:

• trunk/src/VBox/Runtime/testcase/tstUtf8.cpp (modified) (46 diffs)

trunk/src/VBox/Runtime/testcase/tstUtf8.cpp

@@ -41 +41 @@
 #include <iprt/assert.h>
 #include <iprt/err.h>
+#include <iprt/test.h>
 
 #include <stdlib.h>
 
-
-/*******************************************************************************
-*   Global Variables                                                           *
-*******************************************************************************/
-static int g_cErrors = 0;
 
 
@@ -68 +64 @@
  *
  */
-static void test1(void)
+static void test1(RTTEST hTest)
 {
     static const char s_szBadString1[] = "Bad \xe0\x13\x0";
@@ -78 +74 @@
     PRTUTF16 pwszRand;
 
-    RTPrintf("tstUtf8: TEST 1\n");
-
     /*
      * Invalid UTF-8 to UCS-2 test.
      */
+    RTTestSub(hTest, "Feeding bad UTF-8 to RTStrToUtf16");
     rc = RTStrToUtf16(s_szBadString1, &pwsz);
-    if (rc != VERR_NO_TRANSLATION && rc != VERR_INVALID_UTF8_ENCODING)
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: Conversion of first bad UTF-8 string to UTF-16 apparantly succeeded. It shouldn't. rc=%Rrc\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
+    RTTEST_CHECK_MSG(hTest, rc == rc != VERR_NO_TRANSLATION || rc == VERR_INVALID_UTF8_ENCODING,
+                     (hTest, RTTESTLVL_FAILURE, "Conversion of first bad UTF-8 string to UTF-16 apparantly succeeded. It shouldn't. rc=%Rrc\n", rc));
     rc = RTStrToUtf16(s_szBadString2, &pwsz);
-    if (rc != VERR_NO_TRANSLATION && rc != VERR_INVALID_UTF8_ENCODING)
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: Conversion of second bad UTF-8 strings to UTF-16 apparantly succeeded. It shouldn't. rc=%Rrc\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
+    RTTEST_CHECK_MSG(hTest, rc == rc != VERR_NO_TRANSLATION || rc == VERR_INVALID_UTF8_ENCODING,
+                     (hTest, RTTESTLVL_FAILURE, "Conversion of second bad UTF-8 strings to UTF-16 apparantly succeeded. It shouldn't. rc=%Rrc\n", rc));
 
     /*
      * Test current CP convertion.
      */
+    RTTestSub(hTest, "Rand UTF-16 -> UTF-8 -> CP -> UTF-8");
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -115 +103 @@
             rc = RTStrCurrentCPToUtf8(&pszUtf8, pszCurrent);
             if (rc == VINF_SUCCESS)
-                RTPrintf("tstUtf8: Random UTF-16 -> UTF-8 -> Current -> UTF-8 successful.\n");
+                RTTestPassed(hTest, "Random UTF-16 -> UTF-8 -> Current -> UTF-8 successful.\n");
             else
-            {
-                RTPrintf("tstUtf8: FAILURE - %d: The third part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.\n",
+                RTTestFailed(hTest, "%d: The third part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.",
+                             __LINE__, rc);
+        }
+        else if (rc == VERR_NO_TRANSLATION)
+            RTTestPassed(hTest, "The second part of random UTF-16 -> UTF-8 -> Current -> UTF-8 returned VERR_NO_TRANSLATION.  This is probably as it should be.\n");
+        else
+            RTTestFailed(hTest, "%d: The second part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.",
                          __LINE__, rc);
-                g_cErrors++;
-            }
-        }
-        else if (rc == VERR_NO_TRANSLATION)
-            RTPrintf("tstUtf8: The second part of random UTF-16 -> UTF-8 -> Current -> UTF-8 returned VERR_NO_TRANSLATION.  This is probably as it should be.\n");
-        else
-        {
-            RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.\n",
+    }
+    else
+        RTTestFailed(hTest, "%d: The first part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.",
                      __LINE__, rc);
-            g_cErrors++;
-        }
-    }
-    else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: The first part of random UTF-16 -> UTF-8 -> Current -> UTF-8 failed with return value %Rrc.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
 
     /*
      * Generate a new random string.
      */
+    RTTestSub(hTest, "Random UTF-16 -> UTF-8 -> UTF-16");
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -157 +137 @@
                 /* nothing */;
             if (pwszRand[i] == pwsz[i] && pwsz[i] == 0)
-                RTPrintf("tstUtf8: Random UTF-16 -> UTF-8 -> UTF-16 successful.\n");
+                RTTestPassed(hTest, "Random UTF-16 -> UTF-8 -> UTF-16 successful.\n");
             else
             {
-                RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> UTF-8 -> UTF-16 failed.\n", __LINE__);
-                RTPrintf("tstUtf8: First differing character is at position %d and has the value %x.\n", i, pwsz[i]);
-                g_cErrors++;
+                RTTestFailed(hTest, "%d: The second part of random UTF-16 -> UTF-8 -> UTF-16 failed.", __LINE__);
+                RTTestPrintf(hTest, RTTESTLVL_FAILURE, "First differing character is at position %d and has the value %x.\n", i, pwsz[i]);
             }
         }
         else
-        {
-            RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> UTF-8 -> UTF-16 failed with return value %Rrc.\n",
+            RTTestFailed(hTest, "%d: The second part of random UTF-16 -> UTF-8 -> UTF-16 failed with return value %Rrc.",
+                         __LINE__, rc);
+    }
+    else
+        RTTestFailed(hTest, "%d: The first part of random UTF-16 -> UTF-8 -> UTF-16 failed with return value %Rrc.",
                      __LINE__, rc);
-            g_cErrors++;
-        }
-    }
-    else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: The first part of random UTF-16 -> UTF-8 -> UTF-16 failed with return value %Rrc.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
 
     /*
      * Generate yet another random string and convert it to a buffer.
      */
+    RTTestSub(hTest, "Random RTUtf16ToUtf8Ex + RTStrToUtf16");
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -200 +174 @@
                 ;
             if (pwsz[i] == 0 && i >= 8)
-                RTPrintf("tstUtf8: Random UTF-16 -> fixed length UTF-8 -> UTF-16 successful.\n");
+                RTTestPassed(hTest, "Random UTF-16 -> fixed length UTF-8 -> UTF-16 successful.\n");
             else
             {
-                RTPrintf("tstUtf8: FAILURE - %d: Incorrect conversion of UTF-16 -> fixed length UTF-8 -> UTF-16.\n", __LINE__);
-                RTPrintf("tstUtf8: First differing character is at position %d and has the value %x.\n", i, pwsz[i]);
-                g_cErrors++;
+                RTTestFailed(hTest, "%d: Incorrect conversion of UTF-16 -> fixed length UTF-8 -> UTF-16.\n", __LINE__);
+                RTTestPrintf(hTest, RTTESTLVL_FAILURE, "First differing character is at position %d and has the value %x.\n", i, pwsz[i]);
             }
         }
         else
-        {
-            RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> fixed length UTF-8 -> UTF-16 failed with return value %Rrc.\n",
-                     __LINE__, rc);
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "%d: The second part of random UTF-16 -> fixed length UTF-8 -> UTF-16 failed with return value %Rrc.\n", __LINE__, rc);
     }
     else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: The first part of random UTF-16 -> fixed length UTF-8 -> UTF-16 failed with return value %Rrc.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "%d: The first part of random UTF-16 -> fixed length UTF-8 -> UTF-16 failed with return value %Rrc.\n", __LINE__, rc);
 
     /*
      * And again.
      */
+    RTTestSub(hTest, "Random RTUtf16ToUtf8 + RTStrToUtf16Ex");
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -243 +209 @@
                 ;
             if (pwszRand[i] == 0 && pwsz2Buf[i] == 0)
-                RTPrintf("tstUtf8: Random UTF-16 -> UTF-8 -> fixed length UTF-16 successful.\n");
+                RTTestPassed(hTest, "Random UTF-16 -> UTF-8 -> fixed length UTF-16 successful.\n");
             else
             {
-                RTPrintf("tstUtf8: FAILURE - %d: Incorrect conversion of random UTF-16 -> UTF-8 -> fixed length UTF-16.\n", __LINE__);
-                RTPrintf("tstUtf8: First differing character is at position %d and has the value %x.\n", i, pwsz2Buf[i]);
-                g_cErrors++;
+                RTTestFailed(hTest, "%d: Incorrect conversion of random UTF-16 -> UTF-8 -> fixed length UTF-16.\n", __LINE__);
+                RTTestPrintf(hTest, RTTESTLVL_FAILURE, "First differing character is at position %d and has the value %x.\n", i, pwsz2Buf[i]);
             }
         }
         else
-        {
-            RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n",
+            RTTestFailed(hTest, "%d: The second part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n", __LINE__, rc);
+    }
+    else
+        RTTestFailed(hTest, "%d: The first part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n",
                      __LINE__, rc);
-            g_cErrors++;
-        }
-    }
-    else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: The first part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -272 +230 @@
     rc = RTUtf16ToUtf8Ex(pwszRand, RTSTR_MAX, &pszUtf8Array, 20, NULL);
     if (rc == VERR_BUFFER_OVERFLOW)
-        RTPrintf("tstUtf8: Random UTF-16 -> fixed length UTF-8 with too short buffer successfully rejected.\n");
+        RTTestPassed(hTest, "Random UTF-16 -> fixed length UTF-8 with too short buffer successfully rejected.\n");
     else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d: Random UTF-16 -> fixed length UTF-8 with too small buffer returned value %d instead of VERR_BUFFER_OVERFLOW.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "%d: Random UTF-16 -> fixed length UTF-8 with too small buffer returned value %d instead of VERR_BUFFER_OVERFLOW.\n",
+                     __LINE__, rc);
 
     /*
      * last time...
      */
+    RTTestSub(hTest, "Random RTUtf16ToUtf8 + RTStrToUtf16Ex");
     pwszRand = (PRTUTF16)RTMemAlloc(31 * sizeof(*pwsz));
     srand((unsigned)RTTimeNanoTS());
@@ -294 +250 @@
         rc = RTStrToUtf16Ex(pszUtf8, RTSTR_MAX, &pwsz2Buf, 20, NULL);
         if (rc == VERR_BUFFER_OVERFLOW)
-            RTPrintf("tstUtf8: Random UTF-16 -> UTF-8 -> fixed length UTF-16 with too short buffer successfully rejected.\n");
-        else
-        {
-            RTPrintf("tstUtf8: FAILURE - %d: The second part of random UTF-16 -> UTF-8 -> fixed length UTF-16 with too short buffer returned value %Rrc instead of VERR_BUFFER_OVERFLOW.\n",
+            RTTestPassed(hTest, "Random UTF-16 -> UTF-8 -> fixed length UTF-16 with too short buffer successfully rejected.\n");
+        else
+            RTTestFailed(hTest, "%d: The second part of random UTF-16 -> UTF-8 -> fixed length UTF-16 with too short buffer returned value %Rrc instead of VERR_BUFFER_OVERFLOW.\n",
+                         __LINE__, rc);
+    }
+    else
+        RTTestFailed(hTest, "%d:The first part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n",
                      __LINE__, rc);
-            g_cErrors++;
-        }
-    }
-    else
-    {
-        RTPrintf("tstUtf8: FAILURE - %d:The first part of random UTF-16 -> UTF-8 -> fixed length UTF-16 failed with return value %Rrc.\n",
-                 __LINE__, rc);
-        g_cErrors++;
-    }
-
+
+
+    RTTestSubDone(hTest);
 }
 
@@ -321 +273 @@
     {
         if (off < 0x7f)
-            RTPrintf("UTF-8 U+%#x\n", off + 1);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 U+%#x\n", off + 1);
         else if (off < 0xf7f)
-            RTPrintf("UTF-8 U+%#x\n", (off - 0x7f) / 2 + 0x80);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 U+%#x\n", (off - 0x7f) / 2 + 0x80);
         else if (off < 0x27f7f)
-            RTPrintf("UTF-8 U+%#x\n", (off - 0xf7f) / 3 + 0x800);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 U+%#x\n", (off - 0xf7f) / 3 + 0x800);
         else if (off < 0x2df79)
-            RTPrintf("UTF-8 U+%#x\n", (off - 0x27f7f) / 3 + 0xe000);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 U+%#x\n", (off - 0x27f7f) / 3 + 0xe000);
         else if (off < 0x42df79)
-            RTPrintf("UTF-8 U+%#x\n", (off - 0x2df79) / 4 + 0x10000);
-        else
-            RTPrintf("UTF-8 ???\n");
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 U+%#x\n", (off - 0x2df79) / 4 + 0x10000);
+        else
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-8 ???\n");
     }
     else if (cBits == 16)
     {
         if (off < 0xd7ff*2)
-            RTPrintf("UTF-16 U+%#x\n", off / 2 + 1);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-16 U+%#x\n", off / 2 + 1);
         else if (off < 0xf7fd*2)
-            RTPrintf("UTF-16 U+%#x\n", (off - 0xd7ff*2) / 2 + 0xe000);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-16 U+%#x\n", (off - 0xd7ff*2) / 2 + 0xe000);
         else if (off < 0x20f7fd)
-            RTPrintf("UTF-16 U+%#x\n", (off - 0xf7fd*2) / 4 + 0x10000);
-        else
-            RTPrintf("UTF-16 ???\n");
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-16 U+%#x\n", (off - 0xf7fd*2) / 4 + 0x10000);
+        else
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "UTF-16 ???\n");
     }
     else
     {
         if (off < (0xd800 - 1) * sizeof(RTUNICP))
-            RTPrintf("RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 1);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 1);
         else if (off < (0xfffe - 0x800 - 1) * sizeof(RTUNICP))
-            RTPrintf("RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 0x800 + 1);
-        else
-            RTPrintf("RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 0x800 + 1 + 2);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 0x800 + 1);
+        else
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "RTUNICP U+%#x\n", off / sizeof(RTUNICP) + 0x800 + 1 + 2);
     }
 }
@@ -363 +315 @@
         if (pb1[off] != pb2[off])
         {
-            RTPrintf("mismatch at %#x: ", off);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "mismatch at %#x: ", off);
             whereami(cBits, off);
-            RTPrintf(" %#x: %02x != %02x!\n", off-1, pb1[off-1], pb2[off-1]);
-            RTPrintf("*%#x: %02x != %02x!\n", off, pb1[off], pb2[off]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+1, pb1[off+1], pb2[off+1]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+2, pb1[off+2], pb2[off+2]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+3, pb1[off+3], pb2[off+3]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+4, pb1[off+4], pb2[off+4]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+5, pb1[off+5], pb2[off+5]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+6, pb1[off+6], pb2[off+6]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+7, pb1[off+7], pb2[off+7]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+8, pb1[off+8], pb2[off+8]);
-            RTPrintf(" %#x: %02x != %02x!\n", off+9, pb1[off+9], pb2[off+9]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off-1, pb1[off-1], pb2[off-1]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, "*%#x: %02x != %02x!\n", off, pb1[off], pb2[off]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+1, pb1[off+1], pb2[off+1]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+2, pb1[off+2], pb2[off+2]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+3, pb1[off+3], pb2[off+3]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+4, pb1[off+4], pb2[off+4]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+5, pb1[off+5], pb2[off+5]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+6, pb1[off+6], pb2[off+6]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+7, pb1[off+7], pb2[off+7]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+8, pb1[off+8], pb2[off+8]);
+            RTTestPrintf(NIL_RTTEST, RTTESTLVL_FAILURE, " %#x: %02x != %02x!\n", off+9, pb1[off+9], pb2[off+9]);
             return 1;
         }
@@ -383 +335 @@
 
 
-void InitStrings(void)
+void InitStrings()
 {
     /*
@@ -476 +428 @@
 
 
-void test2(void)
-{
-    RTPrintf("tstUtf8: TEST 2\n");
-
+void test2(RTTEST hTest)
+{
     /*
      * Convert to UTF-8 and back.
      */
-    RTPrintf("tstUtf8: #1: UTF-16 -> UTF-8 -> UTF-16...\n");
+    RTTestSub(hTest, "UTF-16 -> UTF-8 -> UTF-16");
     char *pszUtf8;
     int rc = RTUtf16ToUtf8(&g_wszAll[0], &pszUtf8);
@@ -489 +439 @@
     {
         if (mymemcmp(pszUtf8, g_szAll, sizeof(g_szAll), 8))
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #1: UTF-16 -> UTF-8 mismatch!\n");
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "UTF-16 -> UTF-8 mismatch!");
 
         PRTUTF16 pwszUtf16;
@@ -499 +446 @@
         {
             if (mymemcmp(pwszUtf16, g_wszAll, sizeof(g_wszAll), 16))
-            {
-                RTPrintf("tstUtf8: FAILURE - the full #1: UTF-8 -> UTF-16 failed compare!\n");
-                g_cErrors++;
-            }
+                RTTestFailed(hTest, "UTF-8 -> UTF-16 failed compare!");
             RTUtf16Free(pwszUtf16);
         }
         else
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #1: UTF-8 -> UTF-16 failed, rc=%Rrc.\n", rc);
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "UTF-8 -> UTF-16 failed, rc=%Rrc.", rc);
         RTStrFree(pszUtf8);
     }
     else
-    {
-        RTPrintf("tstUtf8: FAILURE - the full #1: UTF-16 -> UTF-8 failed, rc=%Rrc.\n", rc);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "UTF-16 -> UTF-8 failed, rc=%Rrc.", rc);
 
 
@@ -522 +460 @@
      * Convert to UTF-16 and back. (just in case the above test fails)
      */
-    RTPrintf("tstUtf8: #2: UTF-8 -> UTF-16 -> UTF-8...\n");
+    RTTestSub(hTest, "UTF-8 -> UTF-16 -> UTF-8");
     PRTUTF16 pwszUtf16;
     rc = RTStrToUtf16(&g_szAll[0], &pwszUtf16);
@@ -528 +466 @@
     {
         if (mymemcmp(pwszUtf16, g_wszAll, sizeof(g_wszAll), 16))
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #2: UTF-8 -> UTF-16 failed compare!\n");
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "UTF-8 -> UTF-16 failed compare!");
 
         char *pszUtf8;
@@ -538 +473 @@
         {
             if (mymemcmp(pszUtf8, g_szAll, sizeof(g_szAll), 8))
-            {
-                RTPrintf("tstUtf8: FAILURE - the full #2: UTF-16 -> UTF-8 failed compare!\n");
-                g_cErrors++;
-            }
+                RTTestFailed(hTest, "UTF-16 -> UTF-8 failed compare!");
             RTStrFree(pszUtf8);
         }
         else
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #2: UTF-16 -> UTF-8 failed, rc=%Rrc.\n", rc);
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "UTF-16 -> UTF-8 failed, rc=%Rrc.", rc);
         RTUtf16Free(pwszUtf16);
     }
     else
-    {
-        RTPrintf("tstUtf8: FAILURE - the full #2: UTF-8 -> UTF-16 failed, rc=%Rrc.\n", rc);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "UTF-8 -> UTF-16 failed, rc=%Rrc.", rc);
 
     /*
      * Convert UTF-8 to CPs.
      */
+    RTTestSub(hTest, "UTF-8 -> UNI -> UTF-8");
     PRTUNICP paCps;
     rc = RTStrToUni(g_szAll, &paCps);
@@ -565 +492 @@
     {
         if (mymemcmp(paCps, g_uszAll, sizeof(g_uszAll), 32))
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #2: UTF-8 -> UTF-16 failed, rc=%Rrc.\n", rc);
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "UTF-8 -> UTF-16 failed, rc=%Rrc.", rc);
 
         size_t cCps;
@@ -575 +499 @@
         {
             if (cCps != RT_ELEMENTS(g_uszAll) - 1)
-            {
-                RTPrintf("tstUtf8: FAILURE - the full #3+: wrong Code Point count %zu, expected %zu\n", cCps, RT_ELEMENTS(g_uszAll) - 1);
-                g_cErrors++;
-            }
-        }
-        else
-        {
-            RTPrintf("tstUtf8: FAILURE - the full #3+: UTF-8 -> Code Points failed, rc=%Rrc.\n", rc);
-            g_cErrors++;
-        }
+                RTTestFailed(hTest, "wrong Code Point count %zu, expected %zu\n", cCps, RT_ELEMENTS(g_uszAll) - 1);
+        }
+        else
+            RTTestFailed(hTest, "UTF-8 -> Code Points failed, rc=%Rrc.\n", rc);
 
         /** @todo RTCpsToUtf8 or something. */
     }
     else
-    {
-        RTPrintf("tstUtf8: FAILURE - the full #3a: UTF-8 -> Code Points failed, rc=%Rrc.\n", rc);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "UTF-8 -> Code Points failed, rc=%Rrc.\n", rc);
 
     /*
      * Check the various string lengths.
      */
+    RTTestSub(hTest, "Lengths");
     size_t cuc1 = RTStrCalcUtf16Len(g_szAll);
     size_t cuc2 = RTUtf16Len(g_wszAll);
     if (cuc1 != cuc2)
-    {
-        RTPrintf("tstUtf8: FAILURE - cuc1=%zu != cuc2=%zu\n", cuc1, cuc2);
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "cuc1=%zu != cuc2=%zu\n", cuc1, cuc2);
     //size_t cuc3 = RTUniLen(g_uszAll);
 
@@ -610 +523 @@
      * Enumerate the strings.
      */
+    RTTestSub(hTest, "Code Point Getters and Putters");
     char *pszPut1Base = (char *)RTMemAlloc(sizeof(g_szAll));
     AssertRelease(pszPut1Base);
@@ -629 +543 @@
         if (RT_FAILURE(rc))
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrGetCpEx failed with rc=%Rrc at %.10Rhxs\n", rc, psz2);
+            RTTestFailed(hTest, "RTStrGetCpEx failed with rc=%Rrc at %.10Rhxs", rc, psz2);
             whereami(8, psz2 - &g_szAll[0]);
-            g_cErrors++;
             break;
         }
@@ -637 +550 @@
         if (pszPrev1 != psz2)
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrPrevCp returned %p expected %p!\n", pszPrev1, psz2);
+            RTTestFailed(hTest, "RTStrPrevCp returned %p expected %p!", pszPrev1, psz2);
             whereami(8, psz2 - &g_szAll[0]);
-            g_cErrors++;
             break;
         }
@@ -645 +557 @@
         if (uc2 != uc1)
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrGetCpEx and RTStrGetCp returned different CPs: %RTunicp != %RTunicp\n", uc2, uc1);
+            RTTestFailed(hTest, "RTStrGetCpEx and RTStrGetCp returned different CPs: %RTunicp != %RTunicp", uc2, uc1);
             whereami(8, psz2 - &g_szAll[0]);
-            g_cErrors++;
             break;
         }
@@ -653 +564 @@
         if (psz2 != psz1)
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrGetCpEx and RTStrGetNext returned different next pointer!\n");
+            RTTestFailed(hTest, "RTStrGetCpEx and RTStrGetNext returned different next pointer!");
             whereami(8, psz2 - &g_szAll[0]);
-            g_cErrors++;
             break;
         }
@@ -663 +573 @@
         if (RT_FAILURE(rc))
         {
-            RTPrintf("tstUtf8: FAILURE - RTUtf16GetCpEx failed with rc=%Rrc at %.10Rhxs\n", rc, pwsz4);
+            RTTestFailed(hTest, "RTUtf16GetCpEx failed with rc=%Rrc at %.10Rhxs", rc, pwsz4);
             whereami(16, pwsz4 - &g_wszAll[0]);
-            g_cErrors++;
             break;
         }
         if (uc3 != uc2)
         {
-            RTPrintf("tstUtf8: FAILURE - RTUtf16GetCpEx and RTStrGetCp returned different CPs: %RTunicp != %RTunicp\n", uc3, uc2);
+            RTTestFailed(hTest, "RTUtf16GetCpEx and RTStrGetCp returned different CPs: %RTunicp != %RTunicp", uc3, uc2);
             whereami(16, pwsz4 - &g_wszAll[0]);
-            g_cErrors++;
             break;
         }
@@ -678 +586 @@
         if (uc3 != uc4)
         {
-            RTPrintf("tstUtf8: FAILURE - RTUtf16GetCpEx and RTUtf16GetCp returned different CPs: %RTunicp != %RTunicp\n", uc3, uc4);
+            RTTestFailed(hTest, "RTUtf16GetCpEx and RTUtf16GetCp returned different CPs: %RTunicp != %RTunicp", uc3, uc4);
             whereami(16, pwsz4 - &g_wszAll[0]);
-            g_cErrors++;
             break;
         }
@@ -686 +593 @@
         if (pwsz4 != pwsz3)
         {
-            RTPrintf("tstUtf8: FAILURE - RTUtf16GetCpEx and RTUtf16GetNext returned different next pointer!\n");
+            RTTestFailed(hTest, "RTUtf16GetCpEx and RTUtf16GetNext returned different next pointer!");
             whereami(8, pwsz4 - &g_wszAll[0]);
-            g_cErrors++;
             break;
         }
@@ -699 +605 @@
         if (pszPut1 - pszPut1Base != psz1 - &g_szAll[0])
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrPutCp is not at the same offset! %p != %p\n",
-                     pszPut1 - pszPut1Base, psz1 - &g_szAll[0]);
+            RTTestFailed(hTest, "RTStrPutCp is not at the same offset! %p != %p",
+                         pszPut1 - pszPut1Base, psz1 - &g_szAll[0]);
             whereami(8, psz2 - &g_szAll[0]);
-            g_cErrors++;
             break;
         }
@@ -709 +614 @@
         if (pwszPut2 - pwszPut2Base != pwsz3 - &g_wszAll[0])
         {
-            RTPrintf("tstUtf8: FAILURE - RTStrPutCp is not at the same offset! %p != %p\n",
-                     pwszPut2 - pwszPut2Base, pwsz3 - &g_wszAll[0]);
+            RTTestFailed(hTest, "RTStrPutCp is not at the same offset! %p != %p",
+                         pwszPut2 - pwszPut2Base, pwsz3 - &g_wszAll[0]);
             whereami(8, pwsz4 - &g_wszAll[0]);
-            g_cErrors++;
             break;
         }
@@ -726 +630 @@
     {
         if (mymemcmp(pszPut1Base, g_szAll, sizeof(g_szAll), 8))
-        {
-            RTPrintf("tstUtf8: FAILURE - RTStrPutCp encoded the string incorrectly.\n");
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "RTStrPutCp encoded the string incorrectly.");
         if (mymemcmp(pwszPut2Base, g_wszAll, sizeof(g_wszAll), 16))
-        {
-            RTPrintf("tstUtf8: FAILURE - RTUtf16PutCp encoded the string incorrectly.\n");
-            g_cErrors++;
-        }
+            RTTestFailed(hTest, "RTUtf16PutCp encoded the string incorrectly.");
     }
 
     RTMemFree(pszPut1Base);
     RTMemFree(pwszPut2Base);
+
+    RTTestSubDone(hTest);
 }
 
@@ -745 +645 @@
  * Check case insensitivity.
  */
-void test3(void)
-{
-    RTPrintf("tstUtf8: TEST 3\n");
+void test3(RTTEST hTest)
+{
+    RTTestSub(hTest, "Case Sensitivitity");
 
     if (    RTUniCpToLower('a') != 'a'
@@ -759 +659 @@
         ||  RTUniCpToUpper('z') != 'Z'
         ||  RTUniCpToUpper('Z') != 'Z')
-    {
-        RTPrintf("tstUtf8: FAILURE - RTUniToUpper/Lower failed basic tests.\n");
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "RTUniToUpper/Lower failed basic tests.\n");
 
     if (RTUtf16ICmp(g_wszAll, g_wszAll))
-    {
-        RTPrintf("tstUtf8: FAILURE - RTUtf16ICmp failed the basic test.\n");
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "RTUtf16ICmp failed the basic test.\n");
 
     if (RTUtf16Cmp(g_wszAll, g_wszAll))
-    {
-        RTPrintf("tstUtf8: FAILURE - RTUtf16Cmp failed the basic test.\n");
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "RTUtf16Cmp failed the basic test.\n");
 
     static RTUTF16 s_wszTst1a[] = { 'a', 'B', 'c', 'D', 'E', 'f', 'g', 'h', 'i', 'j', 'K', 'L', 'm', 'N', 'o', 'P', 'q', 'r', 'S', 't', 'u', 'V', 'w', 'x', 'Y', 'Z', 0xc5, 0xc6, 0xf8, 0 };
@@ -783 +674 @@
         ||  RTUtf16ICmp(s_wszTst1b, s_wszTst1a)
         )
-    {
-        RTPrintf("tstUtf8: FAILURE - RTUtf16ICmp failed the alphabet test.\n");
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "RTUtf16ICmp failed the alphabet test.\n");
 
     if (    RTUtf16Cmp(s_wszTst1b, s_wszTst1b)
@@ -793 +681 @@
         ||  !RTUtf16Cmp(s_wszTst1b, s_wszTst1a)
         )
-    {
-        RTPrintf("tstUtf8: FAILURE - RTUtf16Cmp failed the alphabet test.\n");
-        g_cErrors++;
-    }
+        RTTestFailed(hTest, "RTUtf16Cmp failed the alphabet test.\n");
+
+    RTTestSubDone(hTest);
 }
 
@@ -803 +690 @@
  * Test the RTStr*Cmp functions.
  */
-void TstRTStrXCmp(void)
-{
-    RTPrintf("tstUtf8: TEST 4 - RTStr*Cmp\n");
+void TstRTStrXCmp(RTTEST hTest)
+{
 #define CHECK_DIFF(expr, op) \
     do \
@@ -811 +697 @@
         int iDiff = expr; \
         if (!(iDiff op 0)) \
-        { \
-            RTPrintf("tstUtf8(%d): failure - %d " #op " 0: %s\n", __LINE__, iDiff, #expr); \
-            g_cErrors++; \
-        } \
+            RTTestFailed(hTest, "%d: %d " #op " 0: %s\n", __LINE__, iDiff, #expr); \
     } while (0)
 
 /** @todo test the non-ascii bits. */
 
+    RTTestSub(hTest, "RTStrCmp");
     CHECK_DIFF(RTStrCmp(NULL, NULL), == );
     CHECK_DIFF(RTStrCmp(NULL, ""), < );
@@ -832 +716 @@
 
 
+    RTTestSub(hTest, "RTStrNCmp");
     CHECK_DIFF(RTStrNCmp(NULL, NULL, RTSTR_MAX), == );
     CHECK_DIFF(RTStrNCmp(NULL, "", RTSTR_MAX), < );
@@ -849 +734 @@
 
 
+    RTTestSub(hTest, "RTStrICmp");
     CHECK_DIFF(RTStrICmp(NULL, NULL), == );
     CHECK_DIFF(RTStrICmp(NULL, ""), < );
@@ -869 +755 @@
 
 
+    RTTestSub(hTest, "RTStrNICmp");
     CHECK_DIFF(RTStrNICmp(NULL, NULL, RTSTR_MAX), == );
     CHECK_DIFF(RTStrNICmp(NULL, "", RTSTR_MAX), < );
@@ -901 +788 @@
     /* We should continue using byte comparison when we hit the invalid CP.  Will assert in debug builds. */
     // CHECK_DIFF(RTStrNICmp("AbCd\xff""eg", "aBcD\xff""eF", 6), ==);
+
+    RTTestSubDone(hTest);
 }
 
@@ -908 +797 @@
  * Benchmark stuff.
  */
-void Benchmarks(void)
-{
-    RTPrintf("tstUtf8: BENCHMARKS\n");
+void Benchmarks(RTTEST hTest)
+{
     static union
     {
@@ -917 +805 @@
     } s_Buf;
 
+    RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Benchmarking RTStrToUtf16Ex:  "); /** @todo figure this stuff into the test framework. */
     PRTUTF16 pwsz = &s_Buf.wszBuf[0];
     int rc = RTStrToUtf16Ex(&g_szAll[0], RTSTR_MAX, &pwsz, RT_ELEMENTS(s_Buf.wszBuf), NULL);
@@ -928 +817 @@
             if (RT_FAILURE(rc))
             {
-                RTPrintf("tstUtf8: UTF-8 -> UTF-16 benchmark failed at i=%d, rc=%Rrc\n", i, rc);
+                RTTestFailed(hTest, "UTF-8 -> UTF-16 benchmark failed at i=%d, rc=%Rrc\n", i, rc);
                 break;
             }
         }
         uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
-        RTPrintf("tstUtf8: UTF-8 -> UTF-16: %d in %RI64ns\n", i, u64Elapsed);
-    }
-
+        RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%d in %RI64ns\n", i, u64Elapsed);
+    }
+
+    RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "Benchmarking RTUtf16ToUtf8Ex: ");
     char *psz = &s_Buf.szBuf[0];
     rc = RTUtf16ToUtf8Ex(&g_wszAll[0], RTSTR_MAX, &psz, RT_ELEMENTS(s_Buf.szBuf), NULL);
@@ -947 +837 @@
             if (RT_FAILURE(rc))
             {
-                RTPrintf("tstUtf8: UTF-16 -> UTF-8 benchmark failed at i=%d, rc=%Rrc\n", i, rc);
+                RTTestFailed(hTest, "UTF-16 -> UTF-8 benchmark failed at i=%d, rc=%Rrc\n", i, rc);
                 break;
             }
         }
         uint64_t u64Elapsed = RTTimeNanoTS() - u64Start;
-        RTPrintf("tstUtf8: UTF-16 -> UTF-8: %d in %RI64ns\n", i, u64Elapsed);
-    }
-
+        RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "%d in %RI64ns\n", i, u64Elapsed);
+    }
+
+}
+
+
+/**
+ * Tests RTStrStr and RTStrIStr.
+ */
+static void testStrStr(RTTEST hTest)
+{
+#define CHECK_NULL(expr) \
+    do { \
+        const char *pszRet = expr; \
+        if (pszRet != NULL) \
+            RTTestFailed(hTest, "%d: %#x -> %s expected NULL", __LINE__, #expr, pszRet); \
+    } while (0)
+
+#define CHECK(expr, expect) \
+    do { \
+        const char *pszRet = expr; \
+        if (    pszRet != expect \
+            &&  (   (expect) == NULL  \
+                 || pszRet == NULL \
+                 || strcmp(pszRet, (expect)) ) \
+            ) \
+            RTTestFailed(hTest, "%d: %#x -> %s expected %s", __LINE__, #expr, pszRet, (expect)); \
+    } while (0)
+
+
+    RTTestSub(hTest, "RTStrStr");
+    CHECK(RTStrStr("abcdef", ""), "abcdef");
+    CHECK_NULL(RTStrStr("abcdef", NULL));
+    CHECK_NULL(RTStrStr(NULL, ""));
+    CHECK_NULL(RTStrStr(NULL, NULL));
+    CHECK(RTStrStr("abcdef", "abcdef"), "abcdef");
+    CHECK(RTStrStr("abcdef", "b"), "bcdef");
+    CHECK(RTStrStr("abcdef", "bcdef"), "bcdef");
+    CHECK(RTStrStr("abcdef", "cdef"), "cdef");
+    CHECK(RTStrStr("abcdef", "cde"), "cdef");
+    CHECK(RTStrStr("abcdef", "cd"), "cdef");
+    CHECK(RTStrStr("abcdef", "c"), "cdef");
+    CHECK(RTStrStr("abcdef", "f"), "f");
+    CHECK(RTStrStr("abcdef", "ef"), "ef");
+    CHECK(RTStrStr("abcdef", "e"), "ef");
+    CHECK_NULL(RTStrStr("abcdef", "z"));
+    CHECK_NULL(RTStrStr("abcdef", "A"));
+    CHECK_NULL(RTStrStr("abcdef", "F"));
+
+    RTTestSub(hTest, "RTStrIStr");
+    CHECK(RTStrIStr("abcdef", ""), "abcdef");
+    CHECK_NULL(RTStrIStr("abcdef", NULL));
+    CHECK_NULL(RTStrIStr(NULL, ""));
+    CHECK_NULL(RTStrIStr(NULL, NULL));
+    CHECK(RTStrIStr("abcdef", "abcdef"), "abcdef");
+    CHECK(RTStrIStr("abcdef", "Abcdef"), "abcdef");
+    CHECK(RTStrIStr("abcdef", "ABcDeF"), "abcdef");
+    CHECK(RTStrIStr("abcdef", "b"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "B"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "bcdef"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "BCdEf"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "bCdEf"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "bcdEf"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "BcdEf"), "bcdef");
+    CHECK(RTStrIStr("abcdef", "cdef"), "cdef");
+    CHECK(RTStrIStr("abcdef", "cde"), "cdef");
+    CHECK(RTStrIStr("abcdef", "cd"), "cdef");
+    CHECK(RTStrIStr("abcdef", "c"), "cdef");
+    CHECK(RTStrIStr("abcdef", "f"), "f");
+    CHECK(RTStrIStr("abcdeF", "F"), "F");
+    CHECK(RTStrIStr("abcdef", "F"), "f");
+    CHECK(RTStrIStr("abcdef", "ef"), "ef");
+    CHECK(RTStrIStr("EeEef", "e"), "EeEef");
+    CHECK(RTStrIStr("EeEef", "E"), "EeEef");
+    CHECK(RTStrIStr("EeEef", "EE"), "EeEef");
+    CHECK(RTStrIStr("EeEef", "EEE"), "EeEef");
+    CHECK(RTStrIStr("EeEef", "EEEF"), "eEef");
+    CHECK_NULL(RTStrIStr("EeEef", "z"));
+
+#undef CHECK
+#undef CHECK_NULL
+    RTTestSubDone(hTest);
 }
 
@@ -960 +929 @@
 int main()
 {
-    RTR3Init();
+    /*
+     * Init the runtime and stuff.
+     */
+    RTTEST hTest;
+    if (    RT_FAILURE(RTR3Init())
+        ||  RT_FAILURE(RTTestCreate("tstUtf8", &hTest)))
+    {
+        RTPrintf("tstBitstUtf8: fatal initialization error\n");
+        return 1;
+    }
+    RTTestBanner(hTest);
 
     InitStrings();
-    test1();
-    test2();
-    test3();
-    TstRTStrXCmp();
-    Benchmarks();
+    test1(hTest);
+    test2(hTest);
+    test3(hTest);
+    TstRTStrXCmp(hTest);
+    testStrStr(hTest);
+    Benchmarks(hTest);
 
     /*
      * Summary
      */
-    if (!g_cErrors)
-        RTPrintf("tstUtf8: SUCCESS\n");
-    else
-        RTPrintf("tstUtf8: FAILURE - %d errors!\n", g_cErrors);
-
-    return !!g_cErrors;
-}
+    return RTTestSummaryAndDestroy(hTest);
+}