Changeset 10419 in vbox for trunk/src/VBox/Runtime/testcase

Timestamp:

Jul 9, 2008 1:46:17 PM (17 years ago)

Author:

vboxsync

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

33078

Message:

Linux implementation of the RTMp* bits we current need in ring-3.

Location:

trunk/src/VBox/Runtime/testcase

Files:

• Makefile.kmk (modified) (2 diffs)
• tstMp-1.cpp (copied) (copied from trunk/src/VBox/Runtime/testcase/tstCidr.cpp ) (4 diffs)

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

@@ -72 +72 @@
         tstLog \
         tstMove \
+        tstMp-1 \
         tstNoCrt-1 \
         tstPath \
@@ -246 +247 @@
 tstMove_SOURCES = tstMove.cpp
 
+tstMp-1_SOURCES = tstMp-1.cpp
+
 tstNoCrt-1_DEFS = RT_WITHOUT_NOCRT_WRAPPER_ALIASES
 tstNoCrt-1_SOURCES = \

trunk/src/VBox/Runtime/testcase/tstMp-1.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT Testcase - IPv4.
+ * IPRT Testcase - RTMp.
  */
 
@@ -33 +33 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include <iprt/cidr.h>
+#include <iprt/mp.h>
+#include <iprt/cpuset.h>
 #include <iprt/err.h>
 #include <iprt/stream.h>
