Changeset 19945 in vbox

Timestamp:

May 23, 2009 9:48:25 PM (16 years ago)

Author:

vboxsync

Message:

tstAvl -> tstRTAvl; use RTTest.

Location:

trunk/src/VBox/Runtime/testcase

Files:

• Makefile.kmk (modified) (2 diffs)
• tstRTAvl.cpp (moved) (moved from trunk/src/VBox/Runtime/testcase/tstAvl.cpp ) (68 diffs)

trunk/src/VBox/Runtime/testcase/Makefile.kmk

@@ -49 +49 @@
 #
 PROGRAMS += \
-        tstAvl \
+        tstRTAvl \
         tstBase64 \
         tstBitOperations \
@@ -136 +136 @@
 #
 
-tstAvl_SOURCES = tstAvl.cpp
+tstRTAvl_SOURCES = tstRTAvl.cpp
 
 tstBase64_TEMPLATE = VBOXR3TSTEXE

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - Avl trees.
+ * IPRT Testcase - AVL trees.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2009 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -29 +29 @@
  */
 
-
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
 #include <iprt/avl.h>
+
 #include <iprt/asm.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/rand.h>
 #include <iprt/stdarg.h>
 #include <iprt/string.h>
-
-#include <stdio.h>
-#include <stdlib.h> /* rand */
+#include <iprt/test.h>
 
 
@@ -60 +61 @@
 
 
-/**
- * Gets a random number between 0 and Max.
- *
- * @return random number.
- * @param   Max     The max number. (exclusive)
- */
-uint32_t Random(uint32_t Max)
-{
-    unsigned rc = rand();
-    if (Max < RAND_MAX)
-    {
-        while (rc >= Max)
-            rc /= 3;
-    }
-    else
-    {
-        /// @todo...
-    }
-    return rc;
-}
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+static RTTEST g_hTest;
+static RTRAND g_hRand;
 
 
@@ -88 +74 @@
  * @param   MaxKey      The max key value for the tracker. (exclusive)
  */
