CharFuncs.c File Reference

#include "precomp.h"
#include <winnls.h>
#include <ndk/rtlfuncs.h>
#include <pseh/pseh2.h>
#include <strsafe.h>
#include <versionhelpers.h>

Include dependency graph for CharFuncs.c:

Go to the source code of this file.

Classes
struct	TESTS_CHARPREV
struct	ST_TESTS_CHARPREV
struct	ST_CODEPAGE_TESTS_CHARPREV
struct	ST_TESTS_CHARNEXT
struct	ST_CODEPAGE_TESTS_CHARNEXT
struct	EX_TESTS_CHARPREV
struct	EX_TESTS_CHARNEXT

Macros
#define	INVALID_PTR_OFF(x)   ((PVOID)(ULONG_PTR)(0xdeadbeefdeadbeefULL + x))
#define	INVALID_PTR   INVALID_PTR_OFF(0)
#define	TEST_ACP   1252

Enumerations
enum	TEST_TYPE { testLen , testOffs , testBoth }

Functions
static LPWSTR	AllocStringW (LPWSTR lpszStr, SIZE_T len)
static LPSTR	AllocStringA (LPWSTR lpszStr, SIZE_T len)
static void	testCharPrevW (const TESTS_CHARPREV *pEntry, SIZE_T len, UINT i)
static void	testCharPrevA (const TESTS_CHARPREV *pEntry, SIZE_T len, UINT i)
static void	testDynCharPrev (const TESTS_CHARPREV *pEntry, UINT i)
static void	testStatCharPrev (const ST_TESTS_CHARPREV *pEntry, UINT i)
static void	testStatCodePageCharPrev (const ST_CODEPAGE_TESTS_CHARPREV *pEntry, UINT i)
static void	testStatCharNext (const ST_TESTS_CHARNEXT *pEntry, UINT i)
static void	testStatCodePageCharNext (const ST_CODEPAGE_TESTS_CHARNEXT *pEntry, UINT i)
static void	testCharPrev (void)
static void	testCharNext (void)
	START_TEST (CharFuncs)

Variables
TESTS_CHARPREV	TestCharPrev []
TESTS_CHARPREV	TestCharPrev_XP []
TESTS_CHARPREV	TestCharPrev_Vista []
static const WCHAR	wszReactOS [] = L"C:\\ReactOS"
static const CHAR	szReactOS [] = "C:\\ReactOS"
static const WCHAR	wszSpecial [] = L"test\0\0\0\0\0\0aa\t\t\t\r\n\r\n"
static const CHAR	szSpecial [] = "test\0\0\0\0\0\0aa\t\t\t\r\n\r\n"
static const WCHAR	wszMagic1 [] = L"test a\x030a"
static const WCHAR	wszMagic2 [] = L"test a\x0301\x0302\x0303\x0304"
static const CHAR	szUTF8Cyril [] = "test \xD1\x82\xD0\xB5\xD1\x81\xD1\x82"
static const CHAR	szUTF8Greek [] = "test \xCF\x84\xCE\xB5\xCF\x83\xCF\x84"
static const CHAR	szUTF8Japan [] = "test \xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88"
static const CHAR	szCP932Japan [] = "test \x83\x65\x83\x58\x83\x67"
ST_TESTS_CHARPREV	TestStaticCharPrev []
ST_TESTS_CHARPREV	TestStaticCharPrev_XP []
ST_TESTS_CHARPREV	TestStaticCharPrev_Vista []
ST_CODEPAGE_TESTS_CHARPREV	TestStaticCodePageCharPrev []
ST_TESTS_CHARNEXT	TestStaticCharNext []
ST_TESTS_CHARNEXT	TestStaticCharNext_XP []
ST_TESTS_CHARNEXT	TestStaticCharNext_Vista []
ST_CODEPAGE_TESTS_CHARNEXT	TestStaticCodePageCharNext []
EX_TESTS_CHARPREV	TestExceptionCharPrev []
EX_TESTS_CHARNEXT	TestExceptionCharNext []

Macro Definition Documentation

INVALID_PTR

#define INVALID_PTR   INVALID_PTR_OFF(0)

