Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

387 lines
10 KiB

/*++
UTEST.C
Test program for the options subsystem. Must compile under
NT and UNIX
Created, 5/24/1997 by DavidCHR
--*/
#include "private.h"
optEnumStruct enums[] = {
{ "one", (PVOID) 1, "should end up 1" },
{ "two", (PVOID) 2, "should end up 2" },
{ "beef", (PVOID) 0xdeadbeef, "should be 0xdeadbeef" },
{ "beefs", (PVOID) 0xbadf00d, "should be 0xbadf00d" },
{ "secret", (PVOID) 60, }, // shouldn't show in help
TERMINATE_ARRAY
};
ULONG enumTestVariable=0;
PCHAR SubString = NULL;
optionStruct substructOptions[] = {
{ "h", NULL, OPT_HELP },
{ "substr", &SubString, OPT_STRING, "Substring option" },
TERMINATE_ARRAY
};
PCHAR FuncString1 = NULL;
PCHAR FuncString2 = NULL;
PCHAR StringOption = NULL;
int IntegerOption = 0L;
BOOL BooleanOption = FALSE;
float FloatOption = 0.0;
PCHAR UndocumentedString = NULL;
PWCHAR WideCharOption = NULL;
UNICODE_STRING UnicodeStringOption = { 0 };
int MyOptFunc( IN int argc,
IN PCHAR *argv );
BOOL MyOptFunc2( IN BOOL fHelp,
IN POPT_FUNC_PARAMETER_DATA pData );
optionStruct sampleOptions[ ] = {
{ "help", NULL, OPT_HELP },
{ "?", NULL, OPT_HELP },
{ NULL, NULL, OPT_DUMMY, "-----------------------------" },
{ NULL, NULL, OPT_CONTINUE, "These are the useful options:" },
{ NULL, NULL, OPT_DUMMY, "-----------------------------" },
{ "enum", &enumTestVariable, OPT_ENUMERATED,
"Test enumerated type", enums },
{ "mask", &enumTestVariable, OPT_ENUMERATED | OPT_ENUM_IS_MASK,
"Test enumerated type with OPT_ENUM_IS_MASK", enums },
{ "substruct", substructOptions, OPT_SUBOPTION | OPT_RECURSE,
"substruct:help for help" },
{ "recurse", sampleOptions, OPT_SUBOPTION, "recurse:help for help" },
{ "string", &StringOption, OPT_STRING | OPT_ENVIRONMENT, "String Option",
"StringOption" },
{ NULL, NULL, OPT_CONTINUE, "Use this option to request a string" },
{ "int", &IntegerOption, OPT_INT | OPT_ENVIRONMENT, "integer option",
"IntegerOption" },
{ NULL, NULL, OPT_CONTINUE, "Use this option to request an integer" },
{ "func", MyOptFunc, OPT_FUNC, "function option" },
{ NULL, NULL, OPT_CONTINUE, "Use this option to request two strings" },
{ "func2", &IntegerOption, OPT_FUNC2, "FUNC2 option",
MyOptFunc2 },
{ "bool", &BooleanOption, OPT_BOOL, "boolean option" },
{ NULL, NULL, OPT_CONTINUE, "Use this option to request a boolean" },
{ "float", &FloatOption, OPT_FLOAT, "floating point option" },
{ NULL, NULL, OPT_CONTINUE, "Use this option to request a float" },
{ "wstring",&WideCharOption, OPT_WSTRING | OPT_ENVIRONMENT,
"Wide Char String option", "WideCharOption" },
{ "ustring",&UnicodeStringOption, OPT_USTRING | OPT_ENVIRONMENT,
"Unicode String Option", "UnicodeStringOption" },
{ "hidden", &UndocumentedString, OPT_STRING | OPT_HIDDEN,
"you should never see this line. This option is OPT_HIDDEN" },
{ "stop", NULL, OPT_STOP_PARSING,
"halts parsing of the command line." },
{ NULL, NULL, OPT_DUMMY | OPT_NOHEADER, "" },
{ NULL, NULL, OPT_DUMMY | OPT_NOHEADER,
"Example: utest /string \"foo bar baz\" /int 0x15 +bool /float 3.14" },
{ NULL, NULL, OPT_PAUSE },
TERMINATE_ARRAY
};
int
MyOptFunc( int argc,
PCHAR *argv ) {
if ( ( argv == NULL ) || (argc < 3 ) ) {
/* this means the user requested help */
fprintf( stderr, "func [string1] [string2]\n" );
return 0;
}
printf( "MyOptFunc was called. argc=%d.\n", argc );
FuncString1 = argv[1];
FuncString2 = argv[2];
return 3; /* number of arguments eaten--
-func argv[1] argv[2] == 3 options */
}
VOID
DumpArgs( int argc,
PCHAR argv[] ) {
int i;
for ( i = 0 ; i < argc ; i++ ) {
fprintf( stderr, "arg %d = %s\n", i, argv[i] );
}
}
BOOL
MyOptFunc2( IN BOOL fHelp,
IN POPT_FUNC_PARAMETER_DATA pData ) {
#if OPT_FUNC_PARAMETER_VERSION != 1
#error "OptFuncParameterVersion has changed. Update this function."
#endif
optionStruct OptFunc2Options[] = {
{ "help", NULL, OPT_HELP },
{ "FuncString1", &FuncString1, OPT_INT },
{ "FuncString2", &FuncString2, OPT_INT },
{ "recurse", sampleOptions, OPT_SUBOPTION,
"points back to the toplevel structure. Very amusing. :-)" },
{ "STOP", NULL, OPT_STOP_PARSING,
"halts parsing within the Func2." },
TERMINATE_ARRAY
};
if ( fHelp ) {
CHAR buffer[ 255 ];
PrintUsageEntry( stderr,
"[-/+]", // switch characters
pData->argv[0], // command GUARANTEED TO EXIST
"->", // separator
"Exercises the OPT_FUNC2 interface. Options follow",
FALSE ); // FALSE--> do not repeat switch.
sprintf( buffer, "-> options %s takes ", pData->argv[0] );
PrintUsageEntry( stderr,
NULL,
NULL,
"-=", // the NULLs will fill with this string.
buffer,
TRUE );
sprintf( buffer, "(%s) ", pData->argv[0] );
PrintUsage( stderr,
0L, // flags
OptFunc2Options,
buffer );
PrintUsageEntry( stderr,
NULL,
NULL,
"-*",
"-> (end of OPT_FUNC2 options)",
TRUE );
return TRUE;
} else {
if ( pData->optionVersion != OPT_FUNC_PARAMETER_VERSION ) {
fprintf( stderr,
"WARNING: option library out of sync with header\n" );
}
fprintf( stderr,
"MyOptFunc2 called. Data follows:\n"
"pData->optionVersion = %d\n"
"pData->dataField = 0x%p\n"
"pData->argc = %d\n"
"pData->argv = 0x%p\n"
"pData->optionFlags = 0x%x\n"
"pData->pSaveQueue = 0x%p\n",
pData->optionVersion,
pData->dataFieldPointer,
pData->argc,
pData->argv,
pData->optionFlags,
pData->pSaveQueue );
fprintf( stderr, "%s arguments are:\n", pData->argv[0] );
DumpArgs( pData->argc, pData->argv );
if ( ParseOptionsEx( pData->argc-1,
pData->argv+1,
OptFunc2Options,
pData->optionFlags,
&pData->pSaveQueue,
&pData->argsused,
&pData->argv ) ) {
fprintf( stderr,
"pData->argsused IN = %d\n", pData->argsused );
pData->argsused = pData->argc - pData->argsused;
fprintf( stderr,
"pData->argsused OUT = %d\n", pData->argsused );
} else return FALSE;
}
fprintf( stderr, "\n Leaving OPT_FUNC2. \n\n" );
return TRUE;
}
int
main( int argc,
char *argv[] ) {
BOOL foo;
PVOID pCleanup = NULL;
optEnumStruct parserOptions[] = {
{ "skip", (PVOID) OPT_FLAG_SKIP_UNKNOWNS,
"OPT_FLAG_SKIP_UNKNOWNS" },
{ "reassemble", (PVOID) OPT_FLAG_REASSEMBLE,
"OPT_FLAG_REASSEMBLE" },
{ "terminate", (PVOID) OPT_FLAG_TERMINATE,
"OPT_FLAG_TERMINATE" },
TERMINATE_ARRAY
};
ULONG ParserFlag = OPT_FLAG_REASSEMBLE;
#ifndef DEBUG_OPTIONS
BOOL DebugFlag = 0; // will be ignored... just here for convenience
#endif
optionStruct singleOption[] = {
{ "utestHelp", NULL, OPT_HELP },
{ "parserFlag", &ParserFlag, OPT_ENUMERATED,
"flags to pass to ParseOptionsEx", parserOptions },
{ "headerlength", &OptMaxHeaderLength, OPT_INT,
"OptMaxHeaderLength value (formatting)" },
{ "commandLength", &OptMaxCommandLength, OPT_INT,
"OptMaxCommandLength value (formatting)" },
{ "separatorLength", &OptMaxSeparatorLength, OPT_INT,
"OptMaxSeparatorLength value (formatting)" },
{ "descriptionLength", &OptMaxDescriptionLength, OPT_INT,
"OptMaxDescriptionLength value (formatting)" },
{ "debug", &DebugFlag, OPT_INT, "Debugger status" },
TERMINATE_ARRAY
};
DebugFlag |= OPTION_DEBUGGING_LEVEL;
foo = ParseOptionsEx( argc-1, argv+1, singleOption,
0, &pCleanup, &argc, &argv );
ParserFlag |= OPT_FLAG_MEMORYLIST_OK;
fprintf( stderr,
"first ParseOptionsEx returned 0x%x \n"
" saveQueue 0x%p \n"
" passing in flags 0x%x \n",
foo, pCleanup, ParserFlag );
if ( argc ) {
ULONG i;
fprintf( stderr, "%d new options: \n", argc );
DumpArgs( argc, argv );
fprintf( stderr, "\n" );
}
foo = ParseOptionsEx( argc, argv, sampleOptions, ParserFlag,
&pCleanup, &argc, &argv );
fprintf( stderr,
"ParseOptionsEx returns %d\n"
" new argv = 0x%p\n"
" new argc = %d \n",
foo, argv, argc );
DumpArgs( argc, argv );
printf( "Formatting values were:\n"
"\tOptMaxHeaderLength = %d\n"
"\tOptMaxCommandLength = %d\n"
"\tOptMaxSeparatorLength = %d\n"
"\tOptMaxDescriptionLength = %d\n",
OptMaxHeaderLength,
OptMaxCommandLength,
OptMaxSeparatorLength,
OptMaxDescriptionLength );
printf( "\nOptions used:\n"
"\tstring = \"%hs\"\n"
"\tint = %d \n"
"\tBool = 0x%x \n"
/* "Float = %f \n" */
"\twstring = L\"%ws\"\n"
"\tustring = (unicode string) %wZ \n"
"\thidden = \"%hs\"\n"
"\tsubstruct:substr = \"%hs\"\n"
"\tfuncString1 = \"%hs\"\n"
"\tfuncString2 = \"%hs\"\n"
"\tenum = %d (0x%x)\n",
StringOption,
IntegerOption,
BooleanOption,
/* FloatOption, */ /* floating point not loaded?
What does that mean?! */
WideCharOption,
&UnicodeStringOption,
UndocumentedString,
SubString,
FuncString1,
FuncString2,
enumTestVariable, enumTestVariable );
CleanupOptionDataEx( pCleanup );
return foo;
}