Changeset 36993 in vbox

Timestamp:

May 6, 2011 9:53:21 PM (14 years ago)

Author:

vboxsync

Message:

Main/linux/USB: unit tests for the code changed in r71554 and r71557

Location:

trunk/src/VBox/Main

Files:

• include/USBGetDevices.h (modified) (1 diff)
• include/USBProxyService.h (modified) (2 diffs)
• src-server/USBProxyService.cpp (modified) (1 diff)
• src-server/linux/USBGetDevices.cpp (modified) (3 diffs)
• src-server/linux/USBProxyServiceLinux.cpp (modified) (3 diffs)
• testcase/Makefile.kmk (modified) (2 diffs)
• testcase/tstUSBProxyLinux.cpp (modified) (4 diffs)

trunk/src/VBox/Main/include/USBGetDevices.h

@@ -84 +84 @@
                                          bool fIsDeviceNodes);
 
+#ifdef UNIT_TEST
+/**
+ * Specify the list of devices that will appear to be available through
+ * usbfs during unit testing (of USBProxyLinuxGetDevices)
+ * @param  pacszDeviceAddresses  NULL terminated array of usbfs device addresses
+ */
+extern void TestUSBSetAvailableUsbfsDevices(const char **pacszDeviceAddresses);
+/**
+ * Specify the list of files that access will report as accessible (at present
+ * we only do accessible or not accessible) during unit testing (of
+ * USBProxyLinuxGetDevices)
+ * @param  pacszAccessibleFiles  NULL terminated array of file paths to be
+ *                               reported accessible
+ */
+extern void TestUSBSetAccessibleFiles(const char **pacszAccessibleFiles);
+#endif
+
 /**
  * Get the list of USB devices supported by the system.  Should be freed using

trunk/src/VBox/Main/include/USBProxyService.h

@@ -211 +211 @@
     virtual int releaseDevice(HostUSBDevice *aDevice);
 
-protected:
-#ifdef TESTCASE
-    virtual
-#endif
+#  ifdef UNIT_TEST
+    /* Functions for setting our unit test mock functions.  Not quite sure if
+     * it is good form to mix test and production code like this, but it seems
+     * cleaner to me than tying the unit test to implementation details of the
+     * class. */
+    /** Select which access methods will be available to the @a init method
+     * during unit testing, and (hack!) what return code it will see from
+     * the access method-specific initialisation. */
+    void testSetupInit(const char *pcszUsbfsRoot, bool fUsbfsAccessible,
+                       const char *pcszDevicesRoot, bool fDevicesAccessible,
+                       int rcMethodInitResult)
+    {
+        mpcszTestUsbfsRoot = pcszUsbfsRoot;
+        mfTestUsbfsAccessible = fUsbfsAccessible;
+        mpcszTestDevicesRoot = pcszDevicesRoot;
+        mfTestDevicesAccessible = fDevicesAccessible;
+        mrcTestMethodInitResult = rcMethodInitResult;
+    }
+    /** Specify the environment that the @a init method will see during unit
+     * testing. */
+    void testSetEnv(const char *pcszEnvUsb, const char *pcszEnvUsbRoot)
+    {
+        mpcszTestEnvUsb = pcszEnvUsb;
+        mpcszTestEnvUsbRoot = pcszEnvUsbRoot;
+    }
+    bool testGetUsingUsbfs(void) { return mUsingUsbfsDevices; }
+    const char *testGetDevicesRoot(void) { return mDevicesRoot.c_str(); }
+#  endif
+
+protected:
     int initUsbfs(void);
-#ifdef TESTCASE
-    virtual
-#endif
     int initSysfs(void);
     void doUsbfsCleanupAsNeeded(void);
@@ -248 +271 @@
     VBoxMainHotplugWaiter *mpWaiter;
 #  endif
+#  ifdef UNIT_TEST
+    /** The path we pretend the usbfs root is located at, or NULL. */
+    const char *mpcszTestUsbfsRoot;
+    /** Should usbfs be accessible to the current user? */
+    bool mfTestUsbfsAccessible;
+    /** The path we pretend the device node tree root is located at, or NULL. */
+    const char *mpcszTestDevicesRoot;
+    /** Should the device node tree be accessible to the current user? */
+    bool mfTestDevicesAccessible;
+    /** The result of the usbfs/inotify-specific init */
+    int mrcTestMethodInitResult;
+    /** The value of the VBOX_USB environment variable. */
+    const char *mpcszTestEnvUsb;
+    /** The value of the VBOX_USB_ROOT environment variable. */
+    const char *mpcszTestEnvUsbRoot;
+#  endif
 };
 # endif /* RT_OS_LINUX */