Definition at line 17 of file CharFuncs.c.

INVALID_PTR_OFF

#define INVALID_PTR_OFF

(

x

)

((PVOID)(ULONG_PTR)(0xdeadbeefdeadbeefULL + x))

Definition at line 16 of file CharFuncs.c.

TEST_ACP

#define TEST_ACP   1252

Definition at line 20 of file CharFuncs.c.

Enumeration Type Documentation

TEST_TYPE

enum TEST_TYPE

Enumerator
testLen
testOffs
testBoth

Definition at line 22 of file CharFuncs.c.

{
    testLen,
    testOffs,
    testBoth,
} TEST_TYPE;

Function Documentation

AllocStringA()

static LPSTR AllocStringA ( LPWSTR  lpszStr, SIZE_T  len  )

static

Definition at line 397 of file CharFuncs.c.

{
    LPSTR str;
    SIZE_T sz, mbs;
 
    if (!lpszStr)
        return NULL;
 
    sz = len + 1;
    str = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz);
    if (!str)
    {
        trace("HeapAlloc failed (error %ld)\n", GetLastError());
        goto Skip;
    }
 
    mbs = WideCharToMultiByte(TEST_ACP, 0, lpszStr, -1, NULL, 0, NULL, NULL);
    if (!mbs || mbs > sz)
    {
        HeapFree(GetProcessHeap(), 0, str);
        str = NULL;
        trace("WideCharToMultiByte returned %lu (error %ld)\n", mbs, GetLastError());
        goto Skip;
    }
 
    WideCharToMultiByte(TEST_ACP, 0, lpszStr, -1, str, mbs, NULL, NULL);
Skip:
    return str;
}

Referenced by testCharPrevA().

AllocStringW()

static LPWSTR AllocStringW ( LPWSTR  lpszStr, SIZE_T  len  )

static

Definition at line 377 of file CharFuncs.c.

{
    LPWSTR str;
    SIZE_T sz;
 
    if (!lpszStr)
        return NULL;
 
    sz = (len + 1) * sizeof(lpszStr[0]);
    str = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz);
    if (!str)
    {
        trace("HeapAlloc failed (error %ld)\n", GetLastError());
        goto Skip;
    }
    StringCbCopyW(str, sz, lpszStr);
Skip:
    return str;
}

Referenced by testCharPrevW().

START_TEST()

START_TEST

(

CharFuncs

)

Definition at line 813 of file CharFuncs.c.

{
    testCharPrev();
    testCharNext();
}

testCharNext()

static void testCharNext ( void  )

static

Definition at line 721 of file CharFuncs.c.

{
    UINT i;
 
    /* Perform static tests */
    for (i = 0; i < _countof(TestStaticCharNext); i++)
    {
        testStatCharNext(&TestStaticCharNext[i], i);
    }
 
    if (!IsWindowsVistaOrGreater())
    {
        for (i = 0; i < _countof(TestStaticCharNext_XP); i++)
        {
            testStatCharNext(&TestStaticCharNext_XP[i], i);
        }
    }
    else
    {
        for (i = 0; i < _countof(TestStaticCharNext_Vista); i++)
        {
            testStatCharNext(&TestStaticCharNext_Vista[i], i);
        }
    }
 
    for (i = 0; i < _countof(TestStaticCodePageCharNext); i++)
    {
        testStatCodePageCharNext(&TestStaticCodePageCharNext[i], i);
    }
 
    /* Perform exception tests (check corner cases) */
    if (INVALID_PTR < (PVOID)wszReactOS)
    {
        ok(FALSE, "testCharNext: unexpected INVALID PTR < wszReactOS\n");
        return;
    }
    if (INVALID_PTR < (PVOID)szReactOS)
    {
        ok(FALSE, "testCharNext: unexpected INVALID PTR < szReactOS\n");
        return;
    }
 
    for (i = 0; i < _countof(TestExceptionCharNext); i++)
    {
        LPWSTR pchW;
        LPSTR pchA;
        const EX_TESTS_CHARNEXT *pEntry = &TestExceptionCharNext[i];
        NTSTATUS Status = STATUS_SUCCESS;
 
        //trace("0x%p\n", pEntry->wszString);
        pchW = NULL;
        _SEH2_TRY
        {
            pchW = CharNextW(pEntry->wszString);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharNextW: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchW == pEntry->wszResult, "[%u] CharNextW: pchW is 0x%p, expected 0x%p\n", i, pchW, pEntry->wszResult);
 
        //trace("0x%p 0x%p\n", pEntry->szString);
        pchA = NULL;
        _SEH2_TRY
        {
            pchA = CharNextA(pEntry->szString);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharNextA: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchA == pEntry->szResult, "[%u] CharNextA: pchA is 0x%p, expected 0x%p\n", i, pchA, pEntry->szResult);
 
        pchA = NULL;
        _SEH2_TRY
        {
            pchA = CharNextExA(TEST_ACP, pEntry->szString, 0);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharNextExA: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchA == pEntry->szResult, "[%u] CharNextExA: pchA is 0x%p, expected 0x%p\n", i, pchA, pEntry->szResult);
    }
}

