mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1576 lines
48 KiB
1576 lines
48 KiB
/*++
|
|
|
|
Copyright (c) 1991-1996, Microsoft Corporation All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
mbtest.c
|
|
|
|
Abstract:
|
|
|
|
Test module for NLS API MultiByteToWideChar.
|
|
|
|
NOTE: This code was simply hacked together quickly in order to
|
|
test the different code modules of the NLS component.
|
|
This is NOT meant to be a formal regression test.
|
|
|
|
Revision History:
|
|
|
|
06-14-91 JulieB Created.
|
|
|
|
--*/
|
|
|
|
|
|
|
|
//
|
|
// Include Files.
|
|
//
|
|
|
|
#include "nlstest.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Constant Declarations.
|
|
//
|
|
|
|
#define BUFSIZE 50 // buffer size in chars
|
|
#define MB_INVALID_FLAGS ((DWORD)(~(MB_PRECOMPOSED | MB_COMPOSITE)))
|
|
|
|
|
|
|
|
|
|
//
|
|
// Global Variables.
|
|
//
|
|
|
|
#define mbMBStr "This Is A String."
|
|
|
|
BYTE mbMBStr2[] = "This Is A String."; // this could get overwritten
|
|
|
|
#define wcMBStr L"This Is A String."
|
|
|
|
WCHAR wcMBDest[BUFSIZE];
|
|
|
|
|
|
|
|
|
|
//
|
|
// Forward Declarations.
|
|
//
|
|
|
|
int
|
|
MB_BadParamCheck();
|
|
|
|
int
|
|
MB_NormalCase();
|
|
|
|
int
|
|
MB_TestFlags();
|
|
|
|
int
|
|
MB_TestDBCS();
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// TestMBToWC
|
|
//
|
|
// Test routine for MultiByteToWideChar API.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TestMBToWC()
|
|
{
|
|
int ErrCount = 0; // error count
|
|
|
|
|
|
//
|
|
// Print out what's being done.
|
|
//
|
|
printf("\n\nTESTING MultiByteToWideChar...\n\n");
|
|
|
|
//
|
|
// Test bad parameters.
|
|
//
|
|
ErrCount += MB_BadParamCheck();
|
|
|
|
//
|
|
// Test normal cases.
|
|
//
|
|
ErrCount += MB_NormalCase();
|
|
|
|
//
|
|
// Test flags.
|
|
//
|
|
ErrCount += MB_TestFlags();
|
|
|
|
//
|
|
// Test DBCS.
|
|
//
|
|
ErrCount += MB_TestDBCS();
|
|
|
|
//
|
|
// Print out result.
|
|
//
|
|
printf("\nMultiByteToWideChar: ERRORS = %d\n", ErrCount);
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (ErrCount);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MB_BadParamCheck
|
|
//
|
|
// This routine passes in bad parameters to the API routine and checks to
|
|
// be sure they are handled properly. The number of errors encountered
|
|
// is returned to the caller.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int MB_BadParamCheck()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
|
|
|
|
//
|
|
// Null Pointers and Equal Pointers.
|
|
//
|
|
|
|
// Variation 1 - lpMultiByteStr = NULL
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
NULL,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"lpMultiByteStr NULL",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - lpWideCharStr = NULL
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"lpWideCharStr NULL",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - equal pointers
|
|
rc = MultiByteToWideChar( 1252,
|
|
0,
|
|
mbMBStr2,
|
|
-1,
|
|
(LPWSTR)mbMBStr2,
|
|
sizeof(mbMBStr2) / sizeof(WCHAR) );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"equal pointers",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Negative or Zero Lengths.
|
|
//
|
|
|
|
// Variation 1 - cchMultiByte = 0
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
0,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"cchMultiByte zero",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cchWideChar = negative
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
-1 );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"cchWideChar zero",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Invalid Code Page.
|
|
//
|
|
|
|
// Variation 1 - CodePage = invalid
|
|
rc = MultiByteToWideChar( 5,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"CodePage invalid",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 2 - CodePage = invalid
|
|
rc = MultiByteToWideChar( 65002,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"CodePage invalid 2",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Zero or Invalid Flag Values.
|
|
//
|
|
|
|
// Variation 1 - wFlags = 0
|
|
rc = MultiByteToWideChar( 1252,
|
|
0,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"wFlags zero",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - wFlags = invalid
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_INVALID_FLAGS,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"wFlags invalid",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - precomp | comp
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED | MB_COMPOSITE,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"precomp | comp",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Buffer Too Small.
|
|
//
|
|
|
|
// Variation 1 - cchWideChar = too small
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
2 );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INSUFFICIENT_BUFFER,
|
|
"cchWideChar too small",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// No Unicode Translation - using MB_ERR_INVALID_CHARS flag.
|
|
//
|
|
|
|
#if 0
|
|
// Variation 1 - cp 875
|
|
rc = MultiByteToWideChar( 875,
|
|
MB_ERR_INVALID_CHARS,
|
|
"fa\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (875)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cp 875
|
|
rc = MultiByteToWideChar( 875,
|
|
MB_ERR_INVALID_CHARS,
|
|
"\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (875) 2",
|
|
&NumErrors );
|
|
#endif
|
|
|
|
// Variation 3 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS,
|
|
"fa\xd5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (857)",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS,
|
|
"\xd5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (857) 2",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS,
|
|
"fa\xd5t",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (857) 3",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 6 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE,
|
|
"\xd5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite flag (857)",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 7 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE,
|
|
"fa\xd5t",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite flag (857) 2",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 8 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE | MB_USEGLYPHCHARS,
|
|
"\xd5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite/glyph flag (857)",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 9 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE | MB_USEGLYPHCHARS,
|
|
"fa\xd5t",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite/glyph flag (857) 2",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 10 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_USEGLYPHCHARS,
|
|
"\xd5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/glyph flag (857)",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 10 - cp 857
|
|
rc = MultiByteToWideChar( 857,
|
|
MB_ERR_INVALID_CHARS | MB_USEGLYPHCHARS,
|
|
"fa\xd5t",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/glyph flag (857) 2",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// DBCS - No Unicode Translation - using MB_ERR_INVALID_CHARS flag.
|
|
//
|
|
|
|
// Variation 1 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS,
|
|
"\x81\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (932)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS,
|
|
"\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (932) 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE,
|
|
"\x81\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char flag (932) 3",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE,
|
|
"\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite flag (932)",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE | MB_USEGLYPHCHARS,
|
|
"\x81\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite/glyph flag (932)",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_COMPOSITE | MB_USEGLYPHCHARS,
|
|
"\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/composite/glyph flag (932) 2",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_USEGLYPHCHARS,
|
|
"\x81\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/glyph flag (932)",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - cp 932
|
|
rc = MultiByteToWideChar( 932,
|
|
MB_ERR_INVALID_CHARS | MB_USEGLYPHCHARS,
|
|
"\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_NO_UNICODE_TRANSLATION,
|
|
"invalid char/glyph flag (932) 2",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MB_NormalCase
|
|
//
|
|
// This routine tests the normal cases of the API routine.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int MB_NormalCase()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
BYTE Ch; // buffer for one character
|
|
WCHAR CheckBuf; // return buffer for one character
|
|
LPWSTR pBogus = NULL; // bogus, uninitialized pointer
|
|
|
|
|
|
#ifdef PERF
|
|
|
|
DbgBreakPoint();
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// cchWideChar.
|
|
//
|
|
|
|
// Variation 1 - cchWideChar = length of wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"cchWideChar (length)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cchWideChar = 0
|
|
wcMBDest[0] = 0x0005;
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"cchWideChar zero",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - cchWideChar = 0, wcMBDest = NULL
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"cchWideChar (NULL ptr)",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cchWideChar = 0, wcMBDest = uninitialized ptr
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
pBogus,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"cchWideChar (bogus ptr)",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// cchMultiByte.
|
|
//
|
|
|
|
// Variation 1 - cchMultiByte = length of mbMBStr
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
MB_STRING_LEN(mbMBStr),
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
WC_STRING_LEN(wcMBStr),
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"cchMultiByte (length)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cchMultiByte = -1
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"cchMultiByte (-1)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - cchMultiByte = length of mbMBStr, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
MB_STRING_LEN(mbMBStr),
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
WC_STRING_LEN(wcMBStr),
|
|
NULL,
|
|
wcMBStr,
|
|
"cchMultiByte (length), no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cchMultiByte = -1, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"cchMultiByte (-1), no wcMBDest",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// CodePage.
|
|
//
|
|
|
|
// Variation 1 - CodePage = CP_ACP
|
|
rc = MultiByteToWideChar( CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage CP_ACP",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - CodePage = CP_ACP, no wcMBDest
|
|
rc = MultiByteToWideChar( CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage CP_ACP, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - CodePage = CP_OEMCP
|
|
rc = MultiByteToWideChar( CP_OEMCP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage CP_OEMCP",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - CodePage = CP_OEMCP, no wcMBDest
|
|
rc = MultiByteToWideChar( CP_OEMCP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage CP_OEMCP, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - CodePage = CP_MACCP
|
|
rc = MultiByteToWideChar( CP_MACCP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage CP_MACCP",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - CodePage = CP_MACCP, no wcMBDest
|
|
rc = MultiByteToWideChar( CP_MACCP,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage CP_MACCP, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
|
|
// Variation 7 - CodePage = 437
|
|
rc = MultiByteToWideChar( 437,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage 437",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - CodePage = 437, no wcMBDest
|
|
rc = MultiByteToWideChar( 437,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage 437, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 9 - CodePage = 850
|
|
rc = MultiByteToWideChar( 850,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage 850",
|
|
&NumErrors );
|
|
|
|
// Variation 10 - CodePage = 850, no wcMBDest
|
|
rc = MultiByteToWideChar( 850,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage 850, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 11 - CodePage = 10000
|
|
rc = MultiByteToWideChar( 10000,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"CodePage 10000",
|
|
&NumErrors );
|
|
|
|
// Variation 12 - CodePage = 10000, no wcMBDest
|
|
rc = MultiByteToWideChar( 10000,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"CodePage 10000, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// UTF 7.
|
|
//
|
|
|
|
// Variation 1 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x55\x78\x64\x4f\x72\x41\x2d", // +UxdOrA-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x5317\x4eac",
|
|
"CodePage CP_UTF7 - 1",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7, // +Ti1XC2b4Xpc-
|
|
0,
|
|
"\x2b\x54\x69\x31\x58\x43\x32\x62\x34\x58\x70\x63\x2d",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x4e2d\x570b\x66f8\x5e97",
|
|
"CodePage CP_UTF7 - 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x41\x44\x73\x2d", // +ADs-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x003b",
|
|
"CodePage CP_UTF7 - 3",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7, // +XrdxmVtXUXg-
|
|
0,
|
|
"\x2b\x58\x72\x64\x78\x6d\x56\x74\x58\x55\x58\x67\x2d",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x5eb7\x7199\x5b57\x5178",
|
|
"CodePage CP_UTF7 - 4",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7, // +TpVPXGBG-
|
|
0,
|
|
"\x2b\x54\x70\x56\x50\x58\x47\x42\x47\x2d",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x4e95\x4f5c\x6046",
|
|
"CodePage CP_UTF7 - 5",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x41\x46\x38\x2d", // +AF8-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x005f",
|
|
"CodePage CP_UTF7 - 6",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x41\x45\x41\x2d", // +AEA-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x0040",
|
|
"CodePage CP_UTF7 - 7",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x2d", // +-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x002b",
|
|
"CodePage CP_UTF7 - 8",
|
|
&NumErrors );
|
|
|
|
// Variation 9 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x41\x2b\x2d", // A+-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x0041\x002b",
|
|
"CodePage CP_UTF7 - 9",
|
|
&NumErrors );
|
|
|
|
// Variation 10 - CodePage = CP_UTF7
|
|
rc = MultiByteToWideChar( CP_UTF7,
|
|
0,
|
|
"\x2b\x41\x45\x41\x2d\x2b\x2d", // +AEA-+-
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x0040\x002b",
|
|
"CodePage CP_UTF7 - 10",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// UTF 8.
|
|
//
|
|
|
|
// Variation 1 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\xe5\x8c\x97\xe4\xba\xac",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x5317\x4eac",
|
|
"CodePage CP_UTF8 - 1",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\xe4\xb8\xad\xe5\x9c\x8b\xe6\x9b\xb8\xe5\xba\x97",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x4e2d\x570b\x66f8\x5e97",
|
|
"CodePage CP_UTF8 - 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\x3b",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x003b",
|
|
"CodePage CP_UTF8 - 3",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\xe5\xba\xb7\xe7\x86\x99\xe5\xad\x97\xe5\x85\xb8",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x5eb7\x7199\x5b57\x5178",
|
|
"CodePage CP_UTF8 - 4",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\xe4\xba\x95\xe4\xbd\x9c\xe6\x81\x86",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x4e95\x4f5c\x6046",
|
|
"CodePage CP_UTF8 - 5",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\x5f",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x005f",
|
|
"CodePage CP_UTF8 - 6",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\x40",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x0040",
|
|
"CodePage CP_UTF8 - 7",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - CodePage = CP_UTF8
|
|
rc = MultiByteToWideChar( CP_UTF8,
|
|
0,
|
|
"\x2b",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x002b",
|
|
"CodePage CP_UTF8 - 8",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Check 0xb3 by itself (to make sure not sign extended).
|
|
//
|
|
Ch = (BYTE)0xb3;
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
&Ch,
|
|
1,
|
|
&CheckBuf,
|
|
1 );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
&CheckBuf,
|
|
L"\x00b3",
|
|
"Check Buffer",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MB_TestFlags
|
|
//
|
|
// This routine tests the different flags of the API routine.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int MB_TestFlags()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
BYTE Ch; // buffer for one character
|
|
WCHAR CheckBuf; // return buffer for one character
|
|
|
|
|
|
//
|
|
// MB_PRECOMPOSED flag.
|
|
//
|
|
|
|
// Variation 1 - normal
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"MB_PRECOMPOSED",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - normal, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"MB_PRECOMPOSED, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - normal
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
"\x6e\x7e",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x006e\x007e",
|
|
"MB_PRECOMPOSED (n tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - normal, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_PRECOMPOSED,
|
|
"\x6e\x7e",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x006e\x007e",
|
|
"MB_PRECOMPOSED (n tilde), no wcMBDest",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// MB_COMPOSITE flag.
|
|
//
|
|
|
|
// Variation 1 - normal
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_COMPOSITE,
|
|
mbMBStr,
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
wcMBStr,
|
|
"MB_COMPOSITE",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - normal, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_COMPOSITE,
|
|
mbMBStr,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
wcMBStr,
|
|
"MB_COMPOSITE, no wcMBDest",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - normal
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_COMPOSITE,
|
|
"\xfc\xf5",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x0075\x0308\x006f\x0303",
|
|
"MB_COMPOSITE (u diaeresis, o tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - normal, no wcMBDest
|
|
rc = MultiByteToWideChar( 1252,
|
|
MB_COMPOSITE,
|
|
"\xfc\xf5",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x0075\x0308\x006f\x0303",
|
|
"MB_COMPOSITE (u diaeresis, o tilde), no wcMBDest",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// MB_USEGLYPHCHARS flag.
|
|
//
|
|
|
|
// Variation 1 - Use Glyph
|
|
Ch = (BYTE)0x0D;
|
|
CheckBuf = (WCHAR)0;
|
|
rc = MultiByteToWideChar( 437,
|
|
MB_USEGLYPHCHARS,
|
|
&Ch,
|
|
1,
|
|
&CheckBuf,
|
|
1 );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
&CheckBuf,
|
|
L"\x266a",
|
|
"Use Glyph",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - Do NOT Use Glyph
|
|
Ch = (BYTE)0x0D;
|
|
CheckBuf = (WCHAR)0;
|
|
rc = MultiByteToWideChar( 437,
|
|
0,
|
|
&Ch,
|
|
1,
|
|
&CheckBuf,
|
|
1 );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
&CheckBuf,
|
|
L"\x000d",
|
|
"Do NOT Use Glyph",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - Use Glyph, Composite
|
|
Ch = (BYTE)0x0D;
|
|
CheckBuf = (WCHAR)0;
|
|
rc = MultiByteToWideChar( 437,
|
|
MB_USEGLYPHCHARS | MB_COMPOSITE,
|
|
&Ch,
|
|
1,
|
|
&CheckBuf,
|
|
1 );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
&CheckBuf,
|
|
L"\x266a",
|
|
"Use Glyph, Composite",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - Do NOT Use Glyph, Composite
|
|
Ch = (BYTE)0x0D;
|
|
CheckBuf = (WCHAR)0;
|
|
rc = MultiByteToWideChar( 437,
|
|
MB_COMPOSITE,
|
|
&Ch,
|
|
1,
|
|
&CheckBuf,
|
|
1 );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
&CheckBuf,
|
|
L"\x000d",
|
|
"Do NOT Use Glyph, Composite",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MB_TestDBCS
|
|
//
|
|
// This routine tests the DBCS code of the API routine.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int MB_TestDBCS()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
|
|
|
|
//
|
|
// No trail byte with lead byte.
|
|
//
|
|
|
|
// Variation 1 - 1 char
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
wcMBDest,
|
|
L"\x0000",
|
|
"no trail byte 1 char",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - 1 char
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81",
|
|
1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
1,
|
|
wcMBDest,
|
|
L"\x0000",
|
|
"no trail byte 1 char 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - 2 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\xdf\x81",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\xff9f",
|
|
"no trail byte 2 chars",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - 2 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\xdf\x81",
|
|
2,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\xff9f",
|
|
"no trail byte 2 chars 2",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Invalid trail byte with lead byte.
|
|
//
|
|
|
|
// Variation 1 - 2 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81\x30",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x30fb",
|
|
"invalid trail byte 2 chars",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - 3 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81\x30\xdf",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x30fb\xff9f",
|
|
"invalid trail byte 3 chars",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Valid Double byte string.
|
|
//
|
|
|
|
// Variation 1 - 2 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81\x40",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x3000",
|
|
"valid trail byte 2 chars",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - 3 chars
|
|
wcMBDest[0] = 0;
|
|
rc = MultiByteToWideChar( 932,
|
|
0,
|
|
"\x81\x40\xdf",
|
|
-1,
|
|
wcMBDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
wcMBDest,
|
|
L"\x3000\xff9f",
|
|
"valid trail byte 3 chars",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|