trunk/src/VBox/Main/src-server/USBProxyService.cpp

@@ -25 +25 @@
 #include "Logging.h"
 
+#include <VBox/com/array.h>
 #include <VBox/err.h>
 #include <iprt/asm.h>

trunk/src/VBox/Main/src-server/linux/USBGetDevices.cpp

@@ -1390 +1390 @@
 }
 
+#ifdef UNIT_TEST
+/* Set up mock functions for USBProxyLinuxCheckDeviceRoot - here dlsym and close
+ * for the inotify presence check. */
+static int testInotifyInitGood(void) { return 0; }
+static int testInotifyInitBad(void) { return -1; }
+static bool s_fHaveInotifyLibC = true;
+static bool s_fHaveInotifyKernel = true;
+
+static void *testDLSym(void *handle, const char *symbol)
+{
+    Assert(handle == RTLD_DEFAULT);
+    Assert(!RTStrCmp(symbol, "inotify_init"));
+    if (!s_fHaveInotifyLibC)
+        return NULL;
+    if (s_fHaveInotifyKernel)
+        return (void *)testInotifyInitGood;
+    return (void *)testInotifyInitBad;
+}
+
+void TestUSBSetInotifyAvailable(bool fHaveInotifyLibC, bool fHaveInotifyKernel)
+{
+    s_fHaveInotifyLibC = fHaveInotifyLibC;
+    s_fHaveInotifyKernel = fHaveInotifyKernel;
+}
+# define dlsym testDLSym
+# define close(a) do {} while(0)
+#endif
+
 /** Is inotify available and working on this system?  This is a requirement
  * for using USB with sysfs */
@@ -1406 +1434 @@
 }
 
+#ifdef UNIT_TEST
+# undef dlsym
+# undef close
+#endif
+
+#ifdef UNIT_TEST
+/** Unit test list of usbfs addresses of connected devices. */
+static const char **s_pacszUsbfsDeviceAddresses = NULL;
+
+static PUSBDEVICE testGetUsbfsDevices(const char *pcszUsbfsRoot, bool testfs)
+{
+    const char **pcsz;
+    PUSBDEVICE pList = NULL, pTail = NULL;
+    for (pcsz = s_pacszUsbfsDeviceAddresses; pcsz && *pcsz; ++pcsz)
+    {
+        PUSBDEVICE pNext = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
+        if (pNext)
+            pNext->pszAddress = RTStrDup(*pcsz);
+        if (!pNext || !pNext->pszAddress)
+        {
+            deviceListFree(&pList);
+            return NULL;
+        }
+        if (pTail)
+            pTail->pNext = pNext;
+        else
+            pList = pNext;
+        pTail = pNext;
+    }
+    return pList;
+}
+# define getDevicesFromUsbfs testGetUsbfsDevices
+
+void TestUSBSetAvailableUsbfsDevices(const char **pacszDeviceAddresses)
+{
+    s_pacszUsbfsDeviceAddresses = pacszDeviceAddresses;
+}
+
+/** Unit test list of files reported as accessible by access(3).  We only do
+ * accessible or not accessible. */
+static const char **s_pacszAccessibleFiles = NULL;
+
+static int testAccess(const char *pcszPath, int mode)
+{
+    const char **pcsz;
+    for (pcsz = s_pacszAccessibleFiles; pcsz && *pcsz; ++pcsz)
+        if (!RTStrCmp(pcszPath, *pcsz))
+            return 0;
+    return -1;
+}
+# define access testAccess
+
+void TestUSBSetAccessibleFiles(const char **pacszAccessibleFiles)
+{
+    s_pacszAccessibleFiles = pacszAccessibleFiles;
+}
+#endif
+
 bool USBProxyLinuxCheckDeviceRoot(const char *pcszRoot, bool fIsDeviceNodes)
 {
@@ -1431 +1517 @@
 }
 
+#ifdef UNIT_TEST
+# undef getDevicesFromUsbfs
+# undef access
+#endif
 
 PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszDevicesRoot,

trunk/src/VBox/Main/src-server/linux/USBProxyServiceLinux.cpp

