1271 lines
35 KiB
C
1271 lines
35 KiB
C
/*++
|
|
|
|
Copyright (c) 1991-1999, Microsoft Corporation All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
fstest.c
|
|
|
|
Abstract:
|
|
|
|
Test module for NLS API FoldString.
|
|
|
|
NOTE: This code was simply hacked together quickly in order to
|
|
test the different code modules of the NLS component.
|
|
This is NOT meant to be a formal regression test.
|
|
|
|
Revision History:
|
|
|
|
06-14-91 JulieB Created.
|
|
|
|
--*/
|
|
|
|
|
|
|
|
//
|
|
// Include Files.
|
|
//
|
|
|
|
#include "nlstest.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Constant Declarations.
|
|
//
|
|
|
|
#define BUFSIZE 50
|
|
#define FS_INVALID_FLAGS ((DWORD)(~(MAP_FOLDCZONE | MAP_PRECOMPOSED | \
|
|
MAP_COMPOSITE | MAP_FOLDDIGITS)))
|
|
|
|
|
|
|
|
|
|
//
|
|
// Global Variables.
|
|
//
|
|
|
|
#define FoldSrc1 L"This Is A String"
|
|
|
|
#define FoldSrc2 L"This Is$ A Str,ing"
|
|
|
|
|
|
WCHAR FoldDest[BUFSIZE];
|
|
|
|
|
|
#define wcMultiComp L"\x0065\x0301\x0300"
|
|
|
|
#define wcCompDigitCZone L"\x0065\x0301\x0300\x00b2\xfe64"
|
|
#define wcFoldCompDigitCZone L"\x00e9\x0300\x0032\x003c"
|
|
|
|
#define wcPrecompDigitCZone L"\x00e9\x0300\x00b2\xfe64"
|
|
#define wcFoldPreDigitCZone L"\x0065\x0301\x0300\x0032\x003c"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Forward Declarations.
|
|
//
|
|
|
|
BOOL
|
|
InitFoldStr();
|
|
|
|
int
|
|
FS_BadParamCheck();
|
|
|
|
int
|
|
FS_NormalCase();
|
|
|
|
int
|
|
FS_Ansi();
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// TestFoldString
|
|
//
|
|
// Test routine for FoldStringW API.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TestFoldString()
|
|
{
|
|
int ErrCount = 0; // error count
|
|
|
|
|
|
//
|
|
// Print out what's being done.
|
|
//
|
|
printf("\n\nTESTING FoldStringW...\n\n");
|
|
|
|
//
|
|
// Initialize global variables.
|
|
//
|
|
if (!InitFoldStr())
|
|
{
|
|
printf("\nABORTED TestFoldString: Could not Initialize.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Test bad parameters.
|
|
//
|
|
ErrCount += FS_BadParamCheck();
|
|
|
|
//
|
|
// Test normal cases.
|
|
//
|
|
ErrCount += FS_NormalCase();
|
|
|
|
//
|
|
// Test Ansi version.
|
|
//
|
|
ErrCount += FS_Ansi();
|
|
|
|
//
|
|
// Print out result.
|
|
//
|
|
printf("\nFoldStringW: ERRORS = %d\n", ErrCount);
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (ErrCount);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// InitFoldStr
|
|
//
|
|
// This routine initializes the global variables. If no errors were
|
|
// encountered, then it returns TRUE. Otherwise, it returns FALSE.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL InitFoldStr()
|
|
{
|
|
//
|
|
// Return success.
|
|
//
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// FS_BadParamCheck
|
|
//
|
|
// This routine passes in bad parameters to the API routines 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 FS_BadParamCheck()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
|
|
|
|
//
|
|
// Null Pointers.
|
|
//
|
|
|
|
// Variation 1 - lpSrcStr = NULL
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
NULL,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"lpSrcStr NULL",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - lpDestStr = NULL
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
FoldSrc1,
|
|
-1,
|
|
NULL,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"lpDestStr NULL",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Bad Counts.
|
|
//
|
|
|
|
// Variation 1 - cbSrc = 0
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
FoldSrc1,
|
|
0,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"cbSrc = 0",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cbDest < 0
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
-1 );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"cbDest < 0",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Zero or Invalid Flag Values.
|
|
//
|
|
|
|
// Variation 1 - dwMapFlags = invalid
|
|
rc = FoldStringW( FS_INVALID_FLAGS,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"dwMapFlags invalid",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - dwMapFlags = 0
|
|
rc = FoldStringW( 0,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"dwMapFlags zero",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - illegal combo comp
|
|
rc = FoldStringW( MAP_PRECOMPOSED | MAP_COMPOSITE,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"illegal combo comp",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - illegal combo ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_COMPOSITE,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"illegal combo ligatures and comp",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - illegal combo ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_FLAGS,
|
|
"illegal combo ligatures and precomp",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Same Buffer Check.
|
|
//
|
|
|
|
// Variation 1 - same buffer
|
|
FoldDest[0] = 0;
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
FoldDest,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INVALID_PARAMETER,
|
|
"same buffer",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Insufficient Buffer Check.
|
|
//
|
|
|
|
// Variation 1 - insufficient buffer
|
|
FoldDest[0] = 0;
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
-1,
|
|
FoldDest,
|
|
2 );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INSUFFICIENT_BUFFER,
|
|
"insufficient buffer",
|
|
&NumErrors );
|
|
|
|
FoldDest[0] = 0;
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
1,
|
|
FoldDest,
|
|
1 );
|
|
CheckReturnBadParam( rc,
|
|
0,
|
|
ERROR_INSUFFICIENT_BUFFER,
|
|
"insufficient buffer 2",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// FS_NormalCase
|
|
//
|
|
// This routine tests the normal cases of the API routine.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int FS_NormalCase()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
|
|
|
|
#ifdef PERF
|
|
|
|
DbgBreakPoint();
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// cbDest = 0.
|
|
//
|
|
|
|
// Variation 1 - cbSrc = -1
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
FoldSrc1,
|
|
"cbDest (0) cbSrc (-1)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cbSrc = value
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
WC_STRING_LEN_NULL(FoldSrc1),
|
|
FoldDest,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
FoldSrc1,
|
|
"cbDest (0) cbSrc (value)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - lpDestStr = NULL
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
FoldSrc1,
|
|
"cbDest (0) lpDestStr NULL",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// cbSrc.
|
|
//
|
|
|
|
// Variation 1 - cbSrc = -1
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
FoldSrc1,
|
|
"cbSrc (-1)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cbSrc = value
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
WC_STRING_LEN(FoldSrc1),
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
WC_STRING_LEN(FoldSrc1),
|
|
FoldDest,
|
|
FoldSrc1,
|
|
"cbSrc (value)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - cbSrc = -1, no DestStr
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
FoldSrc1,
|
|
"cbSrc (-1), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cbSrc = value, no DestStr
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc1,
|
|
WC_STRING_LEN(FoldSrc1),
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
WC_STRING_LEN(FoldSrc1),
|
|
NULL,
|
|
FoldSrc1,
|
|
"cbSrc (value), no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// MAP_PRECOMPOSED Flag.
|
|
//
|
|
|
|
// Variation 1 - precomposed
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
FoldSrc2,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
FoldSrc2,
|
|
"precomposed",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - precomposed
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
L"\x006e\x0303",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x00f1",
|
|
"precomposed (n tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - precomposed
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
L"\x006e\x0303",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x00f1",
|
|
"precomposed (n tilde), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - precomposed
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
L"\x0062\x0303",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0062\x0303",
|
|
"precomposed (b tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - precomposed
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
L"\x0062\x0303",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x0062\x0303",
|
|
"precomposed (b tilde), no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// MAP_COMPOSITE Flag.
|
|
//
|
|
|
|
// Variation 1 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
FoldSrc2,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
FoldSrc2,
|
|
"composite",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x00f1",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x006e\x0303",
|
|
"composite (n tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x00f1",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x006e\x0303",
|
|
"composite (n tilde), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x01c4",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0044\x017d",
|
|
"composite (dz hacek)",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x01c4",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x0044\x017d",
|
|
"composite (dz hacek), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x0062\x0303",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0062\x0303",
|
|
"composite (b tilde)",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x0062\x0303",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x0062\x0303",
|
|
"composite (b tilde), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - composite
|
|
rc = FoldStringW( MAP_COMPOSITE,
|
|
L"\x304c",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x304b\xff9e",
|
|
"composite (hiragana Ga)",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// MAP_FOLDCZONE Flag.
|
|
//
|
|
|
|
// Variation 1 - fold compatibility zone
|
|
rc = FoldStringW( MAP_FOLDCZONE,
|
|
FoldSrc2,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
FoldSrc2,
|
|
"fold czone",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - fold compatibility zone
|
|
rc = FoldStringW( MAP_FOLDCZONE,
|
|
L"\x004a\xff24\xff22",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x004a\x0044\x0042",
|
|
"fold czone (JDB)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - fold compatibility zone
|
|
rc = FoldStringW( MAP_FOLDCZONE,
|
|
L"\x004a\xff24\xff22",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x004a\x0044\x0042",
|
|
"fold czone (JDB), no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// MAP_FOLDDIGITS Flag.
|
|
//
|
|
|
|
// Variation 1 - fold digits
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
FoldSrc2,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
FoldSrc2,
|
|
"fold digits",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - fold digits
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
L"\x00b2\x00b3",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0032\x0033",
|
|
"fold digits (23)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - fold digits
|
|
rc = FoldStringW( MAP_FOLDDIGITS,
|
|
L"\x00b2\x00b3",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"\x0032\x0033",
|
|
"fold digits (23), no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Check precomposed with multiple diacritics.
|
|
//
|
|
// Variation 1 - precomp, multi diacritics
|
|
rc = FoldStringW( MAP_PRECOMPOSED,
|
|
wcMultiComp,
|
|
3,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
2,
|
|
FoldDest,
|
|
L"\x00e9\x0300",
|
|
"precomp, multi diacritics",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - precomp, czone
|
|
rc = FoldStringW( MAP_PRECOMPOSED | MAP_FOLDCZONE,
|
|
wcCompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x00e9\x0300\x00b2\x003c",
|
|
"precomp, czone",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - precomp, digits
|
|
rc = FoldStringW( MAP_PRECOMPOSED | MAP_FOLDDIGITS,
|
|
wcCompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x00e9\x0300\x0032\xfe64",
|
|
"precomp, digits",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - precomp, czone, digits
|
|
rc = FoldStringW( MAP_PRECOMPOSED | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
wcCompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x00e9\x0300\x0032\x003c",
|
|
"precomp, czone, digits",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Check composite.
|
|
//
|
|
|
|
// Variation 1 - comp, czone
|
|
rc = FoldStringW( MAP_COMPOSITE | MAP_FOLDCZONE,
|
|
wcPrecompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0065\x0301\x0300\x00b2\x003c",
|
|
"comp, czone",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - comp, digits
|
|
rc = FoldStringW( MAP_COMPOSITE | MAP_FOLDDIGITS,
|
|
wcPrecompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0065\x0301\x0300\x0032\xfe64",
|
|
"comp, digits",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - comp, czone, digits
|
|
rc = FoldStringW( MAP_COMPOSITE | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
wcPrecompDigitCZone,
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"\x0065\x0301\x0300\x0032\x003c",
|
|
"comp, czone, digits",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// MAP_EXPAND_LIGATURES Flag.
|
|
//
|
|
|
|
// Variation 1 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"abc",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"abc",
|
|
"expand ligatures 1",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"ae",
|
|
"expand ligatures 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
-1,
|
|
FoldDest,
|
|
3 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"ae",
|
|
"expand ligatures 3",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
1,
|
|
FoldDest,
|
|
2 );
|
|
CheckReturnValidW( rc,
|
|
2,
|
|
FoldDest,
|
|
L"ae",
|
|
"expand ligatures 4",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\x00e6",
|
|
1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
2,
|
|
NULL,
|
|
L"ae",
|
|
"expand ligatures 5 - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE,
|
|
L"\x00e6\xff26",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"aeF",
|
|
"expand ligatures 6 - lig & czone",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE,
|
|
L"\x00e6\xff26",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"aeF",
|
|
"expand ligatures 7 - lig & czone - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS,
|
|
L"\x00e6\x0660",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"ae0",
|
|
"expand ligatures 8 - lig & digits",
|
|
&NumErrors );
|
|
|
|
// Variation 9 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS,
|
|
L"\x00e6\x0660",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"ae0",
|
|
"expand ligatures 9 - lig & digits - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 10 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
L"\x00e6\xff26\x0660",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"aeF0",
|
|
"expand ligatures 10 - lig, czone, & digits",
|
|
&NumErrors );
|
|
|
|
// Variation 11 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
L"\x00e6\xff26\x0660",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"aeF0",
|
|
"expand ligatures 11 - lig, czone, & digits - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 12 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\xfb03",
|
|
-1,
|
|
FoldDest,
|
|
BUFSIZE );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
FoldDest,
|
|
L"ffi",
|
|
"expand ligatures 12",
|
|
&NumErrors );
|
|
|
|
// Variation 13 - expand ligatures
|
|
rc = FoldStringW( MAP_EXPAND_LIGATURES,
|
|
L"\xfb03",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidW( rc,
|
|
-1,
|
|
NULL,
|
|
L"ffi",
|
|
"expand ligatures 13",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// FS_Ansi
|
|
//
|
|
// This routine tests the Ansi version of the API routine.
|
|
//
|
|
// 06-14-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int FS_Ansi()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
BYTE pFoldDestA[BUFSIZE]; // ptr to buffer
|
|
|
|
|
|
//
|
|
// FoldStringA.
|
|
//
|
|
|
|
// Variation 1 - cbSrc = -1
|
|
rc = FoldStringA( MAP_PRECOMPOSED,
|
|
"AbCd",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"AbCd",
|
|
NULL,
|
|
"A version cbSrc (-1)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - cbSrc = value
|
|
rc = FoldStringA( MAP_PRECOMPOSED,
|
|
"AbCd",
|
|
4,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
4,
|
|
pFoldDestA,
|
|
"AbCd",
|
|
NULL,
|
|
"A version cbSrc (value)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - cbSrc = -1, no DestStr
|
|
rc = FoldStringA( MAP_PRECOMPOSED,
|
|
"AbCd",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
NULL,
|
|
"AbCd",
|
|
NULL,
|
|
"A version cbSrc (-1), no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - cbSrc = value, no DestStr
|
|
rc = FoldStringA( MAP_PRECOMPOSED,
|
|
"AbCd",
|
|
4,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
4,
|
|
NULL,
|
|
"AbCd",
|
|
NULL,
|
|
"A version cbSrc (value), no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// MAP_EXPAND_LIGATURES Flag.
|
|
//
|
|
|
|
// Variation 1 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES,
|
|
"abc",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"abc",
|
|
NULL,
|
|
"A expand ligatures 1",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES,
|
|
"\xe6",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"ae",
|
|
NULL,
|
|
"A expand ligatures 2",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES,
|
|
"\xe6",
|
|
-1,
|
|
pFoldDestA,
|
|
3 );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"ae",
|
|
NULL,
|
|
"A expand ligatures 3",
|
|
&NumErrors );
|
|
|
|
// Variation 4 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES,
|
|
"\xe6",
|
|
1,
|
|
pFoldDestA,
|
|
2 );
|
|
CheckReturnValidA( rc,
|
|
2,
|
|
pFoldDestA,
|
|
"ae",
|
|
NULL,
|
|
"A expand ligatures 4",
|
|
&NumErrors );
|
|
|
|
// Variation 5 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES,
|
|
"\xe6",
|
|
1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
2,
|
|
NULL,
|
|
"ae",
|
|
NULL,
|
|
"A expand ligatures 5 - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 6 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE,
|
|
"\xe6G",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"aeG",
|
|
NULL,
|
|
"A expand ligatures 6 - lig & czone",
|
|
&NumErrors );
|
|
|
|
// Variation 7 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE,
|
|
"\xe6G",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
NULL,
|
|
"aeG",
|
|
NULL,
|
|
"A expand ligatures 7 - lig & czone - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 8 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS,
|
|
"\xe6\xb2",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"ae2",
|
|
NULL,
|
|
"A expand ligatures 8 - lig & digits",
|
|
&NumErrors );
|
|
|
|
// Variation 9 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDDIGITS,
|
|
"\xe6\xb2",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
NULL,
|
|
"ae2",
|
|
NULL,
|
|
"A expand ligatures 9 - lig & digits - no DestStr",
|
|
&NumErrors );
|
|
|
|
// Variation 10 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
"\xe6G\xb2",
|
|
-1,
|
|
pFoldDestA,
|
|
BUFSIZE );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
pFoldDestA,
|
|
"aeG2",
|
|
NULL,
|
|
"A expand ligatures 10 - lig, czone, & digits",
|
|
&NumErrors );
|
|
|
|
// Variation 11 - expand ligatures
|
|
rc = FoldStringA( MAP_EXPAND_LIGATURES | MAP_FOLDCZONE | MAP_FOLDDIGITS,
|
|
"\xe6G\xb2",
|
|
-1,
|
|
NULL,
|
|
0 );
|
|
CheckReturnValidA( rc,
|
|
-1,
|
|
NULL,
|
|
"aeG2",
|
|
NULL,
|
|
"A expand ligatures 11 - lig, czone, & digits - no DestStr",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|