Referenced by START_TEST().

testCharPrev()

static void testCharPrev ( void  )

static

Definition at line 608 of file CharFuncs.c.

{
    UINT i;
 
    /* Perform dynamic allocation tests */
    for (i = 0; i < _countof(TestCharPrev); i++)
    {
        testDynCharPrev(&TestCharPrev[i], i);
    }
 
    if (!IsWindowsVistaOrGreater())
    {
        for (i = 0; i < _countof(TestCharPrev_XP); i++)
        {
            testDynCharPrev(&TestCharPrev_XP[i], i);
        }
    }
    else
    {
        for (i = 0; i < _countof(TestCharPrev_Vista); i++)
        {
            testDynCharPrev(&TestCharPrev_Vista[i], i);
        }
    }
 
    /* Perform static tests */
    for (i = 0; i < _countof(TestStaticCharPrev); i++)
    {
        testStatCharPrev(&TestStaticCharPrev[i], i);
    }
 
    if (!IsWindowsVistaOrGreater())
    {
        for (i = 0; i < _countof(TestStaticCharPrev_XP); i++)
        {
            testStatCharPrev(&TestStaticCharPrev_XP[i], i);
        }
    }
    else
    {
        for (i = 0; i < _countof(TestStaticCharPrev_Vista); i++)
        {
            testStatCharPrev(&TestStaticCharPrev_Vista[i], i);
        }
    }
 
    for (i = 0; i < _countof(TestStaticCodePageCharPrev); i++)
    {
        testStatCodePageCharPrev(&TestStaticCodePageCharPrev[i], i);
    }
 
    /* Perform exception tests (check corner cases) */
    if (INVALID_PTR < (PVOID)wszReactOS)
    {
        ok(FALSE, "testCharPrev: unexpected INVALID PTR < wszReactOS\n");
        return;
    }
    if (INVALID_PTR < (PVOID)szReactOS)
    {
        ok(FALSE, "testCharPrev: unexpected INVALID PTR < szReactOS\n");
        return;
    }
 
    for (i = 0; i < _countof(TestExceptionCharPrev); i++)
    {
        LPWSTR pchW;
        LPSTR pchA;
        const EX_TESTS_CHARPREV *pEntry = &TestExceptionCharPrev[i];
        NTSTATUS Status = STATUS_SUCCESS;
 
        //trace("0x%p 0x%p\n", pEntry->wszStart, pEntry->wszCurrent);
        pchW = NULL;
        _SEH2_TRY
        {
            pchW = CharPrevW(pEntry->wszStart, pEntry->wszCurrent);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharPrevW: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchW == pEntry->wszResult, "[%u] CharPrevW: pchW is 0x%p, expected 0x%p\n", i, pchW, pEntry->wszResult);
 
        //trace("0x%p 0x%p\n", pEntry->szStart, pEntry->szCurrent);
        pchA = NULL;
        _SEH2_TRY
        {
            pchA = CharPrevA(pEntry->szStart, pEntry->szCurrent);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharPrevA: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchA == pEntry->szResult, "[%u] CharPrevA: pchA is 0x%p, expected 0x%p\n", i, pchA, pEntry->szResult);
 
        pchA = NULL;
        _SEH2_TRY
        {
            pchA = CharPrevExA(TEST_ACP, pEntry->szStart, pEntry->szCurrent, 0);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
        ok(Status == pEntry->resStatus, "[%u] CharPrevExA: Status is 0x%lX, expected 0x%lX\n", i, Status, pEntry->resStatus);
        ok(pchA == pEntry->szExResult, "[%u] CharPrevExA: pchA is 0x%p, expected 0x%p\n", i, pchA, pEntry->szExResult);
    }
}

Referenced by START_TEST().

testCharPrevA()

static void testCharPrevA ( const TESTS_CHARPREV *  pEntry, SIZE_T  len, UINT  i  )

static

Definition at line 484 of file CharFuncs.c.

{
    LPSTR szStart, szCurrent;
    LPSTR pchA, pchEx;
    INT iRealOffset;
    BOOL b;
 
    szStart = AllocStringA(pEntry->lpszStart, len);
    if (!szStart && pEntry->lpszStart)
    {
        skip("[%u] AllocStringA for szStart failed\n", i);
        goto Cleanup;
    }
    if (pEntry->testType == testLen)
        szCurrent = szStart + len;
    else if (pEntry->testType == testOffs)
        szCurrent = szStart + pEntry->iOffset;
    else
    {
        szCurrent = AllocStringA(pEntry->lpszCurrent, wcslen(pEntry->lpszCurrent));
        if (!szCurrent && pEntry->lpszCurrent)
        {
            skip("[%u] AllocStringA for szCurrent failed\n", i);
            goto Cleanup;
        }
    }
    pchA = CharPrevA(szStart, szCurrent);
    pchEx = CharPrevExA(TEST_ACP, szStart, szCurrent, 0);
    if (szCurrent - szStart >= 0)
        iRealOffset = pEntry->iResOffset;
    else
        iRealOffset = pEntry->iResOffsetNeg;
    if (pEntry->bWithinStart)
    {
        b = pchA >= szStart && pchA <= szStart + len;
        if (iRealOffset >= 0)
            ok(b, "[%u] CharPrevA: pchA (0x%p) is expected to be within szStart (0x%p)\n", i, pchA, szStart);
        else
            ok(!b, "[%u] CharPrevA: pchA (0x%p) is expected to be outside szStart (0x%p)\n", i, pchA, szStart);
        ok(pchA == szStart + iRealOffset, "[%u] CharPrevA: pchA is 0x%p (offset %d)\n", i, pchA, pchA - szStart);
    }
    else
    {
        b = pchA >= szCurrent && pchA <= szCurrent + wcslen(pEntry->lpszCurrent);
        if (iRealOffset >= 0)
            ok(b, "[%u] CharPrevA: pchA (0x%p) is expected to be within szCurrent (0x%p)\n", i, pchA, szCurrent);
        else
            ok(!b, "[%u] CharPrevA: pchA (0x%p) is expected to be outside szCurrent (0x%p)\n", i, pchA, szCurrent);
        ok(pchA == szCurrent + iRealOffset, "[%u] CharPrevA: pchA is 0x%p (offset %d)\n", i, pchA, pchA - szCurrent);
    }
    ok(pchA == pchEx, "[%u] CharPrevExA: pchA (0x%p) is not equal to pchEx (0x%p)\n", i, pchA, pchEx);
 
Cleanup:
    if (pEntry->testType != testBoth)
        szCurrent = NULL;
    HeapFree(GetProcessHeap(), 0, szStart);
    HeapFree(GetProcessHeap(), 0, szCurrent);
}

Referenced by testDynCharPrev().

testCharPrevW()

static void testCharPrevW ( const TESTS_CHARPREV *  pEntry, SIZE_T  len, UINT  i  )

static

Definition at line 427 of file CharFuncs.c.

{
    LPWSTR wszStart, wszCurrent;
    LPWSTR pchW;
    INT iRealOffset;
    BOOL b;
 
    wszStart = AllocStringW(pEntry->lpszStart, len);
    if (!wszStart && pEntry->lpszStart)
    {
        skip("[%u] AllocStringW for wszStart failed\n", i);
        goto Cleanup;
    }
    if (pEntry->testType == testLen)
        wszCurrent = wszStart + len;
    else if (pEntry->testType == testOffs)
        wszCurrent = wszStart + pEntry->iOffset;
    else
    {
        wszCurrent = AllocStringW(pEntry->lpszCurrent, wcslen(pEntry->lpszCurrent));
        if (!wszCurrent && pEntry->lpszCurrent)
        {
            skip("[%u] AllocStringW for wszCurrent failed\n", i);
            goto Cleanup;
        }
    }
    pchW = CharPrevW(wszStart, wszCurrent);
    if (wszCurrent - wszStart >= 0)
        iRealOffset = pEntry->iResOffset;
    else
        iRealOffset = pEntry->iResOffsetNeg;
    if (pEntry->bWithinStart)
    {
        b = pchW >= wszStart && pchW <= wszStart + len;
        if (iRealOffset >= 0)
            ok(b, "[%u] CharPrevW: pchW (0x%p) is expected to be within wszStart (0x%p)\n", i, pchW, wszStart);
        else
            ok(!b, "[%u] CharPrevW: pchW (0x%p) is expected to be outside wszStart (0x%p)\n", i, pchW, wszStart);
        ok(pchW == wszStart + iRealOffset, "[%u] CharPrevW: pchW is 0x%p (offset %d)\n", i, pchW, pchW - wszStart);
    }
    else
    {
        b = pchW >= wszCurrent && pchW <= wszCurrent + wcslen(pEntry->lpszCurrent);
        if (iRealOffset >= 0)
            ok(b, "[%u] CharPrevW: pchW (0x%p) is expected to be within wszCurrent (0x%p)\n", i, pchW, wszCurrent);
        else
            ok(!b, "[%u] CharPrevW: pchW (0x%p) is expected to be outside wszCurrent (0x%p)\n", i, pchW, wszCurrent);
        ok(pchW == wszCurrent + iRealOffset, "[%u] CharPrevW: pchW is 0x%p (offset %d)\n", i, pchW, pchW - wszCurrent);
    }
 
Cleanup:
    if (pEntry->testType != testBoth)
        wszCurrent = NULL;
    HeapFree(GetProcessHeap(), 0, wszStart);
    HeapFree(GetProcessHeap(), 0, wszCurrent);
}

Referenced by testDynCharPrev().

testDynCharPrev()

static void testDynCharPrev ( const TESTS_CHARPREV *  pEntry, UINT  i  )

static

Definition at line 543 of file CharFuncs.c.

{
    SIZE_T len;
 
    len = wcslen(pEntry->lpszStart);
    testCharPrevW(pEntry, len, i);
 
    if (pEntry->bWideOnly)
        return;
 
    testCharPrevA(pEntry, len, i);
}

Referenced by testCharPrev().

testStatCharNext()

static void testStatCharNext ( const ST_TESTS_CHARNEXT *  pEntry, UINT  i  )

static

Definition at line 582 of file CharFuncs.c.

{
    LPWSTR pchW;
    LPSTR pchA;
 
    pchW = CharNextW(pEntry->wszString);
    ok(pchW == pEntry->wszResult, "[%u] CharNextW: pchW is 0x%p (expected 0x%p)\n", i, pchW, pEntry->wszResult);
 
    if (!pEntry->szString)
        return;
 
    pchA = CharNextA(pEntry->szString);
    ok(pchA == pEntry->szResult, "[%u] CharNextA: pchA is 0x%p (expected 0x%p)\n", i, pchA, pEntry->szResult);
 
    pchA = CharNextExA(TEST_ACP, pEntry->szString, 0);
    ok(pchA == pEntry->szResult, "[%u] CharNextExA: pchA is 0x%p (expected 0x%p)\n", i, pchA, pEntry->szResult);
}

Referenced by testCharNext().

testStatCharPrev()

static void testStatCharPrev ( const ST_TESTS_CHARPREV *  pEntry, UINT  i  )

static

Definition at line 556 of file CharFuncs.c.

{
    LPWSTR pchW;
    LPSTR pchA;
 
    pchW = CharPrevW(pEntry->wszStart, pEntry->wszCurrent);
    ok(pchW == pEntry->wszResult, "[%u] CharPrevW: pchW is 0x%p (expected 0x%p)\n", i, pchW, pEntry->wszResult);
 
    if (!pEntry->szStart)
        return;
 
    pchA = CharPrevA(pEntry->szStart, pEntry->szCurrent);
    ok(pchA == pEntry->szResult, "[%u] CharPrevA: pchA is 0x%p (expected 0x%p)\n", i, pchA, pEntry->szResult);
 
    pchA = CharPrevExA(TEST_ACP, pEntry->szStart, pEntry->szCurrent, 0);
    ok(pchA == pEntry->szResult, "[%u] CharPrevExA: pchA is 0x%p (expected 0x%p)\n", i, pchA, pEntry->szResult);
}

Referenced by testCharPrev().

testStatCodePageCharNext()

static void testStatCodePageCharNext ( const ST_CODEPAGE_TESTS_CHARNEXT *  pEntry, UINT  i  )

static

Definition at line 600 of file CharFuncs.c.

{
    LPSTR pchA;
 
    pchA = CharNextExA(pEntry->uCodePage, pEntry->szString, 0);
    ok(pchA == pEntry->szResult, "[%u] CharNextExA(%u): pchA is 0x%p (expected 0x%p)\n", i, pEntry->uCodePage, pchA, pEntry->szResult);
}

Referenced by testCharNext().

testStatCodePageCharPrev()

static void testStatCodePageCharPrev ( const ST_CODEPAGE_TESTS_CHARPREV *  pEntry, UINT  i  )

static

Definition at line 574 of file CharFuncs.c.

{
    LPSTR pchA;
 
    pchA = CharPrevExA(pEntry->uCodePage, pEntry->szStart, pEntry->szCurrent, 0);
    ok(pchA == pEntry->szResult, "[%u] CharPrevExA(%u): pchA is 0x%p (expected 0x%p)\n", i, pEntry->uCodePage, pchA, pEntry->szResult);
}

Referenced by testCharPrev().

Variable Documentation

szCP932Japan

const CHAR szCP932Japan[] = "test \x83\x65\x83\x58\x83\x67"

static

Definition at line 84 of file CharFuncs.c.

szReactOS

const CHAR szReactOS[] = "C:\\ReactOS"

static

Definition at line 75 of file CharFuncs.c.

Referenced by testCharNext(), and testCharPrev().

szSpecial

const CHAR szSpecial[] = "test\0\0\0\0\0\0aa\t\t\t\r\n\r\n"

static

Definition at line 77 of file CharFuncs.c.

szUTF8Cyril

const CHAR szUTF8Cyril[] = "test \xD1\x82\xD0\xB5\xD1\x81\xD1\x82"

static

Definition at line 81 of file CharFuncs.c.

szUTF8Greek

const CHAR szUTF8Greek[] = "test \xCF\x84\xCE\xB5\xCF\x83\xCF\x84"

static

Definition at line 82 of file CharFuncs.c.

szUTF8Japan

const CHAR szUTF8Japan[] = "test \xE3\x83\x86\xE3\x82\xB9\xE3\x83\x88"

static

Definition at line 83 of file CharFuncs.c.

TestCharPrev

TESTS_CHARPREV TestCharPrev[]

Initial value:

=
{
    {testLen, L"C:\\ReactOS", NULL, 0, 9, 9, TRUE, FALSE},
    {testOffs, L"abcdefghijk", NULL, 11, 10, 10, TRUE, FALSE},
    {testOffs, L"test a´^~¯", NULL, 10, 9, 9, TRUE, FALSE},
    {testOffs, L"test å", NULL, 6, 5, 5, TRUE, FALSE},
    {testBoth, L"C:\\ReactOS", L"", 0, -1, 0, FALSE, FALSE},
    {testBoth, L"C:\\ReactOS\\", L"C:\\ReactOS", 0, -1, 0, FALSE, FALSE},
    {testBoth, L"C:\\ReactOS\\", L"ReactOS", 0, -1, 0, FALSE, FALSE},
}

Definition at line 42 of file CharFuncs.c.

Referenced by testCharPrev().

TestCharPrev_Vista

TESTS_CHARPREV TestCharPrev_Vista[]

Initial value:

=
{
    
    {testOffs, L"test a\x030a", NULL, 7, 5, 5, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 10, 5, 5, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 9, 5, 5, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 8, 5, 5, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 7, 5, 5, TRUE, TRUE},
}

Definition at line 63 of file CharFuncs.c.

Referenced by testCharPrev().

TestCharPrev_XP

TESTS_CHARPREV TestCharPrev_XP[]

Initial value:

=
{
    
    {testOffs, L"test a\x030a", NULL, 7, 6, 6, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 10, 9, 9, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 9, 8, 8, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 8, 7, 7, TRUE, TRUE},
    {testOffs, L"test a\x0301\x0302\x0303\x0304", NULL, 7, 6, 6, TRUE, TRUE},
}

Definition at line 53 of file CharFuncs.c.

Referenced by testCharPrev().

TestExceptionCharNext

EX_TESTS_CHARNEXT TestExceptionCharNext[]

Initial value:

=
{
    {wszReactOS, wszReactOS + 1,
      szReactOS,  szReactOS + 1,
     STATUS_SUCCESS},
    {NULL, NULL,
     NULL, NULL,
     STATUS_ACCESS_VIOLATION},
    {INVALID_PTR, NULL,
     INVALID_PTR, NULL,
     STATUS_ACCESS_VIOLATION},
 
    {INVALID_PTR_OFF(-2), NULL,
     INVALID_PTR_OFF(-2), NULL,
     STATUS_ACCESS_VIOLATION},
    {INVALID_PTR_OFF(2), NULL,
     INVALID_PTR_OFF(2), NULL,
     STATUS_ACCESS_VIOLATION},
}

Definition at line 357 of file CharFuncs.c.

Referenced by testCharNext().

TestExceptionCharPrev

EX_TESTS_CHARPREV TestExceptionCharPrev[]

Definition at line 302 of file CharFuncs.c.

Referenced by testCharPrev().

TestStaticCharNext

ST_TESTS_CHARNEXT TestStaticCharNext[]

Definition at line 200 of file CharFuncs.c.

Referenced by testCharNext().

TestStaticCharNext_Vista

ST_TESTS_CHARNEXT TestStaticCharNext_Vista[]

Initial value:

=
{
    
    {wszMagic1 + 5, wszMagic1 + 7,
     NULL, NULL},
    {wszMagic2 + 5, wszMagic2 + 10,
     NULL, NULL},
    {wszMagic2 + 6, wszMagic2 + 10,
     NULL, NULL},
    {wszMagic2 + 7, wszMagic2 + 10,
     NULL, NULL},
    {wszMagic2 + 8, wszMagic2 + 10,
     NULL, NULL},
}

Definition at line 247 of file CharFuncs.c.

Referenced by testCharNext().

TestStaticCharNext_XP

ST_TESTS_CHARNEXT TestStaticCharNext_XP[]

Initial value:

=
{
    
    {wszMagic1 + 5, wszMagic1 + 6,
     NULL, NULL},
    {wszMagic2 + 5, wszMagic2 + 6,
     NULL, NULL},
    {wszMagic2 + 6, wszMagic2 + 7,
     NULL, NULL},
    {wszMagic2 + 7, wszMagic2 + 8,
     NULL, NULL},
    {wszMagic2 + 8, wszMagic2 + 9,
     NULL, NULL},
}

Definition at line 232 of file CharFuncs.c.

Referenced by testCharNext().

TestStaticCharPrev

ST_TESTS_CHARPREV TestStaticCharPrev[]

Definition at line 96 of file CharFuncs.c.

Referenced by testCharPrev().

TestStaticCharPrev_Vista

ST_TESTS_CHARPREV TestStaticCharPrev_Vista[]

Initial value:

=
{
    
    {wszMagic1, wszMagic1 + 7,  wszMagic1 + 5,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 10, wszMagic2 + 5,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 9,  wszMagic2 + 5,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 8,  wszMagic2 + 5,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 7,  wszMagic2 + 5,
     NULL, NULL, NULL},
}

Definition at line 150 of file CharFuncs.c.

Referenced by testCharPrev().

TestStaticCharPrev_XP

ST_TESTS_CHARPREV TestStaticCharPrev_XP[]

Initial value:

=
{
    
    {wszMagic1, wszMagic1 + 7,  wszMagic1 + 6,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 10, wszMagic2 + 9,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 9,  wszMagic2 + 8,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 8,  wszMagic2 + 7,
     NULL, NULL, NULL},
    {wszMagic2, wszMagic2 + 7,  wszMagic2 + 6,
     NULL, NULL, NULL},
}

Definition at line 135 of file CharFuncs.c.

Referenced by testCharPrev().

TestStaticCodePageCharNext

ST_CODEPAGE_TESTS_CHARNEXT TestStaticCodePageCharNext[]

Initial value:

=
{
    
    {CP_UTF8, szUTF8Cyril, szUTF8Cyril + 1},
    {CP_UTF8, szUTF8Cyril + 4, szUTF8Cyril + 5},
    {CP_UTF8, szUTF8Cyril + 5, szUTF8Cyril + 6},
    {CP_UTF8, szUTF8Cyril + 7, szUTF8Cyril + 8},
 
    {CP_UTF8, szUTF8Greek + 5, szUTF8Greek + 6},
    {CP_UTF8, szUTF8Greek + 7, szUTF8Greek + 8},
 
    {CP_UTF8, szUTF8Japan + 5, szUTF8Japan + 6},
    {CP_UTF8, szUTF8Japan + 8, szUTF8Japan + 9},
 
    
    {932,     szCP932Japan, szCP932Japan + 1},
    {932,     szCP932Japan + 5, szCP932Japan + 7},
    {932,     szCP932Japan + 7, szCP932Japan + 9},
}

Definition at line 269 of file CharFuncs.c.

Referenced by testCharNext().

TestStaticCodePageCharPrev

ST_CODEPAGE_TESTS_CHARPREV TestStaticCodePageCharPrev[]

Initial value:

=
{
    
    {CP_UTF8, szUTF8Cyril, szUTF8Cyril + 2, szUTF8Cyril + 1},
    {CP_UTF8, szUTF8Cyril, szUTF8Cyril + 7, szUTF8Cyril + 6},
    {CP_UTF8, szUTF8Cyril, szUTF8Cyril + 9, szUTF8Cyril + 8},
 
    {CP_UTF8, szUTF8Greek, szUTF8Greek + 7, szUTF8Greek + 6},
    {CP_UTF8, szUTF8Greek, szUTF8Greek + 9, szUTF8Greek + 8},
 
    {CP_UTF8, szUTF8Japan, szUTF8Japan + 8, szUTF8Japan + 7},
    {CP_UTF8, szUTF8Japan, szUTF8Japan + 11, szUTF8Japan + 10},
 
    
    {932,     szCP932Japan, szCP932Japan + 2, szCP932Japan + 1},
    {932,     szCP932Japan, szCP932Japan + 7, szCP932Japan + 5},
    {932,     szCP932Japan, szCP932Japan + 9, szCP932Japan + 7},
}

Definition at line 173 of file CharFuncs.c.

Referenced by testCharPrev().

wszMagic1

const WCHAR wszMagic1[] = L"test a\x030a"

static

Definition at line 78 of file CharFuncs.c.

wszMagic2

const WCHAR wszMagic2[] = L"test a\x0301\x0302\x0303\x0304"

static

Definition at line 79 of file CharFuncs.c.

wszReactOS

const WCHAR wszReactOS[] = L"C:\\ReactOS"

static

Definition at line 74 of file CharFuncs.c.

Referenced by testCharNext(), and testCharPrev().

wszSpecial

const WCHAR wszSpecial[] = L"test\0\0\0\0\0\0aa\t\t\t\r\n\r\n"

static

Definition at line 76 of file CharFuncs.c.