@@ -63 +63 @@
       mWakeupPipeW(NIL_RTFILE), mUsingUsbfsDevices(true /* see init */),
       mUdevPolls(0), mpWaiter(NULL)
+#ifdef UNIT_TEST
+      , mpcszTestUsbfsRoot(NULL), mfTestUsbfsAccessible(false),
+      mpcszTestDevicesRoot(NULL), mfTestDevicesAccessible(false),
+      mrcTestMethodInitResult(VINF_SUCCESS), mpcszTestEnvUsb(NULL),
+      mpcszTestEnvUsbRoot(NULL)
+#endif
 {
     LogFlowThisFunc(("aHost=%p\n", aHost));
 }
 
+#ifdef UNIT_TEST
+/* For testing we redefine anything that accesses the outside world to
+ * return test values. */
+# define RTEnvGet(a) \
+    (  !RTStrCmp(a, "VBOX_USB") ? mpcszTestEnvUsb \
+     : !RTStrCmp(a, "VBOX_USB_ROOT") ? mpcszTestEnvUsbRoot \
+     : NULL)
+# define USBProxyLinuxCheckDeviceRoot(pcszPath, fUseNodes) \
+    (   ((fUseNodes) && mfTestDevicesAccessible \
+                     && !RTStrCmp(pcszPath, mpcszTestDevicesRoot)) \
+     || (!(fUseNodes) && mfTestUsbfsAccessible \
+                      && !RTStrCmp(pcszPath, mpcszTestUsbfsRoot)))
+# define RTDirExists(pcszDir) \
+    (   (pcszDir) \
+     && (   !RTStrCmp(pcszDir, mpcszTestDevicesRoot) \
+         || !RTStrCmp(pcszDir, mpcszTestUsbfsRoot)))
+# define RTFileExists(pcszFile) \
+    (   (pcszFile) \
+     && mpcszTestUsbfsRoot \
+     && !RTStrNCmp(pcszFile, mpcszTestUsbfsRoot, strlen(mpcszTestUsbfsRoot)) \
+     && !RTStrCmp(pcszFile + strlen(mpcszTestUsbfsRoot), "/devices"))
+#endif
 
 /**
@@ -131 +159 @@
         mUsingUsbfsDevices = !fUseSysfs;
         mDevicesRoot = pcszUsbRoot;
+#ifndef UNIT_TEST /* Hack for now */
         int rc = mUsingUsbfsDevices ? initUsbfs() : initSysfs();
