Index: /trunk/include/iprt/mangling.h
===================================================================
--- /trunk/include/iprt/mangling.h	(revision 45393)
+++ /trunk/include/iprt/mangling.h	(revision 45394)
@@ -953,4 +953,7 @@
 # define RTPathSetTimesEx                               RT_MANGLER(RTPathSetTimesEx)
 # define RTPathSharedLibs                               RT_MANGLER(RTPathSharedLibs)
+# define RTPathSplit                                    RT_MANGLER(RTPathSplit)
+# define RTPathSplitATag                                RT_MANGLER(RTPathSplitATag)
+# define RTPathSplitFree                                RT_MANGLER(RTPathSplitFree)
 # define RTPathStartsWith                               RT_MANGLER(RTPathStartsWith)
 # define RTPathStartsWithRoot                           RT_MANGLER(RTPathStartsWithRoot)
Index: /trunk/include/iprt/path.h
===================================================================
--- /trunk/include/iprt/path.h	(revision 45393)
+++ /trunk/include/iprt/path.h	(revision 45394)
@@ -48,4 +48,15 @@
 #if !defined(___iprt_param_h) || defined(DOXYGEN_RUNNING)
 # define RTPATH_MAX         (4096 + 4)    /* (PATH_MAX + 1) on linux w/ some alignment */
+#endif
+
+/** @def RTPATH_TAG
+ * The default allocation tag used by the RTPath allocation APIs.
+ *
+ * When not defined before the inclusion of iprt/string.h, this will default to
+ * the pointer to the current file name.  The string API will make of use of
+ * this as pointer to a volatile but read-only string.
+ */
+#ifndef RTPATH_TAG
+# define RTPATH_TAG     (__FILE__)
 #endif
 
@@ -452,5 +463,6 @@
  * @note This is not set for lone root specifications (RTPATH_PROP_UNC,
  *       RTPATH_PROP_ROOT_SLASH, or RTPATH_PROP_VOLUME).
- * @note The slash is not counted into the last component.  */
+ * @note The slash is not counted into the last component. However, it is
+ *       counted into cchPath. */
 #define RTPATH_PROP_DIR_SLASH       UINT16_C(0x0002)
 
@@ -519,10 +531,10 @@
  * (All other components in a split or parsed path requies slashes added.) */
 #define RTPATH_PROP_FIRST_NEEDS_NO_SLASH(a_fProps) \
-    ( (a_fProps) & (RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_VOLUME | RTPATH_PROP_UNC) )
+    RT_BOOL( (a_fProps) & (RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_VOLUME | RTPATH_PROP_UNC) )
 
 /** Macro to determin whether there is a root specification of any kind
  * (unix, volumes, unc). */
 #define RTPATH_PROP_HAS_ROOT_SPEC(a_fProps) \
-    ( (a_fProps) & (RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_VOLUME | RTPATH_PROP_UNC) )
+    RT_BOOL( (a_fProps) & (RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_VOLUME | RTPATH_PROP_UNC) )
 
 /** @} */
@@ -615,5 +627,5 @@
      * component lengths and necessary separators.
      * Do NOT use this to index in the source path in case it contains
-     * unnecessary slashes that RTPathParsed has ignored here. */
+     * unnecessary slashes that RTPathSplit has ignored here. */
     uint16_t    cchPath;
     /** Reserved (internal use).  */
@@ -656,8 +668,10 @@
  *                              (variable sized array at the end).  Must be at
  *                              least the size of RTPATHSPLIT.
+ * @param   fFlags              Combination of RTPATH_STR_F_XXX flags.
+ *                              Most users will pass 0.
  *
  * @sa      RTPathSplitA, RTPathParse.
  */
