static void
TestIDNToASCII(){
int32_t i;
UChar buf[MAX_DEST_SIZE];
UChar expected[MAX_DEST_SIZE];
UErrorCode status = U_ZERO_ERROR;
int32_t bufLen = 0;
UParseError parseError;
const char* testName="udina_IDNToASCII";
TestFunc func=uidna_IDNToASCII;
for(i=0;i< (int32_t)(sizeof(domainNames)/sizeof(domainNames[0])); i++){
bufLen = (int32_t)strlen(domainNames[i]);
bufLen = u_unescape(domainNames[i],buf, bufLen+1);
func(buf,bufLen,expected,MAX_DEST_SIZE, UIDNA_ALLOW_UNASSIGNED, &parseError,&status);
if(U_FAILURE(status)){
log_err_status(status, "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
break;
}
testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
/*test toASCII with all labels in the string*/
testAPI(buf,expected,testName, FALSE,U_ZERO_ERROR, FALSE, TRUE, func);
if(U_FAILURE(status)){
log_err( "%s failed to convert domainNames[%i].Error: %s \n",testName,i, u_errorName(status));
break;
}
}
}
int
main(int argc, char *argv[])
{
printf("Platform-independent login recording test driver\n");
__progname = ssh_get_progname(argv[0]);
if (argc == 2) {
if (strncmp(argv[1], "-i", 3) == 0)
compile_opts_only = 1;
else if (strncmp(argv[1], "-v", 3) == 0)
be_verbose=1;
}
if (!compile_opts_only) {
if (be_verbose && !testOutput())
return 1;
if (!testAPI())
return 1;
}
showOptions();
return 0;
} /* main() */
void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
switch (index) {
case 0: name = "DecimalFormat API test";
if (exec) {
logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
UErrorCode status = U_ZERO_ERROR;
Locale saveLocale;
Locale::setDefault(Locale::getEnglish(), status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
}
testAPI(/*par*/);
Locale::setDefault(saveLocale, status);
}
break;
case 1: name = "Rounding test";
if(exec) {
logln((UnicodeString)"DecimalFormat Rounding test---");
testRounding(/*par*/);
}
break;
case 2: name = "Test6354";
if(exec) {
logln((UnicodeString)"DecimalFormat Rounding Increment test---");
testRoundingInc(/*par*/);
}
break;
default: name = ""; break;
}
}
void IntlTestDateFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
if (exec) logln("TestSuite DateFormatAPI");
switch (index) {
case 0: name = "DateFormat API test";
if (exec) {
logln("DateFormat API test---"); logln("");
UErrorCode status = U_ZERO_ERROR;
Locale saveLocale;
Locale::setDefault(Locale::getEnglish(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not set default locale, test may not give correct results");
}
testAPI(/*par*/);
Locale::setDefault(saveLocale, status);
}
break;
case 1: name = "TestEquals";
if (exec) {
logln("TestEquals---"); logln("");
TestEquals();
}
break;
case 2: name = "TestNameHiding";
if (exec) {
logln("TestNameHiding---"); logln("");
TestNameHiding();
}
break;
default: name = ""; break;
}
}
int main(int argc, char **argv)
{
RTEXITCODE rcExit = RTTestInitAndCreate(RTPathFilename(argv[0]),
&g_hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(g_hTest);
testAPI(g_hTest);
return RTTestSummaryAndDestroy(g_hTest);
}
static void
TestToUnicode(){
int32_t i;
UChar buf[MAX_DEST_SIZE];
const char* testName = "uidna_toUnicode";
TestFunc func = uidna_toUnicode;
for(i=0;i< (int32_t)(sizeof(asciiIn)/sizeof(asciiIn[0])); i++){
u_charsToUChars(asciiIn[i],buf, (int32_t)strlen(asciiIn[i])+1);
testAPI(buf,unicodeIn[i],testName,FALSE,U_ZERO_ERROR, TRUE, TRUE, func);
}
}
main(int argc, char* argv)
{
config();
bool do_socks = false;
if( argc > 1 ) {
do_socks = true;
}
dprintf( dflag, "\nExternal interface (local daemon)\n\n" );
testAPI( NULL, do_socks );
dprintf( dflag, "\nExternal interface (bad hostname)\n\n" );
testAPI( "bazzle", do_socks );
dprintf( dflag, "\nLocal daemons\n\n" );
makeAndDisplayCM( NULL, NULL );
makeAndDisplayRegular( NULL, NULL );
dprintf( dflag, "\nRemote daemons we should find\n\n" );
makeAndDisplayCM( "condor", "condor" );
makeAndDisplayRegular( "puck.cs.wisc.edu", "condor" );
dprintf( dflag, "\nWe should find the startd, but not the others\n\n" );
makeAndDisplayRegular( "*****@*****.**", NULL );
dprintf( dflag, "\nUsing a bogus sinful string\n\n" );
Daemon d( DT_NEGOTIATOR, "<128.105.232.240:23232>" );
if( d.locate() ) {
dprintf( dflag, "Found %s\n", d.idStr() );
d.display( dflag );
} else {
dprintf( dflag, "%s\n", d.error() );
}
dprintf( dflag, "\nMake a local STARTD w/ explicit name\n\n" );
Daemon d2( DT_STARTD, get_local_fqdn().Value() );
if( d2.locate() ) {
d2.display( dflag );
} else {
dprintf( dflag, "%s\n", d2.error() );
}
dprintf( dflag, "\nMake a local COLLECTOR w/ explicit name\n\n" );
Daemon d3( DT_COLLECTOR, "turkey.cs.wisc.edu" );
if( d3.locate() ) {
d3.display( dflag );
} else {
dprintf( dflag, "%s\n", d3.error() );
}
dprintf( dflag, "\nUse idStr for a remote STARTD\n\n" );
Daemon d4( DT_STARTD, "puck.cs.wisc.edu" );
if( d4.locate() ) {
dprintf( dflag, "Found %s\n", d4.idStr() );
} else {
dprintf( dflag, "%s\n", d4.error() );
}
dprintf( dflag, "\nTest socks on a valid Daemon that isn't up\n\n" );
Daemon d5( DT_SCHEDD, "cabernet.cs.wisc.edu" );
testSocks( &d5 );
dprintf( dflag, "\nCM where you specify pool and not name\n\n" );
Daemon d6( DT_COLLECTOR, NULL, "condor" );
if( d6.locate() ) {
d6.display( dflag );
} else {
dprintf( dflag, "%s\n", d6.error() );
}
dprintf( dflag, "\nUsing sinful string for the collector\n\n" );
Daemon d7( DT_COLLECTOR, "<128.105.143.16:9618>" );
if( d7.locate() ) {
dprintf( dflag, "Found %s\n", d7.idStr() );
d7.display( dflag );
} else {
dprintf( dflag, "%s\n", d7.error() );
}
dprintf( dflag, "\nRemote daemons we should NOT find\n\n" );
makeAndDisplayRegular( "bazzle.cs.wisc.edu", "condor" );
makeAndDisplayCM( "bazzle", "bazzle" );
}
int main(int argc, char **argv)
{
// char *outstring;
//int i;
int cmdNum = 0;
int verbose = 0;
int rValue;
int argcnt = 1;
char *confpath = "/etc/ssl/openssl.cnf";
// Needs to be configured to wherever @WEBOS_INSTALL_SYSCONFDIR@
// points. Pass as run-time parameter to override.
while(argcnt < argc) {
switch(argv[argcnt][0]) {
case '-':
switch(argv[argcnt][1]) {
case 'v':
verbose++;
break;
default:
usage();
break;
}
break;
default:
confpath = argv[argcnt];
break;
}
argcnt++;
}
if (0 != (rValue = (CertInitCertMgr(confpath))))
{
fprintf(stderr,
"ERROR: Couldn't initialize the manager using conf file %s\n",confpath);
PRINT_RETURN_CODE(rValue);
}
while (1)
{
char cmdBuf[1024];
char nOpts;
char cmd[64];
char param1[64], *param1p;
char param2[64], *param2p;
char param3[64], *param3p;
int result;
printf("%08d> ", cmdNum++);
memset((void *)cmdBuf, 0, MAX_CERT_PATH);
gets(cmdBuf);
cmd[0] = 0;
nOpts = sscanf(cmdBuf, "%s %s %s %s", cmd, param1, param2, param3);
if (verbose)
printf("%s\n", cmdBuf);
result = CERT_OK;
param1p = param2p = param3p = NULL;
if (1 < nOpts)
{
param1p = param1;
if (2 < nOpts)
{
param2p = param2;
if (3 < nOpts)
{
param3p = param3;
}
}
}
if (!nOpts)
{
printUsage(mainTestList, MAIN_TEST_LIST_SIZE);
break;
}
switch (cmd[0])
{
case 'a': // test API directly
result = testAPI(param1p, param2p, param3p, cmdBuf);
printf("API %s: %s (%d)\n", param1p,
(result < CERT_MAX_RETURN_CODE) ?
strErrorNames[result] : "UNKNOWN",
result);
break;
case 'c': // configuration details
displayConfigDetail(param1p, param2p);
break; // configuration details
case 'd': // Database manipulation
result = tcert_TestDatabase(param1p, param2p, param3p);
break;
case 'h': // h[elp]
printUsage(mainTestList, MAIN_TEST_LIST_SIZE);
break; // help
/* installation goes from default package dir
* to default destination dirs
*/
case 'i': // install
tcert_InstallPackage(param1p, param2p, param3p);
break;
case 'p': // private keys
tcert_PrivatekeyInfo(param1p, param2p, param3p);
break;
case 'q':
exit(0);
break;
case 'r': // raw package information
tcert_RawPackageInfo(param1p, param2p, param3p);
break; // raw package information
case 'x': // x[509 certificate information]
tcert_X509PackageInfo(param1p, param2p, param3p);
break; // x[509 certificate information]
default:
cmdNum--;
break;
} // switch(cmdBuf[0])
PRINT_RETURN_CODE(result);
}
return 0;
}
int main(int argc, char** argv) {
std::cout << std::boolalpha;
if ( option(argv, 'h') ) {
std::cout << "usage: test_symbol [-v] [-h]\n"
<< "exits with zero if all tests pass\n"
<< "-v option for verbose output\n"
<< "-h option for these instructions\n";
return 0;
}
verbose = option(argv, 'v');
bool passed = true;
passed &= testAPI();
// the empty string is encoded as 0 as a special case.
passed &= testEncodeDecode("");
// some simple short identifiers which should be encoded exactly.
passed &= testEncodeDecode("hello");
passed &= testEncodeDecode("abyz019_AZ");
passed &= testEncodeDecode("0123456789");
// some bad identifiers which can't be encoded at all.
passed &= expectSymbolError(" ");
passed &= expectSymbolError("trailing ");
passed &= expectSymbolError(" padded ");
passed &= expectSymbolError("hi there");
passed &= expectSymbolError("!@#$#%");
passed &= expectSymbolError("excited!");
passed &= expectSymbolError("@ruby");
passed &= expectSymbolError("#yolo");
passed &= expectSymbolError("$ngRoute");
passed &= expectSymbolError("Mwahaha!!");
// these can be reliably encoded, but some information is lost so they
// can't be entirely decoded again.
passed &= testLossy("0123456789A");
passed &= testLossy("abcdefghijklmnopqrstuvwxyz");
passed &= testLossy("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
passed &= testLossy("abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
// short symbol identifiers should be recovered exactly
passed &= testDecodeReencode("", true);
passed &= testDecodeReencode("hello", true);
passed &= testDecodeReencode("_", true);
passed &= testDecodeReencode("__init__", true);
passed &= testDecodeReencode("0", true);
passed &= testDecodeReencode("1", true);
passed &= testDecodeReencode("42", true);
passed &= testDecodeReencode("0123456789", true);
// long symbol identifiers will lose information
passed &= testDecodeReencode("abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", false);
// these are all examples of correctly formatted lossy-encoded symbols, so should match when re-encoded.
passed &= testDecodeReencode("abc_1234abcd_de", true);
passed &= testDecodeReencode("abc_1234a____de", true);
passed &= testDecodeReencode("_AZ_567890ef_09", true);
// these don't quite match, middle should be hashed and won't match exactly when re-encoded.
passed &= testDecodeReencode("abc_1234abcd_dex", false);
passed &= testDecodeReencode("abc_1_34abcd_de", false);
passed &= testDecodeReencode("abc_1234aBcd_de", false);
passed &= testSymbolSpace();
if ( passed ) std::cout << "passed." << std::endl;
else std::cout << "failed!" << std::endl;
return passed ? 0 : 1;
}
void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
switch (index) {
case 0: name = "DecimalFormat API test";
if (exec) {
logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
UErrorCode status = U_ZERO_ERROR;
Locale saveLocale;
Locale::setDefault(Locale::getEnglish(), status);
if(U_FAILURE(status)) {
errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
}
testAPI(/*par*/);
Locale::setDefault(saveLocale, status);
}
break;
case 1: name = "Rounding test";
if(exec) {
logln((UnicodeString)"DecimalFormat Rounding test---");
testRounding(/*par*/);
}
break;
case 2: name = "Test6354";
if(exec) {
logln((UnicodeString)"DecimalFormat Rounding Increment test---");
testRoundingInc(/*par*/);
}
break;
case 3: name = "TestCurrencyPluralInfo";
if(exec) {
logln((UnicodeString)"CurrencyPluralInfo API test---");
TestCurrencyPluralInfo();
}
break;
case 4: name = "TestScale";
if(exec) {
logln((UnicodeString)"Scale test---");
TestScale();
}
break;
case 5: name = "TestFixedDecimal";
if(exec) {
logln((UnicodeString)"TestFixedDecimal ---");
TestFixedDecimal();
}
break;
case 6: name = "TestBadFastpath";
if(exec) {
logln((UnicodeString)"TestBadFastpath ---");
TestBadFastpath();
}
break;
case 7: name = "TestRequiredDecimalPoint";
if(exec) {
logln((UnicodeString)"TestRequiredDecimalPoint ---");
TestRequiredDecimalPoint();
}
break;
default: name = ""; break;
}
}