-PTRACKER TrackerCreate(uint32_t MaxKey)
+static PTRACKER TrackerCreate(uint32_t MaxKey)
 {
     uint32_t cbBitmap = (MaxKey + sizeof(uint32_t) * sizeof(uint8_t) - 1) / sizeof(uint8_t);
-    PTRACKER pTracker = (PTRACKER)calloc(1, RT_OFFSETOF(TRACKER, abBitmap[cbBitmap]));
+    PTRACKER pTracker = (PTRACKER)RTMemAllocZ(RT_OFFSETOF(TRACKER, abBitmap[cbBitmap]));
     if (pTracker)
     {
@@ -97 +83 @@
         pTracker->LastAllocatedKey = MaxKey;
         pTracker->cbBitmap = cbBitmap;
+        Assert(pTracker->cSetBits == 0);
     }
     return pTracker;
@@ -107 +94 @@
  * @param   pTracker        The tracker.
  */
-void TrackerDestroy(PTRACKER pTracker)
-{
-    if (pTracker)
-        free(pTracker);
+static void TrackerDestroy(PTRACKER pTracker)
+{
+    RTMemFree(pTracker);
 }
 
@@ -122 +108 @@
  * @param   KeyLast     The last key in the range. (inclusive)
  */
-bool TrackerInsert(PTRACKER pTracker, uint32_t Key, uint32_t KeyLast)
+static bool TrackerInsert(PTRACKER pTracker, uint32_t Key, uint32_t KeyLast)
 {
     bool fRc = !ASMBitTestAndSet(pTracker->abBitmap, Key);
@@ -147 +133 @@
  * @param   KeyLast     The last key in the range. (inclusive)
  */
-bool TrackerRemove(PTRACKER pTracker, uint32_t Key, uint32_t KeyLast)
+static bool TrackerRemove(PTRACKER pTracker, uint32_t Key, uint32_t KeyLast)
 {
     bool fRc = ASMBitTestAndClear(pTracker->abBitmap, Key);
@@ -174 +160 @@
  * @remark  The caller has to call TrackerInsert.
  */
-bool TrackerNewRandomEx(PTRACKER pTracker, uint32_t *pKey, uint32_t *pKeyLast, uint32_t cMaxKeys)
+static bool TrackerNewRandomEx(PTRACKER pTracker, uint32_t *pKey, uint32_t *pKeyLast, uint32_t cMaxKeys)
 {
     /*
      * Find a key.
      */
-    uint32_t Key = Random(pTracker->MaxKey);
+    uint32_t Key = RTRandAdvU32Ex(g_hRand, 0, pTracker->MaxKey - 1);
     if (ASMBitTest(pTracker->abBitmap, Key))
     {
@@ -194 +180 @@
             {
                 const uint32_t KeyPrev = Key;
-                Key = Random(KeyPrev);
+                Key = RTRandAdvU32Ex(g_hRand, 0, KeyPrev - 1);
                 if (!ASMBitTest(pTracker->abBitmap, Key))
                     break;
@@ -215 +201 @@
     else
     {
-        uint32_t cKeys = Random(RT_MIN(pTracker->MaxKey - Key, cMaxKeys));
+        uint32_t cKeys = RTRandAdvU32Ex(g_hRand, 0, RT_MIN(pTracker->MaxKey - Key, cMaxKeys - 1));
         KeyLast = Key + cKeys;
         int Key2 = ASMBitNextSet(pTracker->abBitmap, RT_ALIGN_32(KeyLast, 32), Key);
@@ -241 +227 @@
  * @remark  The caller has to call TrackerInsert.
  */
-bool TrackerNewRandom(PTRACKER pTracker, uint32_t *pKey)
+static bool TrackerNewRandom(PTRACKER pTracker, uint32_t *pKey)
 {
     return TrackerNewRandomEx(pTracker, pKey, NULL, 1);
@@ -255 +241 @@
  * @remark  The caller has to call TrackerRemove.
  */
-bool TrackerFindRandom(PTRACKER pTracker, uint32_t *pKey)
-{
-    uint32_t Key = Random(pTracker->MaxKey);
+static bool TrackerFindRandom(PTRACKER pTracker, uint32_t *pKey)
+{
+    uint32_t Key = RTRandAdvU32Ex(g_hRand, 0, pTracker->MaxKey - 1);
     if (!ASMBitTest(pTracker->abBitmap, Key))
     {
@@ -268 +254 @@
         else
         {
-            /* we're missing a ASMBitPrevSet function, so just try another, lower, value.*/
-            for (;;)
-            {
-                const uint32_t KeyPrev = Key;
-                Key = Random(KeyPrev);
-                if (ASMBitTest(pTracker->abBitmap, Key))
-                    break;
-                Key2 = ASMBitNextSet(pTracker->abBitmap, RT_ALIGN_32(KeyPrev, 32), Key);
-                if (Key2 > 0)
+            /* we're missing a ASMBitPrevSet function, so here's a quick replacement hack. */
+            uint32_t *pu32Start = (uint32_t *)&pTracker->abBitmap[0];
+            uint32_t *pu32Cur   = (uint32_t *)&pTracker->abBitmap[Key >> 8];
+            while (pu32Cur >= pu32Start)
+            {
+                if (*pu32Cur)
                 {
-                    Key = Key2;
-                    break;
+                    *pKey = ASMBitLastSetU32(*pu32Cur) - 1 + (uint32_t)((pu32Cur - pu32Start) * 32);
+                    return true;
                 }
-            }
+                pu32Cur--;
+            }
+            Key2 = ASMBitFirstSet(pTracker->abBitmap, pTracker->MaxKey);
+            if (Key2 == -1)
+            {
+                RTTestIFailed("cSetBits=%u - but ASMBitFirstSet failed to find any", pTracker->cSetBits);
+                return false;
+            }
+            Key = Key2;
         }
     }
@@ -301 +292 @@
  * @param   ch  The char.
  */
-void ProgressChar(char ch)
-{
-    fputc(ch, stdout);
-    fflush(stdout);
+static void ProgressChar(char ch)
+{
+    //RTTestIPrintf(RTTESTLVL_INFO, "%c", ch);
+    RTTestIPrintf(RTTESTLVL_SUB_TEST, "%c", ch);
 }
 
@@ -317 +308 @@
     if (cMax < 10000)
         return;
+
     va_list va;
     va_start(va, pszFormat);
-    vfprintf(stdout, pszFormat, va);
+    //RTTestIPrintfV(RTTESTLVL_INFO, pszFormat, va);
+    RTTestIPrintfV(RTTESTLVL_SUB_TEST, pszFormat, va);
     va_end(va);
 }
@@ -338 +331 @@
 
 
-int avlogcphys(unsigned cMax)
+static int avlogcphys(unsigned cMax)
 {
     /*
      * Simple linear insert and remove.
      */
-    ProgressPrintf(cMax, "tstAVL oGCPhys(%d): linear left", cMax);
-    PAVLOGCPHYSTREE pTree = (PAVLOGCPHYSTREE)calloc(sizeof(*pTree),1);
+    if (cMax >= 10000)
+        RTTestISubF("oGCPhys(%d): linear left", cMax);
+    PAVLOGCPHYSTREE pTree = (PAVLOGCPHYSTREE)RTMemAllocZ(sizeof(*pTree));
     unsigned i;
     for (i = 0; i < cMax; i++)
     {
         Progress(i, cMax);
-        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvloGCPhysInsert(pTree, pNode))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear left insert i=%d\n", i);
+            RTTestIFailed("linear left insert i=%d\n", i);
             return 1;
         }
@@ -360 +354 @@
         if (RTAvloGCPhysInsert(pTree, &Node))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear left negative insert i=%d\n", i);
+            RTTestIFailed("linear left negative insert i=%d\n", i);
             return 1;
         }
@@ -372 +366 @@
         if (!pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear left remove i=%d\n", i);
+            RTTestIFailed("linear left remove i=%d\n", i);
             return 1;
         }
         memset(pNode, 0xcc, sizeof(*pNode));
-        free(pNode);
+        RTMemFree(pNode);
 
         /* negative */
@@ -382 +376 @@
         if (pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear left negative remove i=%d\n", i);
+            RTTestIFailed("linear left negative remove i=%d\n", i);
             return 1;
         }
@@ -390 +384 @@
      * Simple linear insert and remove from the right.
      */
-    ProgressPrintf(cMax, "\ntstAVL oGCPhys(%d): linear right", cMax);
+    if (cMax >= 10000)
+        RTTestISubF("oGCPhys(%d): linear right", cMax);
     for (i = 0; i < cMax; i++)
     {
         Progress(i, cMax);
-        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvloGCPhysInsert(pTree, pNode))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear right insert i=%d\n", i);
+            RTTestIFailed("linear right insert i=%d\n", i);
             return 1;
         }
@@ -405 +400 @@
         if (RTAvloGCPhysInsert(pTree, &Node))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear right negative insert i=%d\n", i);
+            RTTestIFailed("linear right negative insert i=%d\n", i);
             return 1;
         }
@@ -417 +412 @@
         if (!pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear right remove i=%d\n", i);
+            RTTestIFailed("linear right remove i=%d\n", i);
             return 1;
         }
         memset(pNode, 0xcc, sizeof(*pNode));
-        free(pNode);
+        RTMemFree(pNode);
 
         /* negative */
@@ -427 +422 @@
         if (pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear right negative remove i=%d\n", i);
+            RTTestIFailed("linear right negative remove i=%d\n", i);
             return 1;
         }
@@ -435 +430 @@
      * Linear insert but root based removal.
      */
-    ProgressPrintf(cMax, "\ntstAVL oGCPhys(%d): linear root", cMax);
+    if (cMax >= 10000)
+        RTTestISubF("oGCPhys(%d): linear root", cMax);
     for (i = 0; i < cMax; i++)
     {
         Progress(i, cMax);
-        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvloGCPhysInsert(pTree, pNode))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear root insert i=%d\n", i);
+            RTTestIFailed("linear root insert i=%d\n", i);
             return 1;
         }
@@ -450 +446 @@
         if (RTAvloGCPhysInsert(pTree, &Node))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear root negative insert i=%d\n", i);
+            RTTestIFailed("linear root negative insert i=%d\n", i);
             return 1;
         }
@@ -464 +460 @@
         if (!pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear root remove i=%d Key=%d\n", i, (unsigned)Key);
+            RTTestIFailed("linear root remove i=%d Key=%d\n", i, (unsigned)Key);
             return 1;
         }
         memset(pNode, 0xcc, sizeof(*pNode));
-        free(pNode);
+        RTMemFree(pNode);
 
         /* negative */
@@ -474 +470 @@
         if (pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear root negative remove i=%d Key=%d\n", i, (unsigned)Key);
+            RTTestIFailed("linear root negative remove i=%d Key=%d\n", i, (unsigned)Key);
             return 1;
         }
@@ -480 +476 @@
     if (*pTree)
     {
-        printf("\ntstAvl: FAILURE - oGCPhys - sparse remove didn't remove it all!\n");
+        RTTestIFailed("sparse remove didn't remove it all!\n");
         return 1;
     }
@@ -488 +484 @@
      */
     const unsigned cMaxSparse = RT_ALIGN(cMax, 32);
-    ProgressPrintf(cMaxSparse, "\ntstAVL oGCPhys(%d): sparse", cMax);
+    if (cMaxSparse >= 10000)
+        RTTestISubF("oGCPhys(%d): sparse", cMax);
     for (i = 0; i < cMaxSparse; i += 8)
     {
         Progress(i, cMaxSparse);
-        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvloGCPhysInsert(pTree, pNode))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - sparse insert i=%d\n", i);
+            RTTestIFailed("sparse insert i=%d\n", i);
             return 1;
         }
@@ -503 +500 @@
         if (RTAvloGCPhysInsert(pTree, &Node))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - sparse negative insert i=%d\n", i);
+            RTTestIFailed("sparse negative insert i=%d\n", i);
             return 1;
         }
@@ -519 +516 @@
             if (!pNode)
             {
-                printf("\ntstAvl: FAILURE - oGCPhys - sparse remove i=%d j=%d\n", i, j);
+                RTTestIFailed("sparse remove i=%d j=%d\n", i, j);
                 return 1;
             }
             if (pNode->Key - (unsigned long)i >= 8 * 4)
             {
-                printf("\ntstAvl: FAILURE - oGCPhys - sparse remove i=%d j=%d Key=%d\n", i, j, (unsigned)pNode->Key);
+                RTTestIFailed("sparse remove i=%d j=%d Key=%d\n", i, j, (unsigned)pNode->Key);
                 return 1;
             }
             memset(pNode, 0xdd, sizeof(*pNode));
-            free(pNode);
+            RTMemFree(pNode);
         }
     }
     if (*pTree)
     {
-        printf("\ntstAvl: FAILURE - oGCPhys - sparse remove didn't remove it all!\n");
+        RTTestIFailed("sparse remove didn't remove it all!\n");
         return 1;
     }
-    free(pTree);
+    RTMemFree(pTree);
     ProgressPrintf(cMaxSparse, "\n");
     return 0;
@@ -544 +541 @@
 int avlogcphysRand(unsigned cMax, unsigned cMax2)
 {
-    PAVLOGCPHYSTREE pTree = (PAVLOGCPHYSTREE)calloc(sizeof(*pTree),1);
+    PAVLOGCPHYSTREE pTree = (PAVLOGCPHYSTREE)RTMemAllocZ(sizeof(*pTree));
     unsigned i;
 
@@ -550 +547 @@
      * Random tree.
      */
-    ProgressPrintf(cMax, "tstAVL oGCPhys(%d, %d): random", cMax, cMax2);
+    if (cMax >= 10000)
+        RTTestISubF("oGCPhys(%d, %d): random", cMax, cMax2);
     PTRACKER pTracker = TrackerCreate(cMax2);
     if (!pTracker)
     {
-        printf("tstAVL: Failure - oGCPhys - failed to create %d tracker!\n", cMax2);
+        RTTestIFailed("failed to create %d tracker!\n", cMax2);
         return 1;
     }
@@ -565 +563 @@
         if (!TrackerNewRandom(pTracker, &Key))
         {
-            printf("\ntstAVL: Failure - oGCPhys - failed to allocate node no. %d\n", i);
+            RTTestIFailed("failed to allocate node no. %d\n", i);
             TrackerDestroy(pTracker);
             return 1;
         }
-        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLOGCPHYSNODECORE pNode = (PAVLOGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = Key;
         if (!RTAvloGCPhysInsert(pTree, pNode))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - random insert i=%d Key=%#x\n", i, Key);
+            RTTestIFailed("random insert i=%d Key=%#x\n", i, Key);
             return 1;
         }
@@ -580 +578 @@
         if (RTAvloGCPhysInsert(pTree, &Node))
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - linear negative insert i=%d Key=%#x\n", i, Key);
+            RTTestIFailed("linear negative insert i=%d Key=%#x\n", i, Key);
             return 1;
         }
@@ -595 +593 @@
         if (!TrackerFindRandom(pTracker, &Key))
         {
-            printf("\ntstAVL: Failure - oGCPhys - failed to find free node no. %d\n", i);
+            RTTestIFailed("failed to find free node no. %d\n", i);
             TrackerDestroy(pTracker);
             return 1;
@@ -603 +601 @@
         if (!pNode)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - random remove i=%d Key=%#x\n", i, Key);
+            RTTestIFailed("random remove i=%d Key=%#x\n", i, Key);
             return 1;
         }
         if (pNode->Key != Key)
         {
-            printf("\ntstAvl: FAILURE - oGCPhys - random remove i=%d Key=%#x pNode->Key=%#x\n", i, Key, (unsigned)pNode->Key);
+            RTTestIFailed("random remove i=%d Key=%#x pNode->Key=%#x\n", i, Key, (unsigned)pNode->Key);
             return 1;
         }
         TrackerRemove(pTracker, Key, Key);
         memset(pNode, 0xdd, sizeof(*pNode));
-        free(pNode);
+        RTMemFree(pNode);
     }
     if (*pTree)
     {
-        printf("\ntstAvl: FAILURE - oGCPhys - random remove didn't remove it all!\n");
+        RTTestIFailed("random remove didn't remove it all!\n");
         return 1;
     }
     ProgressPrintf(cMax, "\n");
     TrackerDestroy(pTracker);
-    free(pTree);
+    RTMemFree(pTree);
     return 0;
 }
