2117 lines
68 KiB
C
2117 lines
68 KiB
C
/*++
|
|
|
|
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);
|
|
|
|
}
|