MultiByteToWideChar.c File Reference

#include "precomp.h"
#include <versionhelpers.h>

Include dependency graph for MultiByteToWideChar.c:

Go to the source code of this file.

Classes
struct	ENTRY

Macros
#define	CP932   932 /* Japanese Shift_JIS (SJIS) codepage */
#define	MAX_BUFFER   10

Typedefs
typedef struct ENTRY	ENTRY

Functions
static void	TestEntry (const ENTRY *pEntry)
	START_TEST (MultiByteToWideChar)

Variables
static ULONG	OsVersion
static const char	UTF8_Japanese [] = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E"
static const char	SJIS_Japanese [] = "\x93\xFA\x96\x7B\x8C\xEA"
static const ENTRY	Entries []

Macro Definition Documentation

CP932

#define CP932   932 /* Japanese Shift_JIS (SJIS) codepage */

Definition at line 16 of file MultiByteToWideChar.c.

MAX_BUFFER

#define MAX_BUFFER   10

Definition at line 23 of file MultiByteToWideChar.c.

Typedef Documentation

ENTRY

typedef struct ENTRY ENTRY

Function Documentation

START_TEST()

START_TEST

(

MultiByteToWideChar

)

Definition at line 295 of file MultiByteToWideChar.c.

{
    RTL_OSVERSIONINFOW vi;
    size_t i;

    vi.dwOSVersionInfoSize = sizeof(vi);
    if (RtlGetVersion(&vi) < 0)
    {
        skip("Failed to get OS version!\n");
        return;
    }

    OsVersion = (vi.dwMajorVersion << 8) | vi.dwMinorVersion;

    /* NOTE: We use Win10's MultiByteToWideChar behaviour due to security reason. */
    if (IsReactOS())
        OsVersion = 0xa00;

    for (i = 0; i < _countof(Entries); ++i)
    {
        TestEntry(&Entries[i]);
    }
}

TestEntry()

static void TestEntry ( const ENTRY *  pEntry )

static

Definition at line 226 of file MultiByteToWideChar.c.

{
    int ret, i;
    WCHAR Buffer[MAX_BUFFER];
    DWORD Error;

    if ((OsVersion < pEntry->VersionRange[0]) ||
        (OsVersion > pEntry->VersionRange[1]))
    {
        skip("Skipping entry from line %u (Version range %lx-%lx, current %lx)\n",
             pEntry->LineNo,
             pEntry->VersionRange[0],
             pEntry->VersionRange[1],
             OsVersion);
        return;
    }

    FillMemory(Buffer, sizeof(Buffer), 0x7F);
    SetLastError(0xBEAF);

    if (pEntry->DestLen == 0)
    {
        /* dest is NULL */
        ret = MultiByteToWideChar(pEntry->CodePage, pEntry->Flags, pEntry->Src,
                                  pEntry->SrcLen, NULL, 0);
    }
    else
    {
        ok(pEntry->DestLen >= pEntry->CheckLen - 1,
           "Line %d: DestLen was shorter than (CheckLen - 1)\n", pEntry->LineNo);

        if (pEntry->SamePointer)
        {
            /* src ptr == dest ptr */
            ret = MultiByteToWideChar(pEntry->CodePage, pEntry->Flags,
                                      (const char *)Buffer, pEntry->SrcLen,
                                      Buffer, pEntry->DestLen);
        }
        else
        {
            /* src ptr != dest ptr */
            ret = MultiByteToWideChar(pEntry->CodePage, pEntry->Flags,
                                      pEntry->Src, pEntry->SrcLen,
                                      Buffer, pEntry->DestLen);
        }
    }

    Error = GetLastError();

    /* check ret */
    ok(ret == pEntry->Return, "Line %d: ret expected %d, got %d\n",
       pEntry->LineNo, pEntry->Return, ret);

    /* check error code */
    ok(Error == pEntry->Error,
       "Line %d: Wrong last error. Expected %lu, got %lu\n",
       pEntry->LineNo, pEntry->Error, Error);

    if (pEntry->DestLen)
    {
        /* check buffer */
        for (i = 0; i < pEntry->CheckLen; ++i)
        {
            ok(Buffer[i] == pEntry->CheckDest[i], "Line %d: Buffer[%d] expected %d, got %d\n",
               pEntry->LineNo, i, pEntry->CheckDest[i], Buffer[i]);
        }
    }
}

Referenced by DriverEntry(), DriverIoControl(), FindTest(), ListTests(), and START_TEST().

Variable Documentation

Entries

const ENTRY Entries[]

static

Definition at line 42 of file MultiByteToWideChar.c.

Referenced by START_TEST().

OsVersion

ULONG OsVersion

static

Definition at line 12 of file MultiByteToWideChar.c.

Referenced by START_TEST(), and TestEntry().

SJIS_Japanese

const char SJIS_Japanese[] = "\x93\xFA\x96\x7B\x8C\xEA"

static

Definition at line 21 of file MultiByteToWideChar.c.

UTF8_Japanese

const char UTF8_Japanese[] = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E"

static

Definition at line 19 of file MultiByteToWideChar.c.