@@ -42 +43 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-#define CHECKNETWORK(string, expected_result, expected_network, expected_netmask) \
-    do { \
-        RTIPV4ADDR network, netmask; \
-        int result = RTCidrStrToIPv4(string, &network, &netmask); \
-        if (expected_result && !result) \
-        { \
-            g_cErrors++; \
-            RTPrintf("%s, %d: %s: expected %Vrc got %Vrc\n", \
-                    __FUNCTION__, __LINE__, string, expected_result, result); \
-        } \
-        else if (   expected_result != result \
-                 || (   result == VINF_SUCCESS \
-                     && (   expected_network != network \
-                         || expected_netmask != netmask))) \
-        { \
-            g_cErrors++; \
-            RTPrintf("%s, %d: '%s': expected %Vrc got %Vrc, expected network %08x got %08x, expected netmask %08x got %08x\n", \
-                    __FUNCTION__, __LINE__, string, expected_result, result, expected_network, network, expected_netmask, netmask); \
-        } \
-    } while (0)
-
 
 /*******************************************************************************
@@ -73 +53 @@
 {
     RTR3Init();
-    CHECKNETWORK("10.0.0/24",                VINF_SUCCESS, 0x0A000000, 0xFFFFFF00);
-    CHECKNETWORK("10.0.0/8",                 VINF_SUCCESS, 0x0A000000, 0xFF000000);
-    CHECKNETWORK("10.0.0./24",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("0.1.0/24",       VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.255.0.0/24",  VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1234.0.0/24", VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.256.0.0/24",  VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/3",       VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1.2.3/8",               VINF_SUCCESS, 0x0A010203, 0xFF000000);
-    CHECKNETWORK("10.0.0/29",      VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/240",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.0.0/24.",     VERR_INVALID_PARAMETER,          0,          0);
-    CHECKNETWORK("10.1.2/16",                VINF_SUCCESS, 0x0A010200, 0xFFFF0000);
-    CHECKNETWORK("1.2.3.4",                  VINF_SUCCESS, 0x01020304, 0xFFFFFFFF);
+    RTPrintf("tstMp-1: TESTING...\n");
+
+#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS) || defined(RT_OS_LINUX)
+    /*
+     * Present and possible CPUs.
+     */
+    RTCPUID cCpus = RTMpGetCount();
+    if (cCpus > 0)
+        RTPrintf("tstMp-1: RTMpGetCount -> %d\n", (int)cCpus);
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetCount -> %d\n", (int)cCpus);
+        g_cErrors++;
+        cCpus = 1;
+    }
+
+    RTCPUSET Set;
+    PRTCPUSET pSet = RTMpGetSet(&Set);
+    if (pSet == &Set)
+    {
+        if ((RTCPUID)RTCpuSetCount(&Set) != cCpus)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetSet returned a set with a different cpu count; %d, expected %d\n",
+                     RTCpuSetCount(&Set), cCpus);
+            g_cErrors++;
+        }
+        RTPrintf("tstMp-1: Possible CPU mask:\n");
+        for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
+        {
+            if (RTCpuSetIsMemberByIndex(&Set, iCpu))
+            {
+                RTPrintf("tstMp-1: %2d - id %d\n", iCpu, RTMpCpuIdFromSetIndex(iCpu));
+                if (!RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(iCpu)))
+                {
+                    RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTCpuSet but not RTMpIsCpuPossible!\n", iCpu);
+                    g_cErrors++;
+                }
+            }
+            else if (RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(iCpu)))
+            {
+                RTPrintf("tstMp-1: FAILURE: Cpu with index %d is returned by RTMpIsCpuPossible but not RTCpuSet!\n", iCpu);
+                g_cErrors++;
+            }
+        }
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetSet -> %p, expected %p\n", pSet, &Set);
+        g_cErrors++;
+        RTCpuSetEmpty(&Set);
+        RTCpuSetAdd(&Set, RTMpCpuIdFromSetIndex(0));
+    }
+
+    /*
+     * Online CPUs.
+     */
+    RTCPUID cCpusOnline = RTMpGetOnlineCount();
+    if (cCpusOnline > 0)
+    {
+        if (cCpusOnline <= cCpus)
+            RTPrintf("tstMp-1: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
+        else
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d, expected <= %d\n", (int)cCpusOnline, (int)cCpus);
+            g_cErrors++;
+            cCpusOnline = cCpus;
+        }
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineCount -> %d\n", (int)cCpusOnline);
+        g_cErrors++;
+        cCpusOnline = 1;
+    }
+
+    RTCPUSET SetOnline;
+    pSet = RTMpGetOnlineSet(&SetOnline);
+    if (pSet == &SetOnline)
+    {
+        if (RTCpuSetCount(&SetOnline) <= 0)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned an empty set!\n");
+            g_cErrors++;
+        }
+        else if ((RTCPUID)RTCpuSetCount(&SetOnline) > cCpus)
+        {
+            RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet returned a too high value; %d, expected <= %d\n",
+                     RTCpuSetCount(&SetOnline), cCpus);
+            g_cErrors++;
+        }
+        RTPrintf("tstMp-1: Online CPU mask:\n");
+        for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
+            if (RTCpuSetIsMemberByIndex(&SetOnline, iCpu))
+            {
+                RTPrintf("tstMp-1: %2d - id %d\n", iCpu, RTMpCpuIdFromSetIndex(iCpu));
+                if (!RTCpuSetIsMemberByIndex(&Set, iCpu))
+                {
+                    RTPrintf("tstMp-1: FAILURE: online cpu with index %2d is not a member of the possible cpu set!\n", iCpu);
+                    g_cErrors++;
+                }
+            }
+
+        /* There isn't any sane way of testing RTMpIsCpuOnline really... :-/ */
+    }
+    else
+    {
+        RTPrintf("tstMp-1: FAILURE: RTMpGetOnlineSet -> %p, expected %p\n", pSet, &Set);
+        g_cErrors++;
+    }
+
+#else
+    RTPrintf("tstMp-1: SKIPPED - RTMp is not implemented on this host OS.\n");
+#endif
+
     if (!g_cErrors)
-        RTPrintf("tstIp: SUCCESS\n", g_cErrors);
+        RTPrintf("tstMp-1: SUCCESS\n", g_cErrors);
     else
-        RTPrintf("tstIp: FAILURE - %d errors\n", g_cErrors);
+        RTPrintf("tstMp-1: FAILURE - %d errors\n", g_cErrors);
     return !!g_cErrors;
 }