-RTDECL(int) RTPathSplit(const char *pszPath, PRTPATHSPLIT pSplit, size_t cbSplit);
+RTDECL(int) RTPathSplit(const char *pszPath, PRTPATHSPLIT pSplit, size_t cbSplit, uint32_t fFlags);
 
 /**
@@ -673,7 +687,28 @@
  *                              success.  This must be freed by calling
  *                              RTPathSplitFree().
+ * @param   fFlags              Combination of RTPATH_STR_F_XXX flags.
+ *                              Most users will pass 0.
  * @sa      RTPathSplitFree, RTPathSplit, RTPathParse.
  */
-RTDECL(int) RTPathSplitA(const char *pszPath, PRTPATHSPLIT *ppSplit);
+#define  RTPathSplitA(pszPath, ppSplit, fFlags)     RTPathSplitATag(pszPath, ppSplit, fFlags, RTPATH_TAG)
+
+/**
+ * Splits the path into individual component strings, allocating the buffer on
+ * the default thread heap.
+ *
+ * @returns IPRT status code.
+ * @retval  VERR_INVALID_POINTER if pParsed or pszPath is an invalid pointer.
+ * @retval  VERR_PATH_ZERO_LENGTH if the path is empty.
+ *
+ * @param   pszPath             The path to parse.
+ * @param   ppSplit             Where to return the pointer to the output on
+ *                              success.  This must be freed by calling
+ *                              RTPathSplitFree().
+ * @param   fFlags              Combination of RTPATH_STR_F_XXX flags.
+ *                              Most users will pass 0.
+ * @param   pszTag              Allocation tag used for statistics and such.
+ * @sa      RTPathSplitFree, RTPathSplit, RTPathParse.
+ */
+RTDECL(int) RTPathSplitATag(const char *pszPath, PRTPATHSPLIT *ppSplit, uint32_t fFlags, const char *pszTag);
 
 /**
Index: /trunk/src/VBox/Runtime/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Runtime/Makefile.kmk	(revision 45393)
+++ /trunk/src/VBox/Runtime/Makefile.kmk	(revision 45394)
@@ -366,4 +366,6 @@
 	common/path/RTPathRealDup.cpp \
 	common/path/RTPathRmCmd.cpp \
+	common/path/RTPathSplit.cpp \
+	common/path/RTPathSplitA.cpp \
 	common/path/RTPathStartsWithRoot.cpp \
 	common/path/RTPathStripExt.cpp \
@@ -1710,5 +1712,4 @@
 	common/path/RTPathHasExt.cpp \
 	common/path/RTPathHasPath.cpp \
-	common/path/RTPathParse.cpp \
 	common/path/RTPathParseSimple.cpp \
 	common/path/RTPathRealDup.cpp \
Index: /trunk/src/VBox/Runtime/common/path/RTPathParse.cpp.h
===================================================================
--- /trunk/src/VBox/Runtime/common/path/RTPathParse.cpp.h	(revision 45393)
+++ /trunk/src/VBox/Runtime/common/path/RTPathParse.cpp.h	(revision 45394)
@@ -193,5 +193,8 @@
                 {
                     if (!(fFlags & RTPATH_STR_F_NO_END))
-                        fProps |= RTPATH_PROP_DIR_SLASH; /* (not counted) */
+                    {
+                        fProps |= RTPATH_PROP_DIR_SLASH; /* (not counted in component, but in cchPath) */
+                        cchPath++;
+                    }
                     else
                         fProps |= RTPATH_PROP_EXTRA_SLASHES;
