Changeset 21714 in vbox for trunk/src/VBox/Runtime

Timestamp:

Jul 17, 2009 11:22:40 PM (16 years ago)

Author:

vboxsync

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

50274

Message:

iprt/string: conversion between Utf16 and Latin1

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• common/string/utf-16.cpp (modified) (1 diff)
• testcase/tstUtf8.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -739 +739 @@
         common/path/RTPathStripFilename.cpp \
         common/path/RTPathStripTrailingSlash.cpp \
+        common/string/RTStrNLen.cpp \
+        common/string/RTStrNLenEx.cpp \
         common/string/straprintf.cpp \
         common/string/strformat.cpp \

trunk/src/VBox/Runtime/common/string/utf-16.cpp

@@ -649 +649 @@
 RT_EXPORT_SYMBOL(RTUtf16PutCpInternal);
 
+
+/**
+ * Validate the UTF-16 encoding and calculates the length of a Latin1 encoding.
+ *
+ * @returns iprt status code.
+ * @param   pwsz        The UTF-16 string.
+ * @param   cwc         The max length of the UTF-16 string to consider.
+ * @param   pcch        Where to store the length (excluding '\\0') of the Latin1 string. (cch == cb, btw)
+ */
+static int rtUtf16CalcLatin1Length(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
+{
+    int     rc = VINF_SUCCESS;
+    size_t  cch = 0;
+    while (cwc > 0)
+    {
+        RTUTF16 wc = *pwsz++; cwc--;
+        if (!wc)
+            break;
+        else if (wc < 0xd800 || wc > 0xdfff)
+        {
+            if (wc < 0xfffe)
+                ++cch;
+            else
+            {
+                RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
+                rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
+                break;
+            }
+        }
+        else
+        {
+            if (wc >= 0xdc00)
+            {
+                RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            if (cwc <= 0)
+            {
+                RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            wc = *pwsz++; cwc--;
+            if (wc < 0xdc00 || wc > 0xdfff)
+            {
+                RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            ++cch;
+        }
+    }
+
+
+    /* done */
+    *pcch = cch;
+    return rc;
+}
+
+
+/**
+ * Recodes an valid UTF-16 string as Latin1.
+ *
+ * @returns iprt status code.
+ * @param   pwsz        The UTF-16 string.
+ * @param   cwc         The number of RTUTF16 characters to process from pwsz. The recoding
+ *                      will stop when cwc or '\\0' is reached.
+ * @param   psz         Where to store the Latin1 string.
+ * @param   cch         The size of the Latin1 buffer, excluding the terminator.
+ * @param   pcch        Where to store the number of octets actually encoded.
+ */
+static int rtUtf16RecodeAsLatin1(PCRTUTF16 pwsz, size_t cwc, char *psz, size_t cch, size_t *pcch)
+{
+    unsigned char  *pwch = (unsigned char *)psz;
+    int             rc = VINF_SUCCESS;
+    while (cwc > 0)
+    {
+        RTUTF16 wc = *pwsz++; cwc--;
+        if (!wc)
+            break;
+        else if (wc < 0xd800 || wc > 0xdfff)
+        {
+            if (wc < 0x100)
+            {
+                if (cch < 1)
+                {
+                    RTStrAssertMsgFailed(("Buffer overflow! 1\n"));
+                    rc = VERR_BUFFER_OVERFLOW;
+                    break;
+                }
+                cch--;
+                *pwch++ = (char)wc;
+            }
+            else if (wc < 0xfffe)
+            {
+                if (cch < 1)
+                {
+                    RTStrAssertMsgFailed(("Buffer overflow! 3\n"));
+                    rc = VERR_BUFFER_OVERFLOW;
+                    break;
+                }
+                cch--;
+                *pwch++ = '?';
+            }
+            else
+            {
+                RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
+                rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
+                break;
+            }
+        }
+        else
+        {
+            if (wc >= 0xdc00)
+            {
+                RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            if (cwc <= 0)
+            {
+                RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            RTUTF16 wc2 = *pwsz++; cwc--;
+            if (wc2 < 0xdc00 || wc2 > 0xdfff)
+            {
+                RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
+                rc = VERR_INVALID_UTF16_ENCODING;
+                break;
+            }
+            if (cch < 1)
+            {
+                RTStrAssertMsgFailed(("Buffer overflow! 4\n"));
+                rc = VERR_BUFFER_OVERFLOW;
+                break;
+            }
+            cch--;
+            *pwch++ = '?';
+        }
+    }
+
+    /* done */
+    *pwch = '\0';
+    *pcch = (char *)pwch - psz;
+    return rc;
+}
+
+
+RTDECL(int)  RTUtf16ToLatin1(PCRTUTF16 pwszString, char **ppszString)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(ppszString));
+    Assert(VALID_PTR(pwszString));
+    *ppszString = NULL;
+
+    /*
+     * Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
+     */
+    size_t cch;
+    int rc = rtUtf16CalcLatin1Length(pwszString, RTSTR_MAX, &cch);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Allocate buffer and recode it.
+         */
+        char *pszResult = (char *)RTMemAlloc(cch + 1);
+        if (pszResult)
+        {
+            rc = rtUtf16RecodeAsLatin1(pwszString, RTSTR_MAX, pszResult, cch, &cch);
+            if (RT_SUCCESS(rc))
+            {
+                *ppszString = pszResult;
+                return rc;
+            }
+
+            RTMemFree(pszResult);
+        }
+        else
+            rc = VERR_NO_STR_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTUtf16ToLatin1);
+
+
+RTDECL(int)  RTUtf16ToLatin1Ex(PCRTUTF16 pwszString, size_t cwcString, char **ppsz, size_t cch, size_t *pcch)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(pwszString));
+    Assert(VALID_PTR(ppsz));
+    Assert(!pcch || VALID_PTR(pcch));
+
+    /*
+     * Validate the UTF-16 string and calculate the length of the Latin1 encoding of it.
+     */
+    size_t cchResult;
+    int rc = rtUtf16CalcLatin1Length(pwszString, cwcString, &cchResult);
+    if (RT_SUCCESS(rc))
+    {
+        if (pcch)
+            *pcch = cchResult;
+
+        /*
+         * Check buffer size / Allocate buffer and recode it.
+         */
+        bool fShouldFree;
+        char *pszResult;
+        if (cch > 0 && *ppsz)
+        {
+            fShouldFree = false;
+            if (cch <= cchResult)
+                return VERR_BUFFER_OVERFLOW;
+            pszResult = *ppsz;
+        }
+        else
+        {
+            *ppsz = NULL;
+            fShouldFree = true;
+            cch = RT_MAX(cch, cchResult + 1);
+            pszResult = (char *)RTMemAlloc(cch);
+        }
+        if (pszResult)
+        {
+            rc = rtUtf16RecodeAsLatin1(pwszString, cwcString, pszResult, cch - 1, &cch);
+            if (RT_SUCCESS(rc))
+            {
+                *ppsz = pszResult;
+                return rc;
+            }
+
+            if (fShouldFree)
+                RTMemFree(pszResult);
+        }
+        else
+            rc = VERR_NO_STR_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTUtf16ToLatin1Ex);
+
+
+RTDECL(size_t) RTUtf16CalcLatin1Len(PCRTUTF16 pwsz)
+{
+    size_t cch;
+    int rc = rtUtf16CalcLatin1Length(pwsz, RTSTR_MAX, &cch);
+    return RT_SUCCESS(rc) ? cch : 0;
+}
+RT_EXPORT_SYMBOL(RTUtf16CalcLatin1Len);
+
+
+RTDECL(int) RTUtf16CalcLatin1LenEx(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
+{
+    size_t cch;
+    int rc = rtUtf16CalcLatin1Length(pwsz, cwc, &cch);
+    if (pcch)
+        *pcch = RT_SUCCESS(rc) ? cch : ~(size_t)0;
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTUtf16CalcLatin1LenEx);
+
+
+/**
+ * Calculates the UTF-16 length of a Latin1 string.  In fact this is just the
+ * original length, but the function saves us nasty comments to that effect
+ * all over the place.
+ *
+ * @returns IPRT status code.
+ * @param   psz     Pointer to the Latin1 string.
+ * @param   cch     The max length of the string. (btw cch = cb)
+ *                  Use RTSTR_MAX if all of the string is to be examined.s
+ * @param   pcwc    Where to store the length of the UTF-16 string as a number of RTUTF16 characters.
+ */
+static int rtLatin1CalcUtf16Length(const char *psz, size_t cch, size_t *pcwc)
+{
+    *pcwc = RTStrNLen(psz, cch);
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Recodes a Latin1 string as UTF-16.  This is just a case of expanding it to
+ * sixteen bits, as Unicode is a superset of Latin1.
+ *
+ * Since we know the input is valid, we do *not* perform length checks.
+ *
+ * @returns iprt status code.
+ * @param   psz     The Latin1 string to recode.
+ * @param   cch     The number of chars (the type char, so bytes if you like) to process of the Latin1 string.
+ *                  The recoding will stop when cch or '\\0' is reached. Pass RTSTR_MAX to process up to '\\0'.
+ * @param   pwsz    Where to store the UTF-16 string.
+ * @param   cwc     The number of RTUTF16 items the pwsz buffer can hold, excluding the terminator ('\\0').
+ * @param   pcwc    Where to store the actual number of RTUTF16 items encoded into the UTF-16. This excludes the terminator.
+ */
+static int rtLatin1RecodeAsUtf16(const char *psz, size_t cch, PRTUTF16 pwsz, size_t cwc, size_t *pcwc)
+{
+    int                     rc = VINF_SUCCESS;
+    const unsigned char    *puch = (const unsigned char *)psz;
+    const PRTUTF16          pwszEnd = pwsz + cwc;
+    PRTUTF16                pwc = pwsz;
+    Assert(pwszEnd >= pwc);
+    while (cch > 0)
+    {
+        /* read the next char and check for terminator. */
+        const unsigned char uch = *puch;
+        if (!uch)
+            break;
+
+        /* check for output overflow */
+        if (pwc >= pwszEnd)
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+
+        /* expand the code point */
+        *pwc++ = uch;
+        puch++;
+        cch--;
+    }
+
+    /* done */
+    *pwc = '\0';
+    *pcwc = pwc - pwsz;
+    return rc;
+}
+
+
+RTDECL(int) RTLatin1ToUtf16(const char *pszString, PRTUTF16 *ppwszString)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(ppwszString));
+    Assert(VALID_PTR(pszString));
+    *ppwszString = NULL;
+
+    /*
+     * Validate the input and calculate the length of the UTF-16 string.
+     */
+    size_t cwc;
+    int rc = rtLatin1CalcUtf16Length(pszString, RTSTR_MAX, &cwc);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Allocate buffer.
+         */
+        PRTUTF16 pwsz = (PRTUTF16)RTMemAlloc((cwc + 1) * sizeof(RTUTF16));
+        if (pwsz)
+        {
+            /*
+             * Encode the UTF-16 string.
+             */
+            rc = rtLatin1RecodeAsUtf16(pszString, RTSTR_MAX, pwsz, cwc, &cwc);
+            if (RT_SUCCESS(rc))
+            {
+                *ppwszString = pwsz;
+                return rc;
+            }
+            RTMemFree(pwsz);
+        }
+        else
+            rc = VERR_NO_UTF16_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTLatin1ToUtf16);
+
+
+RTDECL(int)  RTLatin1ToUtf16Ex(const char *pszString, size_t cchString, PRTUTF16 *ppwsz, size_t cwc, size_t *pcwc)
+{
+    /*
+     * Validate input.
+     */
+    Assert(VALID_PTR(pszString));
+    Assert(VALID_PTR(ppwsz));
+    Assert(!pcwc || VALID_PTR(pcwc));
+
+    /*
+     * Validate the input and calculate the length of the UTF-16 string.
+     */
+    size_t cwcResult;
+    int rc = rtLatin1CalcUtf16Length(pszString, cchString, &cwcResult);
+    if (RT_SUCCESS(rc))
+    {
+        if (pcwc)
+            *pcwc = cwcResult;
+
+        /*
+         * Check buffer size / Allocate buffer.
+         */
+        bool fShouldFree;
+        PRTUTF16 pwszResult;
+        if (cwc > 0 && *ppwsz)
+        {
+            fShouldFree = false;
+            if (cwc <= cwcResult)
+                return VERR_BUFFER_OVERFLOW;
+            pwszResult = *ppwsz;
+        }
+        else
+        {
+            *ppwsz = NULL;
+            fShouldFree = true;
+            cwc = RT_MAX(cwcResult + 1, cwc);
+            pwszResult = (PRTUTF16)RTMemAlloc(cwc * sizeof(RTUTF16));
+        }
+        if (pwszResult)
+        {
+            /*
+             * Encode the UTF-16 string.
+             */
+            rc = rtLatin1RecodeAsUtf16(pszString, cchString, pwszResult, cwc - 1, &cwcResult);
+            if (RT_SUCCESS(rc))
+            {
+                *ppwsz = pwszResult;
+                return rc;
+            }
+            if (fShouldFree)
+                RTMemFree(pwszResult);
+        }
+        else
+            rc = VERR_NO_UTF16_MEMORY;
+    }
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTLatin1ToUtf16Ex);
+
+
+RTDECL(size_t) RTLatin1CalcUtf16Len(const char *psz)
+{
+    size_t cwc;
+    int rc = rtLatin1CalcUtf16Length(psz, RTSTR_MAX, &cwc);
+    return RT_SUCCESS(rc) ? cwc : 0;
+}
+RT_EXPORT_SYMBOL(RTLatin1CalcUtf16Len);
+
+
+RTDECL(int) RTLatin1CalcUtf16LenEx(const char *psz, size_t cch, size_t *pcwc)
+{
+    size_t cwc;
+    int rc = rtLatin1CalcUtf16Length(psz, cch, &cwc);
+    if (pcwc)
+        *pcwc = RT_SUCCESS(rc) ? cwc : ~(size_t)0;
+    return rc;
+}
+RT_EXPORT_SYMBOL(RTLatin1CalcUtf16LenEx);

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

@@ -1009 +1009 @@
 }
 
+void testLatin1(RTTEST hTest)
+{
+    RTTestSub(hTest, "Latin1 conversion functions");
+    
+    /* Test Utf16 -> Latin1 */
+    size_t cch_szAll = 0;
+    int rc = RTUtf16CalcLatin1LenEx(g_wszAll, 255, &cch_szAll);
+    RTTEST_CHECK(hTest, (cch_szAll == 255));
+    rc = RTUtf16CalcLatin1LenEx(g_wszAll, RTSTR_MAX, &cch_szAll);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cch_szAll == 0x110000 - 1 - 0x800 - 2));
+        RTTEST_CHECK(hTest, (cch_szAll == RTUtf16CalcLatin1Len(g_wszAll)));
+    }
+    char *psz = NULL;
+    rc = RTUtf16ToLatin1(g_wszAll, &psz);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (strlen(psz) == cch_szAll));
+        for (unsigned i = 0, j = 1; psz[i] != '\0'; ++i, ++j)
+            if (   ((j < 0x100) && (psz[i] != (char) j))
+                || ((j > 0xff) && psz[i] != '?'))
+            {
+                RTTestFailed(hTest, "conversion of g_wszAll to Latin1 failed at position %u\n", i);
+                break;
+            }
+    }
+    char sz[512];
+    char *psz2 = &sz[0];
+    size_t cchActual = 0;
+    rc = RTUtf16ToLatin1Ex(g_wszAll, sizeof(sz) - 1, &psz2, sizeof(sz),
+                           &cchActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cchActual == sizeof(sz) - 1));
+        RTTEST_CHECK(hTest, (cchActual == strlen(sz)));
+        for (unsigned i = 0, j = 1; psz[i] != '\0'; ++i, ++j)
+            if (   ((j < 0x100) && (psz[i] != (char) j))
+                || ((j > 0xff) && psz[i] != '?'))
+            {
+                RTTestFailed(hTest, "second conversion of g_wszAll to Latin1 failed at position %u\n", i);
+                break;
+            }
+    }
+    rc = RTUtf16ToLatin1Ex(g_wszAll, sizeof(sz), &psz2, sizeof(sz),
+                           &cchActual);
+    RTTEST_CHECK_RC(hTest, rc, VERR_BUFFER_OVERFLOW);
+    /** @todo Either fix the documentation or fix the code - cchActual is
+     * set to the number of bytes actually encoded. */
+    RTTEST_CHECK(hTest, (cchActual == sizeof(sz)));
+    RTStrFree(psz);
+    rc = RTUtf16ToLatin1Ex(g_wszAll, 512, &psz, 0, &cchActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cchActual == 512));
+        RTTEST_CHECK(hTest, (cchActual == strlen(psz)));
+        for (unsigned i = 0, j = 1; psz[i] != '\0'; ++i, ++j)
+            if (   ((j < 0x100) && (psz[i] != (char) j))
+                || ((j > 0xff) && psz[i] != '?'))
+            {
+                RTTestFailed(hTest, "third conversion of g_wszAll to Latin1 failed at position %u\n", i);
+                break;
+            }
+    }
+    const char *pszGood = "H\0e\0l\0l\0o\0\0\xD8\0\xDC\0";
+    const char *pszBad = "H\0e\0l\0l\0o\0\0\xDC\0\xD8\0";
+    rc = RTUtf16ToLatin1Ex((RTUTF16 *) pszGood, RTSTR_MAX, &psz2, sizeof(sz),
+                           &cchActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    RTTEST_CHECK(hTest, (cchActual == 6));
+    RTTEST_CHECK(hTest, (strlen(sz) == 6));
+    rc = RTUtf16ToLatin1Ex((RTUTF16 *) pszGood, RTSTR_MAX, &psz2, sizeof(sz),
+                           NULL);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    rc = RTUtf16ToLatin1Ex((RTUTF16 *) pszBad, RTSTR_MAX, &psz2, sizeof(sz),
+                           &cchActual);
+    RTTEST_CHECK_RC(hTest, rc, VERR_INVALID_UTF16_ENCODING);
+    RTStrFree(psz);
+    rc = RTUtf16ToLatin1((RTUTF16 *) pszGood, &psz);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    RTTEST_CHECK(hTest, (strlen(psz) == 6));
+    RTStrFree(psz);
+
+    /* Test Latin1 -> Utf16 */
+    const char *pszLat1 = "\x01\x20\x40\x80\x81";
+    RTTEST_CHECK(hTest, (RTLatin1CalcUtf16Len(pszLat1) == 5));
+    rc = RTLatin1CalcUtf16LenEx(pszLat1, 3, &cchActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+        RTTEST_CHECK(hTest, (cchActual == 3));
+    rc = RTLatin1CalcUtf16LenEx(pszLat1, RTSTR_MAX, &cchActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+        RTTEST_CHECK(hTest, (cchActual == 5));
+    RTUTF16 *pwc = NULL;
+    RTUTF16 wc[6];
+    RTUTF16 *pwc2 = &wc[0];
+    size_t cwActual = 0;
+    rc = RTLatin1ToUtf16(pszLat1, &pwc);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+        RTTEST_CHECK(hTest,    (pwc[0] == 1) && (pwc[1] == 0x20)
+                            && (pwc[2] == 0x40) && (pwc[3] == 0x80)
+                            && (pwc[4] == 0x81) && (pwc[5] == '\0'));
+    RTUtf16Free(pwc);
+    rc = RTLatin1ToUtf16Ex(pszLat1, RTSTR_MAX, &pwc, 0, &cwActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cwActual == 5));
+        RTTEST_CHECK(hTest,    (pwc[0] == 1) && (pwc[1] == 0x20)
+                            && (pwc[2] == 0x40) && (pwc[3] == 0x80)
+                            && (pwc[4] == 0x81) && (pwc[5] == '\0'));
+    }
+    RTUtf16Free(pwc);
+    rc = RTLatin1ToUtf16Ex(pszLat1, RTSTR_MAX, &pwc, 0, NULL);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+        RTTEST_CHECK(hTest,    (pwc[0] == 1) && (pwc[1] == 0x20)
+                            && (pwc[2] == 0x40) && (pwc[3] == 0x80)
+                            && (pwc[4] == 0x81) && (pwc[5] == '\0'));
+    rc = RTLatin1ToUtf16Ex(pszLat1, RTSTR_MAX, &pwc2, RT_ELEMENTS(wc),
+                           &cwActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cwActual == 5));
+        RTTEST_CHECK(hTest,    (wc[0] == 1) && (wc[1] == 0x20)
+                            && (wc[2] == 0x40) && (wc[3] == 0x80)
+                            && (wc[4] == 0x81) && (wc[5] == '\0'));
+    }
+    rc = RTLatin1ToUtf16Ex(pszLat1, 3, &pwc2, RT_ELEMENTS(wc),
+                           &cwActual);
+    RTTEST_CHECK_RC_OK(hTest, rc);
+    if (RT_SUCCESS(rc))
+    {
+        RTTEST_CHECK(hTest, (cwActual == 3));
+        RTTEST_CHECK(hTest,    (wc[0] == 1) && (wc[1] == 0x20)
+                            && (wc[2] == 0x40) && (wc[3] == '\0'));
+    }
+    rc = RTLatin1ToUtf16Ex(pszLat1, RTSTR_MAX, &pwc2, RT_ELEMENTS(wc) - 1,
+                           &cwActual);
+    RTTEST_CHECK_RC(hTest, rc, VERR_BUFFER_OVERFLOW);
+    /** @todo Either fix the documentation or fix the code - cchActual is
+     * set to the number of bytes actually encoded. */
+    RTTEST_CHECK(hTest, (cwActual == 5));
+    RTTestSubDone(hTest);
+}
+
 int main()
 {
@@ -1032 +1185 @@
     testMinistring(hTest);
 
+    testLatin1(hTest);
+
     Benchmarks(hTest);