@@ -633 +631 @@
     unsigned            j;
     unsigned            k;
-    PAVLROGCPHYSTREE    pTree = (PAVLROGCPHYSTREE)calloc(sizeof(*pTree), 1);
+    PAVLROGCPHYSTREE    pTree = (PAVLROGCPHYSTREE)RTMemAllocZ(sizeof(*pTree));
 
     AssertCompileSize(AVLOGCPHYSNODECORE, 24);
     AssertCompileSize(AVLROGCPHYSNODECORE, 32);
 
+    RTTestISubF("RTAvlroGCPhys");
+
     /*
      * Simple linear insert, get and remove.
@@ -644 +644 @@
     for (i = 0; i < 65536; i += 4)
     {
-        PAVLROGCPHYSNODECORE pNode = (PAVLROGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLROGCPHYSNODECORE pNode = (PAVLROGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         pNode->KeyLast = i + 3;
         if (!RTAvlroGCPhysInsert(pTree, pNode))
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear insert i=%d\n", (unsigned)i);
+            RTTestIFailed("linear insert i=%d\n", (unsigned)i);
             return 1;
         }
@@ -663 +663 @@
                 if (RTAvlroGCPhysInsert(pTree, &Node))
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - linear negative insert i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("linear negative insert i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -676 +676 @@
         if (!pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear get i=%d\n", i);
+            RTTestIFailed("linear get i=%d\n", i);
             return 1;
         }
         if (pNode->Key > i || pNode->KeyLast < i)
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear get i=%d Key=%d KeyLast=%d\n", i, (unsigned)pNode->Key, (unsigned)pNode->KeyLast);
+            RTTestIFailed("linear get i=%d Key=%d KeyLast=%d\n", i, (unsigned)pNode->Key, (unsigned)pNode->KeyLast);
             return 1;
         }
@@ -689 +689 @@
             if (RTAvlroGCPhysRangeGet(pTree, i + j) != pNode)
             {
-                printf("tstAvl: FAILURE - roGCPhys - linear range get i=%d j=%d\n", i, j);
+                RTTestIFailed("linear range get i=%d j=%d\n", i, j);
                 return 1;
             }
@@ -699 +699 @@
             ||  RTAvlroGCPhysGet(pTree, i + 3))
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear negative get i=%d + n\n", i);
+            RTTestIFailed("linear negative get i=%d + n\n", i);
             return 1;
         }
@@ -711 +711 @@
         if (!pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear remove i=%d\n", i);
+            RTTestIFailed("linear remove i=%d\n", i);
             return 1;
         }
         memset(pNode, 0xcc, sizeof(*pNode));
-        free(pNode);
+        RTMemFree(pNode);
 
         /* negative */