Index: /trunk/src/VBox/Runtime/common/path/RTPathSplit.cpp
===================================================================
--- /trunk/src/VBox/Runtime/common/path/RTPathSplit.cpp	(revision 45394)
+++ /trunk/src/VBox/Runtime/common/path/RTPathSplit.cpp	(revision 45394)
@@ -0,0 +1,134 @@
+/* $Id$ */
+/** @file
+ * IPRT - RTPathSplit
+ */
+
+/*
+ * Copyright (C) 2013 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/path.h>
+
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/string.h>
+
+
+
+RTDECL(int) RTPathSplit(const char *pszPath, PRTPATHSPLIT pSplit, size_t cbSplit, uint32_t fFlags)
+{
+    /*
+     * Input validation.
+     */
+    AssertReturn(cbSplit >= RT_UOFFSETOF(RTPATHSPLIT, apszComps), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pSplit, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
+    AssertReturn(*pszPath, VERR_PATH_ZERO_LENGTH);
+    AssertReturn(RTPATH_STR_F_IS_VALID(fFlags, 0), VERR_INVALID_FLAGS);
+
+    /*
+     * Use RTPathParse to do the parsing.
+     * - This makes the ASSUMPTION that the output of this function is greater
+     *   or equal to that of RTPathParsed.
+     * - We're aliasing the buffer here, so use volatile to avoid issues due to
+     *   compiler optimizations.
+     */
+    RTPATHPARSED volatile  *pParsedVolatile = (RTPATHPARSED volatile *)pSplit;
+    RTPATHSPLIT  volatile  *pSplitVolatile  = (RTPATHSPLIT  volatile *)pSplit;
+
+    AssertCompile(sizeof(*pParsedVolatile) <= sizeof(*pSplitVolatile));
+    AssertCompile(sizeof(pParsedVolatile->aComps[0]) <= sizeof(pSplitVolatile->apszComps[0]));
+
+    int rc = RTPathParse(pszPath, (PRTPATHPARSED)pParsedVolatile, cbSplit, fFlags);
+    if (RT_FAILURE(rc) && rc != VERR_BUFFER_OVERFLOW)
+        return rc;
+
+    /*
+     * Calculate the required buffer space.
+     */
+    uint16_t const  cComps    = pParsedVolatile->cComps;
+    uint16_t const  fProps    = pParsedVolatile->fProps;
+    uint16_t const  cchPath   = pParsedVolatile->cchPath;
+    uint16_t const  offSuffix = pParsedVolatile->offSuffix;
+    uint32_t        cbNeeded  = RT_OFFSETOF(RTPATHSPLIT, apszComps[cComps])
+                              + cchPath
+                              + RTPATH_PROP_FIRST_NEEDS_NO_SLASH(fProps) /* zero terminator for root spec. */
+                              - RT_BOOL(fProps & RTPATH_PROP_DIR_SLASH) /* counted by cchPath, not included in the comp str. */
+                              + 1; /* zero terminator. */
+    if (cbNeeded > cbSplit)
+    {
+        pSplitVolatile->cbNeeded = cbNeeded;
+        return VERR_BUFFER_OVERFLOW;
+    }
+    Assert(RT_SUCCESS(rc));
+
+    /*
+     * Convert the array and copy the strings, both backwards.
+     */
+    char    *psz     = (char *)pSplit + cbNeeded;
+    uint32_t idxComp = cComps - 1;
+
+    /* the final component first (because of suffix handling). */
+    uint16_t offComp = pParsedVolatile->aComps[idxComp].off;
+    uint16_t cchComp = pParsedVolatile->aComps[idxComp].cch;
+
+    *--psz = '\0';
+    psz -= cchComp;
+    memcpy(psz, &pszPath[offComp], cchComp);
+    pSplitVolatile->apszComps[idxComp] = psz;
+
+    char *pszSuffix;
+    if (offSuffix >= offComp + cchComp)
+        pszSuffix = &psz[cchComp];
+    else
+        pszSuffix = &psz[offSuffix - offComp];
+
+    /* the remainder */
+    while (idxComp-- > 0)
+    {
+        offComp = pParsedVolatile->aComps[idxComp].off;
+        cchComp = pParsedVolatile->aComps[idxComp].cch;
+        *--psz = '\0';
+        psz -= cchComp;
+        memcpy(psz, &pszPath[offComp], cchComp);
+        pSplitVolatile->apszComps[idxComp] = psz;
+    }
+
+    /*
+     * Store / reshuffle the non-array bits. This MUST be done after finishing
+     * the array processing because there may be members in RTPATHSPLIT
+     * overlapping the array of RTPATHPARSED.
+     */
+    AssertCompileMembersSameSizeAndOffset(RTPATHPARSED, cComps,  RTPATHSPLIT, cComps);  Assert(pSplitVolatile->cComps == cComps);
+    AssertCompileMembersSameSizeAndOffset(RTPATHPARSED, fProps,  RTPATHSPLIT, fProps);  Assert(pSplitVolatile->fProps == fProps);
+    AssertCompileMembersSameSizeAndOffset(RTPATHPARSED, cchPath, RTPATHSPLIT, cchPath); Assert(pSplitVolatile->cchPath == cchPath);
+    pSplitVolatile->u16Reserved = 0;
+    pSplitVolatile->cbNeeded    = cbNeeded;
+    pSplitVolatile->pszSuffix   = pszSuffix;
+
+    return rc;
+}
+
+
Index: /trunk/src/VBox/Runtime/common/path/RTPathSplitA.cpp
===================================================================
--- /trunk/src/VBox/Runtime/common/path/RTPathSplitA.cpp	(revision 45394)
+++ /trunk/src/VBox/Runtime/common/path/RTPathSplitA.cpp	(revision 45394)
@@ -0,0 +1,91 @@
+/* $Id$ */
+/** @file
+ * IPRT - RTPathSplitA and RTPathSplitFree.
+ */
+
+/*
+ * Copyright (C) 2013 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#include "internal/iprt.h"
+#include <iprt/path.h>
+
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/mem.h>
+#include <iprt/string.h>
+
+
+
+RTDECL(int) RTPathSplitATag(const char *pszPath, PRTPATHSPLIT *ppSplit, uint32_t fFlags, const char *pszTag)
+{
+    AssertPtrReturn(ppSplit, VERR_INVALID_POINTER);
+    *ppSplit = NULL;
+
+    /*
+     * Try estimate a reasonable buffer size based on the path length.
+     * Note! No point in trying very hard to get it right.
+     */
+    size_t cbSplit = strlen(pszPath);
+    cbSplit += RT_OFFSETOF(RTPATHSPLIT, apszComps[cbSplit / 8]) + cbSplit / 8 + 8;
+    cbSplit = RT_ALIGN(cbSplit, 64);
+    PRTPATHSPLIT pSplit = (PRTPATHSPLIT)RTMemAllocTag(cbSplit, pszTag);
+    if (pSplit == NULL)
+        return VERR_NO_MEMORY;
+
+    /*
+     * First try. If it fails due to buffer, reallocate the buffer and try again.
+     */
+    int rc = RTPathSplit(pszPath, pSplit, cbSplit, fFlags);
+    if (rc == VERR_BUFFER_OVERFLOW)
+    {
+        cbSplit = RT_ALIGN(pSplit->cbNeeded, 64);
+        RTMemFree(pSplit);
+
+        pSplit = (PRTPATHSPLIT)RTMemAllocTag(cbSplit, pszTag);
+        if (pSplit == NULL)
+            return VERR_NO_MEMORY;
+        rc = RTPathSplit(pszPath, pSplit, cbSplit, fFlags);
+    }
+
+    /*
+     * Done (one way or the other).
+     */
+    if (RT_SUCCESS(rc))
+        *ppSplit = pSplit;
+    else
+        RTMemFree(pSplit);
+    return rc;
+}
+
+
+RTDECL(void) RTPathSplitFree(PRTPATHSPLIT pSplit)
+{
+    if (pSplit)
+    {
+        Assert(pSplit->u16Reserved = UINT16_C(0xbeef));
+        RTMemFree(pSplit);
+    }
+}
+
Index: /trunk/src/VBox/Runtime/testcase/tstRTPath.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstRTPath.cpp	(revision 45393)
+++ /trunk/src/VBox/Runtime/testcase/tstRTPath.cpp	(revision 45394)
@@ -39,8 +39,6 @@
 
 
-static void testParser(RTTEST hTest)
+static void testParserAndSplitter(RTTEST hTest)
 {
-    RTTestSub(hTest, "RTPathParse");
-
     static struct
     {
@@ -53,4 +51,5 @@
     } const s_aTests[] =
     {
+        { 2,  5,  5,  "/bin/",            RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_DIR_SLASH,                                                RTPATH_STR_F_STYLE_UNIX },
         { 2, 13,  9,  "C:/Config.sys",    RTPATH_PROP_VOLUME | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_SUFFIX,       RTPATH_STR_F_STYLE_DOS },
         { 2, 13, 10,  "C://Config.sys",   RTPATH_PROP_VOLUME | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_SUFFIX | RTPATH_PROP_EXTRA_SLASHES, RTPATH_STR_F_STYLE_DOS },
@@ -65,5 +64,5 @@
         { 1,  1,  1,  "/",                RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE,                                                                        RTPATH_STR_F_STYLE_UNIX },
         { 2,  4,  4,  "/bin",             RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME,                                                 RTPATH_STR_F_STYLE_UNIX },
-        { 2,  4,  5,  "/bin/",            RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_DIR_SLASH,                                                RTPATH_STR_F_STYLE_UNIX },
+        { 2,  5,  5,  "/bin/",            RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_DIR_SLASH,                                                RTPATH_STR_F_STYLE_UNIX },
         { 3,  7,  7,  "/bin/ls",          RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME,                                                 RTPATH_STR_F_STYLE_UNIX },
         { 3,  12, 7,  "/etc/rc.conf",     RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_SUFFIX,                            RTPATH_STR_F_STYLE_UNIX },
@@ -72,6 +71,6 @@
         { 3,  6,  7,  "/.//bin",          RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_EXTRA_SLASHES | RTPATH_PROP_DOT_REFS | RTPATH_PROP_FILENAME, RTPATH_STR_F_STYLE_UNIX },
         { 1,  3,  3,  "bin",              RTPATH_PROP_RELATIVE | RTPATH_PROP_FILENAME,                                                                          RTPATH_STR_F_STYLE_UNIX },
-        { 1,  3,  4,  "bin/",             RTPATH_PROP_RELATIVE | RTPATH_PROP_DIR_SLASH,                                                                         RTPATH_STR_F_STYLE_UNIX },
-        { 1,  3,  7,  "bin////",          RTPATH_PROP_RELATIVE | RTPATH_PROP_DIR_SLASH | RTPATH_PROP_EXTRA_SLASHES,                                             RTPATH_STR_F_STYLE_UNIX },
+        { 1,  4,  4,  "bin/",             RTPATH_PROP_RELATIVE | RTPATH_PROP_DIR_SLASH,                                                                         RTPATH_STR_F_STYLE_UNIX },
+        { 1,  4,  7,  "bin////",          RTPATH_PROP_RELATIVE | RTPATH_PROP_DIR_SLASH | RTPATH_PROP_EXTRA_SLASHES,                                             RTPATH_STR_F_STYLE_UNIX },
         { 3, 10, 10,  "bin/../usr",       RTPATH_PROP_RELATIVE | RTPATH_PROP_DOTDOT_REFS | RTPATH_PROP_FILENAME,                                                RTPATH_STR_F_STYLE_UNIX },
         { 4, 11, 11,  "/bin/../usr",      RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_RELATIVE | RTPATH_PROP_DOTDOT_REFS | RTPATH_PROP_FILENAME,                       RTPATH_STR_F_STYLE_UNIX },
@@ -91,9 +90,12 @@
     {
         RTPATHPARSED    Parsed;
+        RTPATHSPLIT     Split;
         uint8_t         ab[4096];
     } u;
 
+    RTTestSub(hTest, "RTPathParse");
     for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
     {
+        memset(&u, i & 1 ? 0xff : 0, sizeof(u));
         int rc = RTPathParse(s_aTests[i].pszPath, &u.Parsed, sizeof(u), s_aTests[i].fFlags);
         if (   rc != VINF_SUCCESS
@@ -114,4 +116,50 @@
                                  s_aTests[i].offSuffix, u.Parsed.offSuffix,
                                  s_aTests[i].cchPath,   u.Parsed.cchPath);
+        }
+    }
+
+    RTTestSub(hTest, "RTPathSplit");
+    for (uint32_t i = 0; i < RT_ELEMENTS(s_aTests); i++)
+    {
+        memset(&u, i & 1 ? 0xff : 0, sizeof(u));
+        int rc = RTPathSplit(s_aTests[i].pszPath, &u.Split, sizeof(u), s_aTests[i].fFlags);
+        if (   rc != VINF_SUCCESS
+            || s_aTests[i].cComps    != u.Split.cComps
+            || s_aTests[i].fProps    != u.Split.fProps
+            || s_aTests[i].cchPath   != u.Split.cchPath)
+        {
+            RTTestFailed(hTest, "i=%d rc=%Rrc %s", i, rc, s_aTests[i].pszPath);
+            RTTestFailureDetails(hTest,
+                                 "  cComps    %u, got %u\n"
+                                 "  fProps    %#x, got %#x, xor=>%#x\n"
+                                 "  cchPath   %u, got %u\n"
+                                 ,
+                                 s_aTests[i].cComps,    u.Split.cComps,
+                                 s_aTests[i].fProps,    u.Split.fProps, s_aTests[i].fProps ^ u.Split.fProps,
+                                 s_aTests[i].cchPath,   u.Split.cchPath);
+        }
+        else
+        {
+            RTTESTI_CHECK_MSG(*u.Split.pszSuffix == '\0' || *u.Split.pszSuffix == '.', ("%s", u.Split.pszSuffix));
+            for (uint32_t idxComp = RTPATH_PROP_HAS_ROOT_SPEC(u.Split.fProps); idxComp < u.Split.cComps; idxComp++)
+                if ( (s_aTests[i].fFlags & RTPATH_STR_F_STYLE_MASK) == RTPATH_STR_F_STYLE_DOS
+                    ? strpbrk(u.Split.apszComps[idxComp], "/\\")
+                    : strchr(u.Split.apszComps[idxComp], RTPATH_SLASH) )
+                    RTTestFailed(hTest, "i=%d idxComp=%d '%s'", i, idxComp, u.Split.apszComps[idxComp]);
+
+            PRTPATHSPLIT pSplit = NULL;
+            RTTESTI_CHECK_RC(rc = RTPathSplitA(s_aTests[i].pszPath, &pSplit, s_aTests[i].fFlags), VINF_SUCCESS);
+            if (RT_SUCCESS(rc))
+            {
+                RTTESTI_CHECK(pSplit);
+                RTTESTI_CHECK(pSplit->cComps   == u.Split.cComps);
+                RTTESTI_CHECK(pSplit->fProps   == u.Split.fProps);
+                RTTESTI_CHECK(pSplit->cchPath  == u.Split.cchPath);
+                RTTESTI_CHECK(pSplit->cbNeeded == u.Split.cbNeeded);
+                RTTESTI_CHECK(!strcmp(pSplit->pszSuffix, u.Split.pszSuffix));
+                for (uint32_t idxComp = 0; idxComp < u.Split.cComps; idxComp++)
+                    RTTESTI_CHECK(!strcmp(pSplit->apszComps[idxComp], pSplit->apszComps[idxComp]));
+                RTPathSplitFree(pSplit);
+            }
         }
     }
@@ -702,5 +750,5 @@
     }
 
-    testParser(hTest);
+    testParserAndSplitter(hTest);
 
     /*