+#else
+        int rc = mrcTestMethodInitResult;
+#endif
         /* For the day when we have VBoxSVC release logging... */
         LogRel((RT_SUCCESS(rc) ? "Successfully initialised host USB using %s\n"
@@ -145 +177 @@
 }
 
+#ifdef UNIT_TEST
+# undef RTEnvGet
+# undef USBProxyLinuxCheckDeviceRoot
+# undef RTDirExists
+# undef RTFileExists
+#endif
 
 /**

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

@@ -172 +172 @@
 tstUSBProxyLinux_SOURCES   = \
         tstUSBProxyLinux.cpp \
-        ../src-server/linux/USBProxyServiceLinux.cpp
+        ../src-server/linux/USBProxyServiceLinux.cpp \
+        ../src-server/linux/USBGetDevices.cpp
 tstUSBProxyLinux_INCS      = \
         . \
@@ -180 +181 @@
         $(VBOX_PATH_SDK)/bindings/xpcom/include/xpcom
 tstUSBProxyLinux_DEFS      = \
-        TESTCASE \
+        UNIT_TEST \
+        VBOX_WITH_USB \
         VBOX_USB_WITH_SYSFS \
-        VBOX_WITH_SYSFS_BY_DEFAULT \
         VBOX_WITH_XPCOM
 tstUSBProxyLinux_DEPS     = \
         $(VBOX_PATH_SDK)/bindings/xpcom/include/VirtualBox_XPCOM.h
+tstUSBProxyLinux_LIBS     += \
+        $(PATH_OUT)/lib/USBLib.a
 
 

trunk/src/VBox/Main/testcase/tstUSBProxyLinux.cpp

@@ -23 +23 @@
 #include "USBGetDevices.h"
 
+#include <VBox/err.h>
 #include <iprt/assert.h>
-#include <iprt/err.h>
 #include <iprt/env.h>
+#include <iprt/string.h>
 #include <iprt/test.h>
 
@@ -62 +63 @@
 }
 
-static const char *s_pcszDeviceRoot = "";
-static bool s_fIsDeviceNodes = false;
-
-bool USBProxyLinuxCheckDeviceRoot(const char *pcszRoot,
-                                  bool fIsDeviceNodes)
-{
-    return (   (!strcmp(s_pcszDeviceRoot, pcszRoot))
-            && (s_fIsDeviceNodes == fIsDeviceNodes));
-}
-
-static struct
-{
+int USBProxyService::getLastError(void)
+{
+    return mLastError;
+}
+
+void SysFreeString(BSTR bstr)
+{
+    Assert(0);
+}
+
+static struct 
+{
+    const char *pcszEnvUsb;
+    const char *pcszEnvUsbRoot;
     const char *pcszDevicesRoot;
-    bool fUseSysfs;
-} s_getDevices;
-
-PUSBDEVICE USBProxyLinuxGetDevices(const char *pcszDevicesRoot,
-                                   bool fUseSysfs)
-{
-    s_getDevices.pcszDevicesRoot = pcszDevicesRoot;
-    s_getDevices.fUseSysfs = fUseSysfs;
-    return NULL;
-}
-
-void SysFreeString(BSTR bstr)
-{
-    Assert(0);
-}
-
-/*** END STUBS ***/
-
-class tstUSBProxyLinux : public USBProxyServiceLinux
-{
-protected:
-    virtual int initUsbfs(void) { return VINF_SUCCESS; }
-    virtual int initSysfs(void) { return VINF_SUCCESS; }
-public:
-    tstUSBProxyLinux(void) : USBProxyServiceLinux(NULL) {}
-    PUSBDEVICE getDevices(void)
-    {
-        return USBProxyServiceLinux::getDevices();
-    }
+    bool fDevicesAccessible;
+    const char *pcszUsbfsRoot;
+    bool fUsbfsAccessible;
+    int rcMethodInit;
+    int rcExpected;
+    const char *pcszDevicesRootExpected;
+    bool fUsingUsbfsExpected;
+} s_testEnvironment[] =
+{
+    { "sysfs", "/dev/bus/usb", NULL, false, NULL, false, VINF_SUCCESS, VINF_SUCCESS, "/dev/bus/usb", false },
+    { "sysfs", "/dev/bus/usb", NULL, false, NULL, false, VERR_NO_MEMORY, VERR_NO_MEMORY, "/dev/bus/usb", false },
+    { "sysfs", "/dev/bus/usb", "/dev/usbvbox", false, "/proc/usb/bus", false, VINF_SUCCESS, VINF_SUCCESS, "/dev/bus/usb", false },
+    { "sysfs", "/dev/bus/usb", "/dev/usbvbox", false, "/proc/usb/bus", false, VERR_NO_MEMORY, VERR_NO_MEMORY, "/dev/bus/usb", false },
+    { "sysfs", NULL, "/dev/usbvbox", true, NULL, false, VINF_SUCCESS, VINF_SUCCESS, "/dev/vboxusb", false },
+    { "usbfs", "/dev/bus/usb", NULL, false, NULL, false, VINF_SUCCESS, VINF_SUCCESS, "/dev/bus/usb", true },
+    { "usbfs", "/dev/bus/usb", NULL, false, NULL, false, VERR_NO_MEMORY, VERR_NO_MEMORY, "/dev/bus/usb", true },
+    { "usbfs", "/dev/bus/usb", "/dev/usbvbox", false, "/proc/usb/bus", false, VINF_SUCCESS, VINF_SUCCESS, "/dev/bus/usb", true },
+    { "usbfs", "/dev/bus/usb", "/dev/usbvbox", false, "/proc/usb/bus", false, VERR_NO_MEMORY, VERR_NO_MEMORY, "/dev/bus/usb", true },
+    { "usbfs", NULL, NULL, false, "/proc/bus/usb", true, VINF_SUCCESS, VINF_SUCCESS, "/proc/bus/usb", true },
+    { NULL, NULL, "/dev/vboxusb", false, "/proc/bus/usb", false, VERR_NO_MEMORY, VERR_VUSB_USB_DEVICE_PERMISSION, "", true },
+    { NULL, NULL, "/dev/vboxusb", true, "/proc/bus/usb", false, VERR_NO_MEMORY, VERR_NO_MEMORY, "/dev/vboxusb", false },
+    { NULL, NULL, NULL, false, "/proc/bus/usb", false, VERR_NO_MEMORY, VERR_VUSB_USBFS_PERMISSION, "", true },
+    { NULL, NULL, NULL, false, "/proc/bus/usb", true, VERR_NO_MEMORY, VERR_NO_MEMORY, "/proc/bus/usb", true }
 };
 
-static struct 
-{
-    const char *pcszVBOX_USB;
-    const char *pcszVBOX_USB_ROOT;
-    const char *pcszReturnedRoot;
-    bool fReturnedUseSysfs;
-    bool fRequestedUseSysfs;
-    const char *pcszFinalRoot;
-    bool fFinalUseSysfs;
-} s_testEnvironment[] =
-{
-    { "sysfs", "/dev/bus/usb", "/proc/bus/usb", false, true, "/dev/bus/usb", true },
-    { "sysfs", "/dev/bus/usb", "/dev/vboxusb", true, true, "/dev/bus/usb", true },
-    { "sysfs", NULL, "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { "sysfs", NULL, "/dev/vboxusb", true, true, "/dev/vboxusb", true },
-    { "usbfs", "/dev/bus/usb", "/proc/bus/usb", false, false, "/dev/bus/usb", false },
-    { "usbfs", "/dev/bus/usb", "/dev/vboxusb", true, false, "/dev/bus/usb", false },
-    { "usbfs", NULL, "/proc/bus/usb", false, false, "/proc/bus/usb", false },
-    { "usbfs", NULL, "/dev/vboxusb", true, false, "/dev/vboxusb", true },
-    { "nofs", "/dev/bus/usb", "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { "nofs", "/dev/bus/usb", "/dev/vboxusb", true, true, "/dev/vboxusb", true },
-    { "nofs", NULL, "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { "nofs", NULL, "/dev/vboxusb", true, true, "/dev/vboxusb", true },
-    { "", "/dev/bus/usb", "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { "", "/dev/bus/usb", "/dev/vboxusb", true, true, "/dev/vboxusb", true },
-    { "", NULL, "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { "", NULL, "/dev/vboxusb", true, true, "/dev/vboxusb", true },
-    { NULL, "/dev/bus/usb", "/proc/bus/usb", false, true, "/proc/bus/usb", false },
-    { NULL, "/dev/bus/usb", "/dev/vboxusb", true, true, "/dev/vboxusb", true }
-};
-
-/** @note Fiddling with the real environment for this is not nice, in my
- * opinion at least. */
-static void testEnvironment(RTTEST hTest)
-{
-    RTTestSub(hTest, "Testing environment variable handling");
+static void testInit(RTTEST hTest)
+{
+    RTTestSub(hTest, "Testing USBProxyServiceLinux initialisation");
     for (unsigned i = 0; i < RT_ELEMENTS(s_testEnvironment); ++i)
     {
-        tstUSBProxyLinux test;
-        if (s_testEnvironment[i].pcszVBOX_USB)
-            RTEnvSet("VBOX_USB", s_testEnvironment[i].pcszVBOX_USB);
-        else
-            RTEnvUnset("VBOX_USB");
-        if (s_testEnvironment[i].pcszVBOX_USB_ROOT)
-            RTEnvSet("VBOX_USB_ROOT",
-                     s_testEnvironment[i].pcszVBOX_USB_ROOT);
-        else
-            RTEnvUnset("VBOX_USB_ROOT");
-        s_pcszDeviceRoot = s_testEnvironment[i].pcszReturnedRoot;
-        s_fIsDeviceNodes = s_testEnvironment[i].fReturnedUseSysfs;
-        RTTESTI_CHECK(test.init() == S_OK);
-        test.getDevices();
-        RTTESTI_CHECK_MSG(!strcmp(s_getDevices.pcszDevicesRoot,
-                          s_testEnvironment[i].pcszFinalRoot),
-                          ("i=%u: %s, %s\n", i, s_getDevices.pcszDevicesRoot,
-                          s_testEnvironment[i].pcszFinalRoot));
-        RTTESTI_CHECK_MSG(   s_getDevices.fUseSysfs
-                          == s_testEnvironment[i].fFinalUseSysfs,
-                          ("i=%u, %d, %d\n", i, s_getDevices.fUseSysfs,
-                          s_testEnvironment[i].fFinalUseSysfs));
+        USBProxyServiceLinux test(NULL);
+        test.testSetEnv(s_testEnvironment[i].pcszEnvUsb,
+                        s_testEnvironment[i].pcszEnvUsbRoot);
+        test.testSetupInit(s_testEnvironment[i].pcszUsbfsRoot,
+                           s_testEnvironment[i].fUsbfsAccessible,
+                           s_testEnvironment[i].pcszDevicesRoot,
+                           s_testEnvironment[i].fDevicesAccessible,
+                           s_testEnvironment[i].rcMethodInit);
+        HRESULT hrc = test.init();
+        RTTESTI_CHECK_MSG(hrc == S_OK,
+                           ("init() returned 0x%x on line %i!\n", hrc, i));
+        int rc = test.getLastError();
+        RTTESTI_CHECK_MSG(rc == s_testEnvironment[i].rcExpected,
+                          ("getLastError() returned %Rrc on line %i instead of %Rrc!\n",
+                           rc, i, s_testEnvironment[i].rcExpected));
+        const char *pcszDevicesRoot = test.testGetDevicesRoot();
+        RTTESTI_CHECK_MSG(!RTStrCmp(pcszDevicesRoot,
+                               s_testEnvironment[i].pcszDevicesRootExpected),
+                          ("testGetDevicesRoot() returned %s on line %i instead of %s!\n",
+                           pcszDevicesRoot, i,
+                           s_testEnvironment[i].pcszDevicesRootExpected));
+        bool fUsingUsbfs = test.testGetUsingUsbfs();
+        RTTESTI_CHECK_MSG(   fUsingUsbfs
+                          == s_testEnvironment[i].fUsingUsbfsExpected,
+                          ("testGetUsingUsbfs() returned %RTbool on line %i instead of %RTbool!\n",
+                           fUsingUsbfs, i,
+                           s_testEnvironment[i].fUsingUsbfsExpected));
+    }
+}
+
+static struct 
+{
+    const char *pacszDeviceAddresses[16];
+    const char *pacszAccessibleFiles[16];
+    const char *pcszRoot;
+    bool fIsDeviceNodes;
+    bool fAvailableExpected;
+} s_testCheckDeviceRoot[] =
+{
+    { { NULL }, { "/dev/vboxusb" }, "/dev/vboxusb", true, true },
+    { { NULL }, { NULL }, "/dev/vboxusb", true, false },
+    { { NULL }, { NULL }, "/proc/bus/usb", false, true },
+    { { "/proc/bus/usb/001/001" }, { NULL }, "/proc/bus/usb", false, false },
+    { { "/proc/bus/usb/001/001", "/proc/bus/usb/002/002" },
+      { "/proc/bus/usb/001/001" }, "/proc/bus/usb", false, false },
+    { { "/proc/bus/usb/001/001", "/proc/bus/usb/002/002" },
+      { "/proc/bus/usb/001/001", "/proc/bus/usb/002/002" },
+      "/proc/bus/usb", false, true }
+};
+
+static void testCheckDeviceRoot(RTTEST hTest)
+{
+    RTTestSub(hTest, "Testing the USBProxyLinuxCheckDeviceRoot API");
+    for (unsigned i = 0; i < RT_ELEMENTS(s_testCheckDeviceRoot); ++i)
+    {
+        TestUSBSetAvailableUsbfsDevices(s_testCheckDeviceRoot[i]
+                                                .pacszDeviceAddresses);
+        TestUSBSetAccessibleFiles(s_testCheckDeviceRoot[i]
+                                                .pacszAccessibleFiles);
+        bool fAvailable = USBProxyLinuxCheckDeviceRoot
+                                  (s_testCheckDeviceRoot[i].pcszRoot,
+                                   s_testCheckDeviceRoot[i].fIsDeviceNodes);
+        RTTESTI_CHECK_MSG(   fAvailable
+                          == s_testCheckDeviceRoot[i].fAvailableExpected,
+                           ("USBProxyLinuxCheckDeviceRoot() returned %RTbool on line %i instead of %RTbool!\n",
+                            fAvailable, i,
+                            s_testCheckDeviceRoot[i].fAvailableExpected));
     }
 }
@@ -183 +192 @@
      * Run the tests.
      */
-    testEnvironment(hTest);
+    testInit(hTest);
+    testCheckDeviceRoot(hTest);
 
     /*
@@ -190 +200 @@
     return RTTestSummaryAndDestroy(hTest);
 }
-