|
|
/*++
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.
//
intMB_BadParamCheck();
intMB_NormalCase();
intMB_TestFlags();
intMB_TestDBCS();
intDoUTF7FunctionTests();
////////////////////////////////////////////////////////////////////////////
//
// 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);
}
|