@@ -723 +723 @@
             ||  RTAvlroGCPhysRemove(pTree, i + 3))
         {
-            printf("tstAvl: FAILURE - roGCPhys - linear negative remove i=%d + n\n", i);
+            RTTestIFailed("linear negative remove i=%d + n\n", i);
             return 1;
         }
@@ -733 +733 @@
     for (i = 0; i < 65536; i += 8)
     {
-        PAVLROGCPHYSNODECORE pNode = (PAVLROGCPHYSNODECORE)malloc(sizeof(*pNode));
+        PAVLROGCPHYSNODECORE pNode = (PAVLROGCPHYSNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         pNode->KeyLast = i + 3;
         if (!RTAvlroGCPhysInsert(pTree, pNode))
         {
-            printf("tstAvl: FAILURE - roGCPhys - sparse insert i=%d\n", i);
+            RTTestIFailed("sparse insert i=%d\n", i);
             return 1;
         }
@@ -753 +753 @@
                 if (RTAvlroGCPhysInsert(pTree, &Node))
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - sparse negative insert i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("sparse negative insert i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -772 +772 @@
             if (!pNode)
             {
-                printf("tstAvl: FAILURE - roGCPhys - sparse get i=%d j=%d KeyBase=%d\n", i, j, (unsigned)KeyBase);
+                RTTestIFailed("sparse get i=%d j=%d KeyBase=%d\n", i, j, (unsigned)KeyBase);
                 return 1;
             }
             if (pNode->Key > KeyBase || pNode->KeyLast < KeyBase)
             {
-                printf("tstAvl: FAILURE - roGCPhys - sparse get i=%d j=%d KeyBase=%d pNode->Key=%d\n", i, j, (unsigned)KeyBase, (unsigned)pNode->Key);
+                RTTestIFailed("sparse get i=%d j=%d KeyBase=%d pNode->Key=%d\n", i, j, (unsigned)KeyBase, (unsigned)pNode->Key);
                 return 1;
             }
@@ -784 +784 @@
                 if (RTAvlroGCPhysRangeGet(pTree, k) != pNode)
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - sparse range get i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("sparse range get i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -795 +795 @@
                     &&  RTAvlroGCPhysGet(pTree, k))
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - sparse negative get i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("sparse negative get i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -803 +803 @@
                 if (RTAvlroGCPhysRangeGet(pTree, k))
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - sparse negative range get i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("sparse negative range get i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -811 +811 @@
                 if (RTAvlroGCPhysRangeGet(pTree, k))
                 {
-                    printf("tstAvl: FAILURE - roGCPhys - sparse negative range get i=%d j=%d k=%d\n", i, j, k);
+                    RTTestIFailed("sparse negative range get i=%d j=%d k=%d\n", i, j, k);
                     return 1;
                 }
@@ -820 +820 @@
             if (RTAvlroGCPhysRangeRemove(pTree, Key) != pNode)
             {
-                printf("tstAvl: FAILURE - roGCPhys - sparse remove i=%d j=%d Key=%d\n", i, j, (unsigned)Key);
+                RTTestIFailed("sparse remove i=%d j=%d Key=%d\n", i, j, (unsigned)Key);
                 return 1;
             }
             memset(pNode, 0xdd, sizeof(*pNode));
-            free(pNode);
+            RTMemFree(pNode);
         }
     }
     if (*pTree)
     {
-        printf("tstAvl: FAILURE - roGCPhys - sparse remove didn't remove it all!\n");
+        RTTestIFailed("sparse remove didn't remove it all!\n");
         return 1;
     }
@@ -856 +856 @@
         if (!RTAvlroGCPhysInsert(&s1.Tree, pNode))
         {
-            printf("tstAvl: FAILURE - roGCPhys - real insert i=%d\n", i);
+            RTTestIFailed("real insert i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysInsert(&s1.Tree, pNode))
         {
-            printf("tstAvl: FAILURE - roGCPhys - real negative insert i=%d\n", i);
+            RTTestIFailed("real negative insert i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysGet(&s1.Tree, pNode->Key) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real get (1) i=%d\n", i);
+            RTTestIFailed("real get (1) i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysGet(&s1.Tree, pNode->KeyLast) != NULL)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real negative get (2) i=%d\n", i);
+            RTTestIFailed("real negative get (2) i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysRangeGet(&s1.Tree, pNode->Key) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real range get (1) i=%d\n", i);
+            RTTestIFailed("real range get (1) i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysRangeGet(&s1.Tree, pNode->Key + 1) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real range get (2) i=%d\n", i);
+            RTTestIFailed("real range get (2) i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysRangeGet(&s1.Tree, pNode->KeyLast) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real range get (3) i=%d\n", i);
+            RTTestIFailed("real range get (3) i=%d\n", i);
             return 1;
         }
@@ -898 +898 @@
         if (RTAvlroGCPhysGet(&s3.Tree, pNode->Key) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real get (10) i=%d\n", i);
+            RTTestIFailed("real get (10) i=%d\n", i);
             return 1;
         }
         if (RTAvlroGCPhysRangeGet(&s3.Tree, pNode->Key) != pNode)
         {
-            printf("tstAvl: FAILURE - roGCPhys - real range get (10) i=%d\n", i);
+            RTTestIFailed("real range get (10) i=%d\n", i);
             return 1;
         }
@@ -912 +912 @@
             if (RTAvlroGCPhysGet(&s3.Tree, j) != NULL)
             {
-                printf("tstAvl: FAILURE - roGCPhys - real negative get (11) i=%d j=%#x\n", i, j);
+                RTTestIFailed("real negative get (11) i=%d j=%#x\n", i, j);
                 return 1;
             }
             if (RTAvlroGCPhysRangeGet(&s3.Tree, j) != pNode)
             {
-                printf("tstAvl: FAILURE - roGCPhys - real range get (11) i=%d j=%#x\n", i, j);
+                RTTestIFailed("real range get (11) i=%d j=%#x\n", i, j);
                 return 1;
             }
@@ -929 +929 @@
 int avlul(void)
 {
+    RTTestISubF("RTAvlUL");
+
     /*
      * Simple linear insert and remove.
@@ -937 +939 @@
     for (i = 0; i < 65536; i++)
     {
-        PAVLULNODECORE pNode = (PAVLULNODECORE)malloc(sizeof(*pNode));
+        PAVLULNODECORE pNode = (PAVLULNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvlULInsert(&pTree, pNode))
         {
-            printf("tstAvl: FAILURE - UL - linear insert i=%d\n", i);
+            RTTestIFailed("linear insert i=%d\n", i);
             return 1;
         }
@@ -948 +950 @@
         if (RTAvlULInsert(&pTree, &Node))
         {
-            printf("tstAvl: FAILURE - UL - linear negative insert i=%d\n", i);
+            RTTestIFailed("linear negative insert i=%d\n", i);
             return 1;
         }
@@ -958 +960 @@
         if (!pNode)
         {
-            printf("tstAvl: FAILURE - UL - linear remove i=%d\n", i);
+            RTTestIFailed("linear remove i=%d\n", i);
             return 1;
         }
@@ -964 +966 @@
         pNode->pRight    = (PAVLULNODECORE)0xbbbbbbbb;
         pNode->uchHeight = 'e';
-        free(pNode);
+        RTMemFree(pNode);
 
         /* negative */
@@ -970 +972 @@
         if (pNode)
         {
-            printf("tstAvl: FAILURE - UL - linear negative remove i=%d\n", i);
+            RTTestIFailed("linear negative remove i=%d\n", i);
             return 1;
         }
@@ -980 +982 @@
     for (i = 0; i < 65536; i += 8)
     {
-        PAVLULNODECORE pNode = (PAVLULNODECORE)malloc(sizeof(*pNode));
+        PAVLULNODECORE pNode = (PAVLULNODECORE)RTMemAlloc(sizeof(*pNode));
         pNode->Key = i;
         if (!RTAvlULInsert(&pTree, pNode))
         {
-            printf("tstAvl: FAILURE - UL - linear insert i=%d\n", i);
+            RTTestIFailed("linear insert i=%d\n", i);
             return 1;
         }
@@ -991 +993 @@
         if (RTAvlULInsert(&pTree, &Node))
         {
-            printf("tstAvl: FAILURE - UL - linear negative insert i=%d\n", i);
+            RTTestIFailed("linear negative insert i=%d\n", i);
             return 1;
         }
@@ -1008 +1010 @@
             if (!pNode)
             {
-                printf("tstAvl: FAILURE - UL - sparse remove i=%d j=%d\n", i, j);
+                RTTestIFailed("sparse remove i=%d j=%d\n", i, j);
                 return 1;
             }
@@ -1014 +1016 @@
             pNode->pRight    = (PAVLULNODECORE)0xcccccccc;
             pNode->uchHeight = 'E';
-            free(pNode);
+            RTMemFree(pNode);
         }
     }
@@ -1024 +1026 @@
 int main()
 {
-    int cErrors = 0;
+    /*
+     * Init.
+     */
+    int rc = RTR3Init();
+    if (RT_FAILURE(rc))
+        return 1;
+
+    RTTEST hTest;
+    rc = RTTestCreate("tstRTAvl", &hTest);
+    if (RT_FAILURE(rc))
+        return 1;
+    g_hTest = hTest;
+    RTTestBanner(hTest);
+
+    rc = RTRandAdvCreateParkMiller(&g_hRand);
+    if (RT_FAILURE(rc))
+    {
+        RTTestIFailed("RTRandAdvCreateParkMiller -> %Rrc", rc);
+        return RTTestSummaryAndDestroy(hTest);
+    }
+
+    /*
+     * Testing.
+     */
     unsigned i;
-
-    ProgressPrintf(~0, "tstAvl oGCPhys(32..2048)\n");
-    for (i = 32; i < 2048 && !cErrors; i++)
-        cErrors += avlogcphys(i);
-    cErrors += avlogcphys(_64K);
-    cErrors += avlogcphys(_512K);
-    cErrors += avlogcphys(_4M);
-    for (unsigned j = 0; j < /*256*/ 1 && !cErrors; j++)
-    {
-        ProgressPrintf(~0, "tstAvl oGCPhys(32..2048, *1K)\n");
-        for (i = 32; i < 4096 && !cErrors; i++)
-            cErrors += avlogcphysRand(i, i + _1K);
-        for (; i <= _4M && !cErrors; i *= 2)
-            cErrors += avlogcphysRand(i, i * 8);
-    }
-
-    cErrors += avlrogcphys();
-    cErrors += avlul();
-
-    if (!cErrors)
-        printf("tstAvl: SUCCESS\n");
-    else
-        printf("tstAvl: FAILURE - %d errors\n", cErrors);
-    return !!cErrors;
-}
+    RTTestSub(hTest, "oGCPhys(32..2048)");
+    for (i = 32; i < 2048; i++)
+        if (avlogcphys(i))
+            break;
+
+    avlogcphys(_64K);
+    avlogcphys(_512K);
+    avlogcphys(_4M);
+
+    RTTestISubF("oGCPhys(32..2048, *1K)");
+    for (i = 32; i < 4096; i++)
+        if (avlogcphysRand(i, i + _1K))
+            break;
+    for (; i <= _4M; i *= 2)
+        if (avlogcphysRand(i, i * 8))
+            break;
+
+    avlrogcphys();
+    avlul();
+
+    /*
+     * Done.
+     */
+    return RTTestSummaryAndDestroy(hTest);
+}
+