able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/win32/winnls/test/nlstest/mbtest.c

2117 lines
68 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991-1999, 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 1024 // 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();
int
DoUTF7FunctionTests();
////////////////////////////////////////////////////////////////////////////
//
// DoTestMultiByteToWideChar
//
// This routine help to test the MultiByteToWideChar() function.
//
// lpErrorString The title to be printed when the test case fails.
// CodePage The code page for the byte to be converted to Unicode.
// dwFlags The flag to be passed into MultiByteToWideChar()
// lpMultiByteStr
// StartIndex The start index of lpMultiByteStr
// Count The char count of lpMultiByteStr
// bTestNegativeLength Flag to indicate if the test of passing length as -1 should run or not.
// ExpectReturn The expected return value of MultiByteToWideChar().
// If error is expected, the value should be 0.
// lpExpectWdieCharStr The expected conversion result.
// dwExpectError The expecter value of GetLastError(). If no error is expected,
// this value should be 0.
//
// This rountine will test the following cases and verify them with the expected result.
//
// 1. Pass the count of lpMulitByteStr in to MB2WC() to get the expected return
// char count.
// 2. Pass -1 as length of lpMulitByteStr to MB2WC() to get the expected return
// char count.
// 3. Pass the length of lpMulitByteStr in to MB2WC() to get the conversion result.
// 4. Pass -1 as the length of lpMulitByteStr to MB2WC() to get the conversion result.
//
// 04-30-01 YSLin Created.
////////////////////////////////////////////////////////////////////////////
int DoTestMultiByteToWideChar(
LPSTR lpErrorString, UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, UINT StartIndex, UINT Count,
BOOL bTestNegativeLength,
LPWSTR lpWideCharStr, int cchWideChar, int ExpectReturn, LPWSTR lpExpectWideCharStr, DWORD dwExpectError)
{
DWORD dwLastError;
int NumErrors = 0;
CHAR TempString[BUFSIZE];
CHAR ErrorString[BUFSIZE];
// Check the WCHAR count first.
int Result = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr + StartIndex, Count,
NULL, 0);
sprintf(ErrorString, "%s (MultiByteToWideChar(%d, 0x%x, \"%s\", %d, NULL, 0)",
lpErrorString,
CodePage,
dwFlags,
GetAnsiString((LPSTR)lpMultiByteStr + StartIndex, Count),
Count);
if (dwExpectError == 0)
{
CheckReturnValidW( Result,
ExpectReturn,
NULL,
NULL,
ErrorString,
&NumErrors);
} else
{
CheckLastError(dwExpectError, lpErrorString, &NumErrors);
}
if (bTestNegativeLength) {
// Check the WCHAR count first (lenght = -1).
Result = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr + StartIndex, -1, NULL, 0);
sprintf(ErrorString, "%s (MultiByteToWideChar(%d, 0x%x, \"%s\", %d, NULL, 0)",
lpErrorString,
CodePage,
dwFlags,
GetAnsiString((LPSTR)lpMultiByteStr + StartIndex, -1),
-1);
if (dwExpectError == 0)
{
CheckReturnValidW( Result,
ExpectReturn + 1,
NULL,
NULL,
ErrorString,
&NumErrors);
} else
{
CheckLastError(dwExpectError, lpErrorString, &NumErrors);
}
}
// Do the real conversion.
Result = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr + StartIndex, Count,
lpWideCharStr, cchWideChar);
sprintf(ErrorString, "%s (MultiByteToWideChar(%d, 0x%x, \"%s\", %d)",
lpErrorString,
CodePage,
dwFlags,
GetAnsiString((LPSTR)lpMultiByteStr + StartIndex, Count),
Count);
if (dwExpectError == 0)
{
CheckReturnValidW( Result,
ExpectReturn,
lpWideCharStr,
lpExpectWideCharStr,
ErrorString,
&NumErrors);
} else
{
CheckLastError(dwExpectError, lpErrorString, &NumErrors);
}
// Do the real conversion with length -1.
if (bTestNegativeLength)
{
strncpy(TempString, lpMultiByteStr + StartIndex, Count);
TempString[Count] = '\0';
Count = -1;
sprintf(ErrorString, "%s (MultiByteToWideChar(%d, 0x%x, \"%s\", %d)",
lpErrorString,
CodePage,
dwFlags,
GetAnsiString((LPSTR)lpMultiByteStr + StartIndex, Count),
Count);
Result = MultiByteToWideChar(CodePage, dwFlags, TempString, Count,
lpWideCharStr, cchWideChar);
if (dwExpectError == 0)
{
CheckReturnValidW( Result,
ExpectReturn + 1,
lpWideCharStr,
lpExpectWideCharStr,
ErrorString,
&NumErrors);
} else
{
CheckLastError(dwExpectError, lpErrorString, &NumErrors);
}
}
return (NumErrors);
}
//
// 376403 Client RC1 2 Active Fix Ready
// *Improper handling of invalid non-direct codes in UTF-7
//
int Regress376403()
{
int rc;
int NumErrors = 0;
printf("\n ---- Regress 376403 ----\n");
rc = MultiByteToWideChar( CP_UTF7,
0,
"\x80\x81",
-1,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
3,
wcMBDest,
L"\x0080\x0081",
"CodePage CP_UTF7 - Invalid byte input",
&NumErrors );
rc = MultiByteToWideChar( CP_UTF7,
0,
"\x2B\x80\x81\x82\x83\x2D",
-1,
wcMBDest,
BUFSIZE);
CheckReturnValidW( rc,
6,
wcMBDest,
L"\x0080\x0081\x0082\x0083\x002d",
"CodePage CP_UTF7 - Invalid byte input 2",
&NumErrors );
return (NumErrors);
}
//
// 381323 Client RC1 2 Active Fix Ready
// *NLS: bad decoded multibyte sequences after unfinished multibyte sequences in UTF-8
//
int Regress381323()
{
int rc;
int NumErrors = 0;
printf("\n ---- Regress 381323 ----\n");
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Leading byte before end of sequence 1" ,
CP_UTF8, 0, "\xe1\x80\xe1\x80\x80", 0, 5, TRUE, wcMBDest, BUFSIZE, 1, L"\x1000", 0);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Leading byte before end of sequence 2" ,
CP_UTF8, 0, "\xEF\xBF\xEF\xBF\xAE", 0, 5, TRUE, wcMBDest, BUFSIZE, 1, L"\xffee", 0);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Leading byte before end of sequence 3" ,
CP_UTF8, 0, "\xF0\xC4\x80", 0, 3, TRUE, wcMBDest, BUFSIZE, 1, L"\x0100", 0);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Invalid byte - 1",
CP_UTF8, 0, "\xEF\xFF\xEE", 0, 3, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION) ;
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Invalid byte - 2",
CP_UTF8, 0, "\xEF\xFF\xAE", 0, 3, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION) ;
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Invalid byte - 3",
CP_UTF8, 0, "\xEF\xBF\xAE", 0, 3, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION) ;
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Invalid byte - 4",
CP_UTF8, 0, "\xEF\xBF\xC0\xBF", 0, 4, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION) ;
return (NumErrors);
}
//
// 381433 Client RC1 2 Active Fix Ready
// *NLS: disparity decoding invalid (too high) scalar value
//
int Regress381433()
{
int rc;
int NumErrors = 0;
printf("\n ---- Regress 381433 ----\n");
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Too high Unicode scalar value",
CP_UTF8, 0, "\xF4\x90\x80\x80" , 0, 4, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Too high Unicode scalar value",
CP_UTF8, 0, "\xF4\x90\x80\x80\x41\x42\x43" , 0, 7, TRUE, wcMBDest, BUFSIZE, 3, L"ABC", 0);
return (NumErrors);
}
//
// 371215 Client RC1 2 Active Fix Ready
// *NLS: UTF-8 MultiByteToWideChar does should support the MB_ERR_INVALID_BYTES flag
//
int Regress371215()
{
int rc;
int NumErrors = 0;
printf("\n ---- Regress 371215 ----\n");
// Test MB_ERR_INVALID_CHARS flag for UTF8.
// Trailing byte without leading byte.
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 with MB_ERR_INVALID_CHARS - Trailing with leading",
CP_UTF8, MB_ERR_INVALID_CHARS, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Trailing with leading",
CP_UTF8, 0, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
// Leading byte before end of sequence
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 with MB_ERR_INVALID_CHARS - Leading byte before end of sequence 1" ,
CP_UTF8, 0, "\xe1\x80\xe1\x80\x80", 0, 5, TRUE, wcMBDest, BUFSIZE, 1, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 with MB_ERR_INVALID_CHARS - Leading byte before end of sequence 2" ,
CP_UTF8, MB_ERR_INVALID_CHARS, "\xEF\xBF\xEF\xBF\xAE", 0, 5, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 with MB_ERR_INVALID_CHARS - Leading byte before end of sequence 3" ,
CP_UTF8, MB_ERR_INVALID_CHARS, "\xF0\xC4\x80", 0, 3, TRUE, wcMBDest, BUFSIZE, 1, NULL, ERROR_NO_UNICODE_TRANSLATION);
// Too high Unicode value (over U+10FFFF)
NumErrors += DoTestMultiByteToWideChar(
"Test UTF8 - Too high Unicode scalar value with MB_ERR_INVALID_CHARS",
CP_UTF8, MB_ERR_INVALID_CHARS, "\xF4\x90\x80\x80" , 0, 4, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_NO_UNICODE_TRANSLATION);
// Test invalid flags for UTF8.
NumErrors += DoTestMultiByteToWideChar(
"Verify UTF8 will signal error on invalid flags",
CP_UTF8, MB_PRECOMPOSED, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_INVALID_FLAGS);
NumErrors += DoTestMultiByteToWideChar(
"Verify UTF8 will signal error on invalid flags",
CP_UTF8, MB_COMPOSITE, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_INVALID_FLAGS);
NumErrors += DoTestMultiByteToWideChar(
"Verify UTF8 will signal error on invalid flags",
CP_UTF8, MB_USEGLYPHCHARS, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_INVALID_FLAGS);
NumErrors += DoTestMultiByteToWideChar(
"Verify UTF8 will signal error on invalid flags",
CP_UTF8, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_INVALID_FLAGS);
// Test MB_ERR_INVALID_CHARS flag for UTF7.
// Verify that UTF7 does not support this flag.
NumErrors += DoTestMultiByteToWideChar(
"Verify UTF7 does not support MB_ERR_INVALID_CHARS",
CP_UTF7, MB_ERR_INVALID_CHARS, "\x80", 0, 1, TRUE, wcMBDest, BUFSIZE, 0, NULL, ERROR_INVALID_FLAGS);
return (NumErrors);
}
//
//385490 Client RC1 1 Active Fix Ready
//*NLS: broken decoding of correct sequences in UTF-8
//
BOOL Regress385490() {
BOOL bPassed = TRUE;
int NumErrors = 0;
printf("\n ---- Regress 385490 ----\n");
NumErrors += DoTestMultiByteToWideChar(
"Bug 385490 - 1",
CP_UTF8, 0, "\x1f\x10\x00\x09", 0, 4, FALSE, wcMBDest, BUFSIZE, 4, L"\x001f\x0010\x0000\x0009", 0);
NumErrors += DoTestMultiByteToWideChar(
"Bug 385490 - 2 Normal surrogate pair (lowset)",
CP_UTF8, 0, "\xf0\x90\x80\x80", 0, 4, TRUE, wcMBDest, BUFSIZE, 2, L"\xd800\xdc00", 0);
NumErrors += DoTestMultiByteToWideChar(
"Bug 385490 - 3 Normal surrogate pair",
CP_UTF8, 0, "\xf3\xb0\x80\x80", 0, 4, TRUE, wcMBDest, BUFSIZE, 2, L"\xdb80\xdc00", 0);
NumErrors += DoTestMultiByteToWideChar(
"Bug 385490 - 2 Normal surrogate pair (highest)",
CP_UTF8, 0, "\xf4\x8f\xbf\xbf", 0, 4, TRUE, wcMBDest, BUFSIZE, 2, L"\xdbff\xdfff", 0);
return (NumErrors);
}
//
//389547 Client RC1 3 Active
//NLS, UTF-8 , WideCharToMultiBytes() returns wrong value for not finished code sequence
//
BOOL Regress389547() {
int NumErrors = 0;
printf("\n ---- Regress 389547 ----\n");
// 3-byte sequence
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Three byte UTF8",
CP_UTF8, 0, "\xef\xbf\xae", 0, 3, FALSE, wcMBDest, BUFSIZE, 1, L"\xffee", 0);
// Just a trailing byte.
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Trailing byte only",
CP_UTF8, 0, "\xaa", 0, 1, FALSE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
// Unfinished 2 byte sequence
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 2 byte sequence 1",
CP_UTF8, 0, "\xc2", 0, 1, FALSE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 2 byte sequence 2",
CP_UTF8, 0, "\xc2\x41\xc2\x41", 0, 4, FALSE, wcMBDest, BUFSIZE, 2, L"AA", 0);
// Unfinished 3 byte sequence
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 3 byte sequence 1",
CP_UTF8, 0, "\xef\xbf", 0, 2, FALSE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 3 byte sequence 2",
CP_UTF8, 0, "A\xef\xbf", 0, 2, FALSE, wcMBDest, BUFSIZE, 1, L"A", 0);
// Unfinished 4 byte sequence
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 4 byte sequence 1",
CP_UTF8, 0, "\xf0\x90\x80", 0, 3, FALSE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 4 byte sequence 2",
CP_UTF8, 0, "\xf4\x8f\xbf", 0, 3, FALSE, wcMBDest, BUFSIZE, 0, L"", ERROR_NO_UNICODE_TRANSLATION);
NumErrors += DoTestMultiByteToWideChar(
"Bug 389547 - Unfinished 4 byte sequence 3",
CP_UTF8, 0, "\xf4\x8f\xbf\x41", 0, 4, FALSE, wcMBDest, BUFSIZE, 1, L"A", 0);
return (NumErrors);
}
////////////////////////////////////////////////////////////////////////////
//
// 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();
ErrCount += DoUTF7FunctionTests();
ErrCount += Regress376403();
ErrCount += Regress381323();
ErrCount += Regress381433();
ErrCount += Regress371215();
ErrCount += Regress385490();
ErrCount += Regress389547();
//
// 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( 8,
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
LCID Locale; // save the old locale
#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 );
// Variation 13 - CodePage = CP_THREAD_ACP
rc = MultiByteToWideChar( CP_THREAD_ACP,
0,
mbMBStr,
-1,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
-1,
wcMBDest,
wcMBStr,
"CodePage CP_THREAD_ACP",
&NumErrors );
// Variation 14 - CodePage = CP_THREAD_ACP, no wcMBDest
rc = MultiByteToWideChar( CP_THREAD_ACP,
0,
mbMBStr,
-1,
NULL,
0 );
CheckReturnValidW( rc,
-1,
NULL,
wcMBStr,
"CodePage CP_THREAD_ACP, no wcMBDest",
&NumErrors );
// Variation 15 - CodePage = CP_THREAD_ACP
Locale = GetThreadLocale();
SetThreadLocale(0x00000405); // Czech - cp 1250
rc = MultiByteToWideChar( CP_THREAD_ACP,
0,
"\x9d\x9f",
-1,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
-1,
wcMBDest,
L"\x0165\x017a",
"CodePage CP_THREAD_ACP - Czech cp 1250",
&NumErrors );
SetThreadLocale(Locale); // US - cp 1252
rc = MultiByteToWideChar( CP_THREAD_ACP,
0,
"\x9d\x9f",
-1,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
-1,
wcMBDest,
L"\x009d\x0178",
"CodePage CP_THREAD_ACP - US cp 1252",
&NumErrors );
// Variation 16 - CodePage = CP_SYMBOL
rc = MultiByteToWideChar( CP_SYMBOL,
0,
"\x20\x33\xca\x00",
-1,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
-1,
wcMBDest,
L"\xf020\xf033\xf0ca\x0000",
"CodePage CP_SYMBOL",
&NumErrors );
// Variation 17 - CodePage = CP_SYMBOL, no wcMBDest
rc = MultiByteToWideChar( CP_SYMBOL,
0,
"\x20\x33\xca\x00",
-1,
NULL,
0 );
CheckReturnValidW( rc,
-1,
NULL,
L"\xf020\xf033\xf0ca\x0000",
"CodePage CP_SYMBOL, no wcMBDest",
&NumErrors );
// Variation 18 - CodePage = CP_SYMBOL
rc = MultiByteToWideChar( CP_SYMBOL,
0,
"\x20\x33\xca\x00",
5,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
5,
wcMBDest,
L"\xf020\xf033\xf0ca\x0000",
"CodePage CP_SYMBOL, size",
&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 );
// Variation 11 - CodePage = CP_UTF7
rc = MultiByteToWideChar( CP_UTF7,
0,
"\x61\x62\x2b",
3,
wcMBDest,
BUFSIZE );
CheckReturnValidW( rc,
2,
wcMBDest,
L"\x0061\x0062",
"CodePage CP_UTF7 - 11",
&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);
}
int DoUTF7FunctionTests()
{
int NumErrors = 0; // error count - to be returned
printf("\n ---- DoUTF7FunctionTests ----\n");
NumErrors += DoTestMultiByteToWideChar(
"DoUTF7FunctionTests - 1",
CP_UTF7, 0, "\x2B\x41\x43\x45\x41\x66\x51\x2D", 0, 8, TRUE, wcMBDest, BUFSIZE, 2, L"\x0021\x007D", 0);
NumErrors += DoTestMultiByteToWideChar(
"DoUTF7FunctionTests - 2",
CP_UTF7, 0, "\x2B\x44\x6C\x6B\x46\x30\x51\x2D", 0, 8, TRUE, wcMBDest, BUFSIZE, 2, L"\x0E59\x05D1", 0);
//
// Return total number of errors found.
//
return (NumErrors);
}
Reference in a new issue Copy permalink