1446 lines
41 KiB
C
1446 lines
41 KiB
C
/*++
|
|
|
|
Copyright (c) 1991-1999, Microsoft Corporation All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
ecitest.c
|
|
|
|
Abstract:
|
|
|
|
Test module for NLS API EnumCalendarInfo.
|
|
|
|
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:
|
|
|
|
08-02-93 JulieB Created.
|
|
|
|
--*/
|
|
|
|
|
|
|
|
//
|
|
// Include Files.
|
|
//
|
|
|
|
#include "nlstest.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Constant Declarations.
|
|
//
|
|
|
|
#define ECI_INVALID_FLAG 0x00000100
|
|
|
|
|
|
|
|
|
|
//
|
|
// Global Variables.
|
|
//
|
|
|
|
int CalendarCtr;
|
|
|
|
|
|
CALTYPE pCalFlag[] =
|
|
{
|
|
CAL_ICALINTVALUE,
|
|
CAL_SCALNAME,
|
|
CAL_ITWODIGITYEARMAX,
|
|
CAL_IYEAROFFSETRANGE,
|
|
CAL_SERASTRING,
|
|
CAL_SSHORTDATE,
|
|
CAL_SLONGDATE,
|
|
CAL_SYEARMONTH,
|
|
CAL_SDAYNAME1,
|
|
CAL_SMONTHNAME1,
|
|
CAL_SMONTHNAME13
|
|
};
|
|
#define NUM_CAL_FLAGS ( sizeof(pCalFlag) / sizeof(CALTYPE) )
|
|
|
|
|
|
//
|
|
// pCalEnglish and pCalJapan_x must have the same number of entries
|
|
// as pCalFlag.
|
|
//
|
|
int pCalEnglish[] =
|
|
{
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
7,
|
|
4,
|
|
1,
|
|
1,
|
|
1,
|
|
0
|
|
};
|
|
|
|
int pCalJapan_All[] =
|
|
{
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
20,
|
|
14,
|
|
3,
|
|
2,
|
|
2,
|
|
0
|
|
};
|
|
|
|
int pCalJapan_1[] =
|
|
{
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
8,
|
|
4,
|
|
1,
|
|
1,
|
|
1,
|
|
0
|
|
};
|
|
|
|
int pCalJapan_2[] =
|
|
{
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
4,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
0
|
|
};
|
|
|
|
int pCalJapan_3[] =
|
|
{
|
|
1,
|
|
1,
|
|
1,
|
|
4,
|
|
4,
|
|
8,
|
|
8,
|
|
1,
|
|
1,
|
|
1,
|
|
0
|
|
};
|
|
|
|
|
|
|
|
|
|
//
|
|
// Forward Declarations.
|
|
//
|
|
|
|
BOOL
|
|
InitEnumCalendarInfo();
|
|
|
|
int
|
|
ECI_BadParamCheck();
|
|
|
|
int
|
|
ECI_NormalCase();
|
|
|
|
int
|
|
ECI_Ansi();
|
|
|
|
BOOL
|
|
CALLBACK
|
|
MyFuncCalendar(
|
|
LPWSTR pStr);
|
|
|
|
BOOL
|
|
CALLBACK
|
|
MyFuncCalendarA(
|
|
LPSTR pStr);
|
|
|
|
BOOL
|
|
CALLBACK
|
|
MyFuncCalendarEx(
|
|
LPWSTR pStr,
|
|
CALID CalId);
|
|
|
|
BOOL
|
|
CALLBACK
|
|
MyFuncCalendarExA(
|
|
LPSTR pStr,
|
|
CALID CalId);
|
|
|
|
|
|
|
|
|
|
//
|
|
// Callback functions.
|
|
//
|
|
|
|
BOOL CALLBACK MyFuncCalendar(
|
|
LPWSTR pStr)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
while (*pStr)
|
|
{
|
|
printf((*pStr > 0xff) ? "(0x%x)" : "%wc", *pStr);
|
|
pStr++;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
CalendarCtr++;
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
BOOL CALLBACK MyFuncCalendarA(
|
|
LPSTR pStr)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
while (*pStr)
|
|
{
|
|
printf((*pStr > 0xff) ? "(0x%x)" : "%c", *pStr);
|
|
pStr++;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
CalendarCtr++;
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
//
|
|
// Callback functions for EX version.
|
|
//
|
|
|
|
BOOL CALLBACK MyFuncCalendarEx(
|
|
LPWSTR pStr,
|
|
CALID CalId)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
printf("CalId = %d\n", CalId);
|
|
|
|
while (*pStr)
|
|
{
|
|
printf((*pStr > 0xff) ? "(0x%x)" : "%wc", *pStr);
|
|
pStr++;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
CalendarCtr++;
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
BOOL CALLBACK MyFuncCalendarExA(
|
|
LPSTR pStr,
|
|
CALID CalId)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
printf("CalId = %d\n", CalId);
|
|
|
|
while (*pStr)
|
|
{
|
|
printf((*pStr > 0xff) ? "(0x%x)" : "%c", *pStr);
|
|
pStr++;
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
CalendarCtr++;
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// TestEnumCalendarInfo
|
|
//
|
|
// Test routine for EnumCalendarInfoW API.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TestEnumCalendarInfo()
|
|
{
|
|
int ErrCount = 0; // error count
|
|
|
|
|
|
//
|
|
// Print out what's being done.
|
|
//
|
|
printf("\n\nTESTING EnumCalendarInfoW...\n\n");
|
|
|
|
//
|
|
// Initialize global variables.
|
|
//
|
|
if (!InitEnumCalendarInfo())
|
|
{
|
|
printf("\nABORTED TestEnumCalendarInfo: Could not Initialize.\n");
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Test bad parameters.
|
|
//
|
|
ErrCount += ECI_BadParamCheck();
|
|
|
|
//
|
|
// Test normal cases.
|
|
//
|
|
ErrCount += ECI_NormalCase();
|
|
|
|
//
|
|
// Test Ansi version.
|
|
//
|
|
ErrCount += ECI_Ansi();
|
|
|
|
//
|
|
// Print out result.
|
|
//
|
|
printf("\nEnumCalendarInfoW: ERRORS = %d\n", ErrCount);
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (ErrCount);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// InitEnumCalendarInfo
|
|
//
|
|
// This routine initializes the global variables. If no errors were
|
|
// encountered, then it returns TRUE. Otherwise, it returns FALSE.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL InitEnumCalendarInfo()
|
|
{
|
|
//
|
|
// Initialize date counter.
|
|
//
|
|
CalendarCtr = 0;
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ECI_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.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int ECI_BadParamCheck()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
|
|
|
|
//
|
|
// Bad Function.
|
|
//
|
|
|
|
// Variation 1 - bad function
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( NULL,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_PARAMETER,
|
|
"function invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( NULL,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_PARAMETER,
|
|
"Ex function invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
|
|
//
|
|
// Bad Locale.
|
|
//
|
|
|
|
// Variation 1 - bad locale
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
(LCID)333,
|
|
ENUM_ALL_CALENDARS,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_PARAMETER,
|
|
"Locale invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
(LCID)333,
|
|
ENUM_ALL_CALENDARS,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_PARAMETER,
|
|
"Ex Locale invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
|
|
//
|
|
// Invalid Flag.
|
|
//
|
|
|
|
// Variation 1 - dwFlags = invalid
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ECI_INVALID_FLAG );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_FLAGS,
|
|
"Flag invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ECI_INVALID_FLAG );
|
|
CheckReturnBadParamEnum( rc,
|
|
FALSE,
|
|
ERROR_INVALID_FLAGS,
|
|
"Ex Flag invalid",
|
|
&NumErrors,
|
|
CalendarCtr,
|
|
0 );
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ECI_NormalCase
|
|
//
|
|
// This routine tests the normal cases of the API routine.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int ECI_NormalCase()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
int ctr; // loop counter
|
|
|
|
|
|
if (Verbose)
|
|
{
|
|
printf("\n---- W version ----\n\n");
|
|
}
|
|
|
|
//
|
|
// Single calendar id - English.
|
|
//
|
|
|
|
// Variation 1 - iCalIntValue - English
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"iCalIntValue English (cal 0)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex iCalIntValue English (cal 0)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - iCalIntValue - English
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"iCalIntValue English (cal 2)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex iCalIntValue English (cal 2)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - Use CP ACP
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE | LOCALE_USE_CP_ACP );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Use CP ACP",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE | LOCALE_USE_CP_ACP );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex Use CP ACP",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// CALTYPE values - English.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"English (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"Ex English (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Single calendar id - Japan.
|
|
//
|
|
|
|
// Variation 1 - iCalIntValue - Japan
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"iCalIntValue Japan (cal 0)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex iCalIntValue Japan (cal 0)",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// CALTYPE values - Japan.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_1[ctr],
|
|
"Japan (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_1[ctr],
|
|
"Ex Japan (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
2,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_2[ctr],
|
|
"Japan (cal 2) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
2,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_2[ctr],
|
|
"Ex Japan (cal 2) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
3,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_3[ctr],
|
|
"Japan (cal 3) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
3,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_3[ctr],
|
|
"Ex Japan (cal 3) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// English - Enumerate ALL Calendars.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"English (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"Ex English (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"Ex English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"Ex English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Japan - Enumerate ALL Calendars.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_All[ctr],
|
|
"Japan (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_All[ctr],
|
|
"Ex Japan (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Ex Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoW( MyFuncCalendar,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExW( MyFuncCalendarEx,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Ex Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ECI_Ansi
|
|
//
|
|
// This routine tests the normal cases of the API routine.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
int ECI_Ansi()
|
|
{
|
|
int NumErrors = 0; // error count - to be returned
|
|
int rc; // return code
|
|
int ctr; // loop counter
|
|
|
|
|
|
if (Verbose)
|
|
{
|
|
printf("\n---- A version ----\n\n");
|
|
}
|
|
|
|
//
|
|
// Single calendar id - English.
|
|
//
|
|
|
|
// Variation 1 - iCalIntValue - English
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"A version iCalIntValue English (cal 0)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex A version iCalIntValue English (cal 0)",
|
|
&NumErrors );
|
|
|
|
// Variation 2 - iCalIntValue - English
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"A version iCalIntValue English (cal 2)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
2,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex A version iCalIntValue English (cal 2)",
|
|
&NumErrors );
|
|
|
|
// Variation 3 - Use CP ACP
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE | LOCALE_USE_CP_ACP );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"A version Use CP ACP",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
0,
|
|
CAL_ICALINTVALUE | LOCALE_USE_CP_ACP );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex A version Use CP ACP",
|
|
&NumErrors );
|
|
|
|
|
|
//
|
|
// CALTYPE values - English.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"A version English (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"Ex A version English (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Single calendar id - Japan.
|
|
//
|
|
|
|
// Variation 1 - iCalIntValue - Japan
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"A version iCalIntValue Japan (cal 0)",
|
|
&NumErrors );
|
|
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
0,
|
|
CAL_ICALINTVALUE );
|
|
CheckReturnValidEnum( rc,
|
|
FALSE,
|
|
CalendarCtr,
|
|
0,
|
|
"Ex A version iCalIntValue Japan (cal 0)",
|
|
&NumErrors );
|
|
|
|
|
|
|
|
//
|
|
// CALTYPE values - Japan.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_1[ctr],
|
|
"A version Japan (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
1,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_1[ctr],
|
|
"Ex A version Japan (cal 1) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
2,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_2[ctr],
|
|
"A version Japan (cal 2) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
2,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_2[ctr],
|
|
"Ex A version Japan (cal 2) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
3,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_3[ctr],
|
|
"A version Japan (cal 3) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
3,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_3[ctr],
|
|
"Ex A version Japan (cal 3) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// English - Enumerate ALL Calendars.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"A version English (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalEnglish[ctr],
|
|
"Ex A version English (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"A version English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"Ex A version English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"A version English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0409,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
1,
|
|
"Ex A version English (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Japan - Enumerate ALL Calendars.
|
|
//
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_All[ctr],
|
|
"A version Japan (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = 0; ctr < NUM_CAL_FLAGS; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
pCalFlag[ctr] );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
pCalJapan_All[ctr],
|
|
"Ex A version Japan (all cal) Calendar Flag",
|
|
pCalFlag[ctr],
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"A version Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SDAYNAME1; ctr <= CAL_SMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Ex A version Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoA( MyFuncCalendarA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"A version Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
for (ctr = CAL_SABBREVMONTHNAME1; ctr <= CAL_SABBREVMONTHNAME12; ctr++)
|
|
{
|
|
CalendarCtr = 0;
|
|
rc = EnumCalendarInfoExA( MyFuncCalendarExA,
|
|
0x0411,
|
|
ENUM_ALL_CALENDARS,
|
|
ctr );
|
|
CheckReturnValidEnumLoop( rc,
|
|
TRUE,
|
|
CalendarCtr,
|
|
2,
|
|
"Ex A version Japan (all cal) Day/Month Calendar Flag",
|
|
ctr,
|
|
&NumErrors );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Return total number of errors found.
|
|
//
|
|
return (NumErrors);
|
|
}
|