static void testParseTimeString(PRTime t) { PRExplodedTime et; PRTime t2; char timeString[128]; char buf[128]; PRInt32 totalOffset; PRInt32 hourOffset, minOffset; const char *sign; PRInt64 usec_per_sec; /* Truncate the microsecond part of PRTime */ LL_I2L(usec_per_sec, PR_USEC_PER_SEC); LL_DIV(t, t, usec_per_sec); LL_MUL(t, t, usec_per_sec); PR_ExplodeTime(t, PR_LocalTimeParameters, &et); /* Print day of the week, month, day, hour, minute, and second */ PR_snprintf(timeString, 128, "%s %s %ld %02ld:%02ld:%02ld ", dayOfWeek[et.tm_wday], month[et.tm_month], et.tm_mday, et.tm_hour, et.tm_min, et.tm_sec); /* Print time zone */ totalOffset = et.tm_params.tp_gmt_offset + et.tm_params.tp_dst_offset; if (totalOffset == 0) { strcat(timeString, "GMT "); /* I wanted to use "UTC" here, but * PR_ParseTimeString doesn't * understand "UTC". */ } else { sign = "+"; if (totalOffset < 0) { totalOffset = -totalOffset; sign = "-"; } hourOffset = totalOffset / 3600; minOffset = (totalOffset % 3600) / 60; PR_snprintf(buf, 128, "%s%02ld%02ld ", sign, hourOffset, minOffset); strcat(timeString, buf); } /* Print year */ PR_snprintf(buf, 128, "%hd", et.tm_year); strcat(timeString, buf); if (PR_ParseTimeString(timeString, PR_FALSE, &t2) == PR_FAILURE) { fprintf(stderr, "PR_ParseTimeString() failed\n"); exit(1); } if (LL_NE(t, t2)) { fprintf(stderr, "PR_ParseTimeString() incorrect\n"); PR_snprintf(buf, 128, "t is %lld, t2 is %lld, time string is %s\n", t, t2, timeString); fprintf(stderr, "%s\n", buf); exit(1); } }
nsresult nsHTTPIndex::OnIndexAvailable(nsIRequest* aRequest, nsISupports *aContext, nsIDirIndex* aIndex) { nsCOMPtr<nsIRDFResource> parentRes = do_QueryInterface(aContext); if (!parentRes) { NS_ERROR("Could not obtain parent resource"); return(NS_ERROR_UNEXPECTED); } const char* baseStr; parentRes->GetValueConst(&baseStr); if (! baseStr) { NS_ERROR("Could not reconstruct base uri\n"); return NS_ERROR_UNEXPECTED; } // we found the filename; construct a resource for its entry nsCAutoString entryuriC(baseStr); // gopher resources don't point to an entry in the same directory // like ftp uris. So the entryuriC is just a unique string, while // the URL attribute is the destination of this element // The naming scheme for the attributes is taken from the bookmarks nsXPIDLCString filename; nsresult rv = aIndex->GetLocation(getter_Copies(filename)); if (NS_FAILED(rv)) return rv; entryuriC.Append(filename); // if its a directory, make sure it ends with a trailing slash. // This doesn't matter for gopher, (where directories don't have // to end in a trailing /), because the filename is used for the URL // attribute. PRUint32 type; rv = aIndex->GetType(&type); if (NS_FAILED(rv)) return rv; PRBool isDirType = (type == nsIDirIndex::TYPE_DIRECTORY); if (isDirType && entryuriC.Last() != '/') { entryuriC.Append('/'); } nsCOMPtr<nsIRDFResource> entry; rv = mDirRDF->GetResource(entryuriC, getter_AddRefs(entry)); // At this point, we'll (hopefully) have found the filename and // constructed a resource for it, stored in entry. So now take a // second pass through the values and add as statements to the RDF // datasource. if (entry && NS_SUCCEEDED(rv)) { nsCOMPtr<nsIRDFLiteral> lit; nsString str; // For gopher, the target is the filename. We still have to do all // the above string manipulation though, because we need the entryuric // as the key for the RDF data source if (!strncmp(entryuriC.get(), kGopherProtocol, sizeof(kGopherProtocol)-1)) str.AssignWithConversion(filename); else { str.AssignWithConversion(entryuriC.get()); } rv = mDirRDF->GetLiteral(str.get(), getter_AddRefs(lit)); if (NS_SUCCEEDED(rv)) { rv = Assert(entry, kNC_URL, lit, PR_TRUE); if (NS_FAILED(rv)) return rv; nsXPIDLString xpstr; // description rv = aIndex->GetDescription(getter_Copies(xpstr)); if (NS_FAILED(rv)) return rv; if (xpstr.Last() == '/') xpstr.Truncate(xpstr.Length() - 1); rv = mDirRDF->GetLiteral(xpstr.get(), getter_AddRefs(lit)); if (NS_FAILED(rv)) return rv; rv = Assert(entry, kNC_Description, lit, PR_TRUE); if (NS_FAILED(rv)) return rv; // contentlength PRInt64 size; rv = aIndex->GetSize(&size); if (NS_FAILED(rv)) return rv; PRInt64 minus1 = LL_MAXUINT; if (LL_NE(size, minus1)) { PRInt32 intSize; LL_L2I(intSize, size); // XXX RDF should support 64 bit integers (bug 240160) nsCOMPtr<nsIRDFInt> val; rv = mDirRDF->GetIntLiteral(intSize, getter_AddRefs(val)); if (NS_FAILED(rv)) return rv; rv = Assert(entry, kNC_ContentLength, val, PR_TRUE); if (NS_FAILED(rv)) return rv; } // lastmodified PRTime tm; rv = aIndex->GetLastModified(&tm); if (NS_FAILED(rv)) return rv; if (tm != -1) { nsCOMPtr<nsIRDFDate> val; rv = mDirRDF->GetDateLiteral(tm, getter_AddRefs(val)); if (NS_FAILED(rv)) return rv; rv = Assert(entry, kNC_LastModified, val, PR_TRUE); } // filetype PRUint32 type; rv = aIndex->GetType(&type); switch (type) { case nsIDirIndex::TYPE_UNKNOWN: rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("UNKNOWN").get(), getter_AddRefs(lit)); break; case nsIDirIndex::TYPE_DIRECTORY: rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("DIRECTORY").get(), getter_AddRefs(lit)); break; case nsIDirIndex::TYPE_FILE: rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("FILE").get(), getter_AddRefs(lit)); break; case nsIDirIndex::TYPE_SYMLINK: rv = mDirRDF->GetLiteral(NS_LITERAL_STRING("SYMLINK").get(), getter_AddRefs(lit)); break; } if (NS_FAILED(rv)) return rv; rv = Assert(entry, kNC_FileType, lit, PR_TRUE); if (NS_FAILED(rv)) return rv; } // Since the definition of a directory depends on the protocol, we would have // to do string comparisons all the time. // But we're told if we're a container right here - so save that fact if (isDirType) Assert(entry, kNC_IsContainer, kTrueLiteral, PR_TRUE); else Assert(entry, kNC_IsContainer, kFalseLiteral, PR_TRUE); // instead of // rv = Assert(parentRes, kNC_Child, entry, PR_TRUE); // if (NS_FAILED(rv)) return rv; // defer insertion onto a timer so that the UI isn't starved AddElement(parentRes, kNC_Child, entry); } return rv; }
int main() { union { PRUint16 s; PRUint32 l; PRUint64 ll; unsigned char bytes[8]; } un; un.s = s_h; printf("%u %u\n", un.bytes[0], un.bytes[1]); un.s = PR_htons(un.s); printf("%u %u\n", un.bytes[0], un.bytes[1]); if (memcmp(un.bytes, bytes_n, 2)) { fprintf(stderr, "PR_htons failed\n"); exit(1); } un.s = PR_ntohs(un.s); printf("%u %u\n", un.bytes[0], un.bytes[1]); if (un.s != s_h) { fprintf(stderr, "PR_ntohs failed\n"); exit(1); } un.l = l_h; printf("%u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3]); un.l = PR_htonl(un.l); printf("%u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3]); if (memcmp(un.bytes, bytes_n, 4)) { fprintf(stderr, "PR_htonl failed\n"); exit(1); } un.l = PR_ntohl(un.l); printf("%u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3]); if (un.l != l_h) { fprintf(stderr, "PR_ntohl failed\n"); exit(1); } un.ll = ll_h; printf("%u %u %u %u %u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3], un.bytes[4], un.bytes[5], un.bytes[6], un.bytes[7]); un.ll = PR_htonll(un.ll); printf("%u %u %u %u %u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3], un.bytes[4], un.bytes[5], un.bytes[6], un.bytes[7]); if (memcmp(un.bytes, bytes_n, 8)) { fprintf(stderr, "PR_htonll failed\n"); exit(1); } un.ll = PR_ntohll(un.ll); printf("%u %u %u %u %u %u %u %u\n", un.bytes[0], un.bytes[1], un.bytes[2], un.bytes[3], un.bytes[4], un.bytes[5], un.bytes[6], un.bytes[7]); if (LL_NE(un.ll, ll_h)) { fprintf(stderr, "PR_ntohll failed\n"); exit(1); } printf("PASS\n"); return 0; }
int main(int argc, char** argv) { /* The command line argument: -d is used to determine if the test is being run in debug mode. The regress tool requires only one line output:PASS or FAIL. All of the printfs associated with this test has been handled with a if (debug_mode) test. Usage: test_name -d */ PLOptStatus os; PLOptState *opt; PR_STDIO_INIT(); opt = PL_CreateOptState(argc, argv, "d"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = PR_TRUE; break; default: break; } } PL_DestroyOptState(opt); /* main test */ PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0); #ifdef XP_MAC SetupMacPrintfLog("timetest.log"); debug_mode = PR_TRUE; #endif /* Testing zero PRTime (the epoch) */ { PRTime t; PRExplodedTime et; LL_I2L(t, 0); if (debug_mode) printf("The NSPR epoch is:\n"); PR_ExplodeTime(t, PR_LocalTimeParameters, &et); printExplodedTime(&et); if (debug_mode) printf("\n"); PR_ExplodeTime(t, PR_GMTParameters, &et); printExplodedTime(&et); if (debug_mode) printf("\n\n"); testParseTimeString(t); } /* ************************************************************* ** ** Testing PR_Now(), PR_ExplodeTime, and PR_ImplodeTime ** on the current time ** ************************************************************* */ { PRTime t1, t2; PRExplodedTime et; if (debug_mode) { printf("*********************************************\n"); printf("** **\n"); printf("** Testing PR_Now(), PR_ExplodeTime, and **\n"); printf("** PR_ImplodeTime on the current time **\n"); printf("** **\n"); printf("*********************************************\n\n"); } t1 = PR_Now(); /* First try converting to UTC */ PR_ExplodeTime(t1, PR_GMTParameters, &et); if (et.tm_params.tp_gmt_offset || et.tm_params.tp_dst_offset) { if (debug_mode) printf("ERROR: UTC has nonzero gmt or dst offset.\n"); else failed_already=1; return 1; } if (debug_mode) printf("Current UTC is "); printExplodedTime(&et); if (debug_mode) printf("\n"); t2 = PR_ImplodeTime(&et); if (LL_NE(t1, t2)) { if (debug_mode) printf("ERROR: Explode and implode are NOT inverse.\n"); else printf("FAIL\n"); return 1; } /* Next, try converting to local (US Pacific) time */ PR_ExplodeTime(t1, PR_LocalTimeParameters, &et); if (debug_mode) printf("Current local time is "); printExplodedTime(&et); if (debug_mode) printf("\n"); if (debug_mode) printf("GMT offset is %ld, DST offset is %ld\n", et.tm_params.tp_gmt_offset, et.tm_params.tp_dst_offset); t2 = PR_ImplodeTime(&et); if (LL_NE(t1, t2)) { if (debug_mode) printf("ERROR: Explode and implode are NOT inverse.\n"); return 1; } if (debug_mode) printf("Please examine the results\n"); testParseTimeString(t1); } /* ******************************************* ** ** Testing PR_NormalizeTime() ** ******************************************* */ /* July 4, 2001 is Wednesday */ { PRExplodedTime et; if (debug_mode) { printf("\n"); printf("**********************************\n"); printf("** **\n"); printf("** Testing PR_NormalizeTime() **\n"); printf("** **\n"); printf("**********************************\n\n"); } et.tm_year = 2001; et.tm_month = 7 - 1; et.tm_mday = 4; et.tm_hour = 0; et.tm_min = 0; et.tm_sec = 0; et.tm_usec = 0; et.tm_params = PR_GMTParameters(&et); PR_NormalizeTime(&et, PR_GMTParameters); if (debug_mode) printf("July 4, 2001 is %s.\n", dayOfWeek[et.tm_wday]); if (et.tm_wday == 3) { if (debug_mode) printf("PASS\n"); } else { if (debug_mode) printf("ERROR: It should be Wednesday\n"); else failed_already=1; return 1; } testParseTimeString(PR_ImplodeTime(&et)); /* June 12, 1997 23:00 PST == June 13, 1997 00:00 PDT */ et.tm_year = 1997; et.tm_month = 6 - 1; et.tm_mday = 12; et.tm_hour = 23; et.tm_min = 0; et.tm_sec = 0; et.tm_usec = 0; et.tm_params.tp_gmt_offset = -8 * 3600; et.tm_params.tp_dst_offset = 0; PR_NormalizeTime(&et, PR_USPacificTimeParameters); if (debug_mode) { printf("Thu Jun 12, 1997 23:00:00 PST is "); } printExplodedTime(&et); if (debug_mode) printf(".\n"); if (et.tm_wday == 5) { if (debug_mode) printf("PASS\n"); } else { if (debug_mode) printf("ERROR: It should be Friday\n"); else failed_already=1; return 1; } testParseTimeString(PR_ImplodeTime(&et)); /* Feb 14, 1997 00:00:00 PDT == Feb 13, 1997 23:00:00 PST */ et.tm_year = 1997; et.tm_month = 2 - 1; et.tm_mday = 14; et.tm_hour = 0; et.tm_min = 0; et.tm_sec = 0; et.tm_usec = 0; et.tm_params.tp_gmt_offset = -8 * 3600; et.tm_params.tp_dst_offset = 3600; PR_NormalizeTime(&et, PR_USPacificTimeParameters); if (debug_mode) { printf("Fri Feb 14, 1997 00:00:00 PDT is "); } printExplodedTime(&et); if (debug_mode) printf(".\n"); if (et.tm_wday == 4) { if (debug_mode) printf("PASS\n"); } else { if (debug_mode) printf("ERROR: It should be Thursday\n"); else failed_already=1; return 1; } testParseTimeString(PR_ImplodeTime(&et)); /* What time is Nov. 7, 1996, 18:29:23 PDT? */ et.tm_year = 1996; et.tm_month = 11 - 1; et.tm_mday = 7; et.tm_hour = 18; et.tm_min = 29; et.tm_sec = 23; et.tm_usec = 0; et.tm_params.tp_gmt_offset = -8 * 3600; /* PDT */ et.tm_params.tp_dst_offset = 3600; PR_NormalizeTime(&et, PR_LocalTimeParameters); if (debug_mode) printf("Nov 7 18:29:23 PDT 1996 is "); printExplodedTime(&et); if (debug_mode) printf(".\n"); testParseTimeString(PR_ImplodeTime(&et)); /* What time is Oct. 7, 1995, 18:29:23 PST? */ et.tm_year = 1995; et.tm_month = 10 - 1; et.tm_mday = 7; et.tm_hour = 18; et.tm_min = 29; et.tm_sec = 23; et.tm_params.tp_gmt_offset = -8 * 3600; /* PST */ et.tm_params.tp_dst_offset = 0; PR_NormalizeTime(&et, PR_LocalTimeParameters); if (debug_mode) printf("Oct 7 18:29:23 PST 1995 is "); printExplodedTime(&et); if (debug_mode) printf(".\n"); testParseTimeString(PR_ImplodeTime(&et)); if (debug_mode) printf("Please examine the results\n"); } /* ************************************************************** ** ** Testing range of years ** ************************************************************** */ { PRExplodedTime et1, et2; PRTime ttt; PRTime secs; if (debug_mode) { printf("\n"); printf("***************************************\n"); printf("** **\n"); printf("** Testing range of years **\n"); printf("** **\n"); printf("***************************************\n\n"); } /* April 4, 1917 GMT */ et1.tm_usec = 0; et1.tm_sec = 0; et1.tm_min = 0; et1.tm_hour = 0; et1.tm_mday = 4; et1.tm_month = 4 - 1; et1.tm_year = 1917; et1.tm_params = PR_GMTParameters(&et1); PR_NormalizeTime(&et1, PR_LocalTimeParameters); secs = PR_ImplodeTime(&et1); if (LL_GE_ZERO(secs)) { if (debug_mode) printf("ERROR: April 4, 1917 GMT returns a nonnegative second count\n"); failed_already = 1; return 1; } PR_ExplodeTime(secs, PR_LocalTimeParameters, &et2); if (!explodedTimeIsEqual(&et1, &et2)) { if (debug_mode) printf("ERROR: PR_ImplodeTime and PR_ExplodeTime are not inverse for April 4, 1917 GMT\n"); failed_already=1; return 1; } ttt = PR_ImplodeTime(&et1); testParseTimeString( ttt ); if (debug_mode) printf("Test passed for April 4, 1917\n"); /* July 4, 2050 */ et1.tm_usec = 0; et1.tm_sec = 0; et1.tm_min = 0; et1.tm_hour = 0; et1.tm_mday = 4; et1.tm_month = 7 - 1; et1.tm_year = 2050; et1.tm_params = PR_GMTParameters(&et1); PR_NormalizeTime(&et1, PR_LocalTimeParameters); secs = PR_ImplodeTime(&et1); if (!LL_GE_ZERO(secs)) { if (debug_mode) printf("ERROR: July 4, 2050 GMT returns a negative second count\n"); failed_already = 1; return 1; } PR_ExplodeTime(secs, PR_LocalTimeParameters, &et2); if (!explodedTimeIsEqual(&et1, &et2)) { if (debug_mode) printf("ERROR: PR_ImplodeTime and PR_ExplodeTime are not inverse for July 4, 2050 GMT\n"); failed_already=1; return 1; } testParseTimeString(PR_ImplodeTime(&et1)); if (debug_mode) printf("Test passed for July 4, 2050\n"); } /* ************************************************************** ** ** Stress test * ** Go through four years, starting from ** 00:00:00 PST Jan. 1, 1993, incrementing ** every 10 minutes. ** ************************************************************** */ { PRExplodedTime et, et1, et2; PRInt64 usecPer10Min; int day, hour, min; PRTime usecs; int dstInEffect = 0; if (debug_mode) { printf("\n"); printf("*******************************************************\n"); printf("** **\n"); printf("** Stress test **\n"); printf("** Starting from midnight Jan. 1, 1993 PST, **\n"); printf("** going through four years in 10-minute increment **\n"); printf("** **\n"); printf("*******************************************************\n\n"); } LL_I2L(usecPer10Min, 600000000L); /* 00:00:00 PST Jan. 1, 1993 */ et.tm_usec = 0; et.tm_sec = 0; et.tm_min = 0; et.tm_hour = 0; et.tm_mday = 1; et.tm_month = 0; et.tm_year = 1993; et.tm_params.tp_gmt_offset = -8 * 3600; et.tm_params.tp_dst_offset = 0; usecs = PR_ImplodeTime(&et); for (day = 0; day < 4 * 365 + 1; day++) { for (hour = 0; hour < 24; hour++) { for (min = 0; min < 60; min += 10) { LL_ADD(usecs, usecs, usecPer10Min); PR_ExplodeTime(usecs, PR_USPacificTimeParameters, &et1); et2 = et; et2.tm_usec += 600000000L; PR_NormalizeTime(&et2, PR_USPacificTimeParameters); if (!explodedTimeIsEqual(&et1, &et2)) { if (debug_mode) printf("ERROR: componentwise comparison failed\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); printExplodedTime(&et2); if (debug_mode) printf("\n"); failed_already=1; return 1; } if (LL_NE(usecs, PR_ImplodeTime(&et1))) { if (debug_mode) printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); failed_already=1; return 1; } testParseTimeString(usecs); if (!dstInEffect && et1.tm_params.tp_dst_offset) { dstInEffect = 1; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } else if (dstInEffect && !et1.tm_params.tp_dst_offset) { dstInEffect = 0; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } et = et1; } } } if (debug_mode) printf("Test passed\n"); } /* Same stress test, but with PR_LocalTimeParameters */ { PRExplodedTime et, et1, et2; PRInt64 usecPer10Min; int day, hour, min; PRTime usecs; int dstInEffect = 0; if (debug_mode) { printf("\n"); printf("*******************************************************\n"); printf("** **\n"); printf("** Stress test **\n"); printf("** Starting from midnight Jan. 1, 1993 PST, **\n"); printf("** going through four years in 10-minute increment **\n"); printf("** **\n"); printf("*******************************************************\n\n"); } LL_I2L(usecPer10Min, 600000000L); /* 00:00:00 PST Jan. 1, 1993 */ et.tm_usec = 0; et.tm_sec = 0; et.tm_min = 0; et.tm_hour = 0; et.tm_mday = 1; et.tm_month = 0; et.tm_year = 1993; et.tm_params.tp_gmt_offset = -8 * 3600; et.tm_params.tp_dst_offset = 0; usecs = PR_ImplodeTime(&et); for (day = 0; day < 4 * 365 + 1; day++) { for (hour = 0; hour < 24; hour++) { for (min = 0; min < 60; min += 10) { LL_ADD(usecs, usecs, usecPer10Min); PR_ExplodeTime(usecs, PR_LocalTimeParameters, &et1); et2 = et; et2.tm_usec += 600000000L; PR_NormalizeTime(&et2, PR_LocalTimeParameters); if (!explodedTimeIsEqual(&et1, &et2)) { if (debug_mode) printf("ERROR: componentwise comparison failed\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); printExplodedTime(&et2); if (debug_mode) printf("\n"); return 1; } if (LL_NE(usecs, PR_ImplodeTime(&et1))) { printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); failed_already=1; return 1; } testParseTimeString(usecs); if (!dstInEffect && et1.tm_params.tp_dst_offset) { dstInEffect = 1; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } else if (dstInEffect && !et1.tm_params.tp_dst_offset) { dstInEffect = 0; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } et = et1; } } } if (debug_mode) printf("Test passed\n"); } /* Same stress test, but with PR_LocalTimeParameters and going backward */ { PRExplodedTime et, et1, et2; PRInt64 usecPer10Min; int day, hour, min; PRTime usecs; int dstInEffect = 0; if (debug_mode) { printf("\n"); printf("*******************************************************\n"); printf("** **\n"); printf("** Stress test **\n"); printf("** Starting from midnight Jan. 1, 1997 PST, **\n"); printf("** going back four years in 10-minute increment **\n"); printf("** **\n"); printf("*******************************************************\n\n"); } LL_I2L(usecPer10Min, 600000000L); /* 00:00:00 PST Jan. 1, 1997 */ et.tm_usec = 0; et.tm_sec = 0; et.tm_min = 0; et.tm_hour = 0; et.tm_mday = 1; et.tm_month = 0; et.tm_year = 1997; et.tm_params.tp_gmt_offset = -8 * 3600; et.tm_params.tp_dst_offset = 0; usecs = PR_ImplodeTime(&et); for (day = 0; day < 4 * 365 + 1; day++) { for (hour = 0; hour < 24; hour++) { for (min = 0; min < 60; min += 10) { LL_SUB(usecs, usecs, usecPer10Min); PR_ExplodeTime(usecs, PR_LocalTimeParameters, &et1); et2 = et; et2.tm_usec -= 600000000L; PR_NormalizeTime(&et2, PR_LocalTimeParameters); if (!explodedTimeIsEqual(&et1, &et2)) { if (debug_mode) printf("ERROR: componentwise comparison failed\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); printExplodedTime(&et2); if (debug_mode) printf("\n"); return 1; } if (LL_NE(usecs, PR_ImplodeTime(&et1))) { if (debug_mode) printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n"); printExplodedTime(&et1); if (debug_mode) printf("\n"); failed_already=1; return 1; } testParseTimeString(usecs); if (!dstInEffect && et1.tm_params.tp_dst_offset) { dstInEffect = 1; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } else if (dstInEffect && !et1.tm_params.tp_dst_offset) { dstInEffect = 0; if (debug_mode) printf("DST changeover from "); printExplodedTime(&et); if (debug_mode) printf(" to "); printExplodedTime(&et1); if (debug_mode) printf(".\n"); } et = et1; } } } } if (failed_already) return 1; else return 0; }
int main(int argc, char** argv) #endif { PR_STDIO_INIT(); PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0); /* ************************************************************* ** ** Testing PR_Now(), PR_ExplodeTime, and PR_ImplodeTime ** on the current time ** ************************************************************* */ { PRTime t1, t2; PRExplodedTime et; printf("*********************************************\n"); printf("** **\n"); printf("** Testing PR_Now(), PR_ExplodeTime, and **\n"); printf("** PR_ImplodeTime on the current time **\n"); printf("** **\n"); printf("*********************************************\n\n"); t1 = PR_Now(); /* First try converting to UTC */ PR_ExplodeTime(t1, PR_GMTParameters, &et); if (et.tm_params.tp_gmt_offset || et.tm_params.tp_dst_offset) { printf("ERROR: UTC has nonzero gmt or dst offset.\n"); return 1; } printf("Current UTC is "); printExplodedTime(&et); printf("\n"); t2 = PR_ImplodeTime(&et); if (LL_NE(t1, t2)) { printf("ERROR: Explode and implode are NOT inverse.\n"); return 1; } /* Next, try converting to local (US Pacific) time */ PR_ExplodeTime(t1, PR_LocalTimeParameters, &et); printf("Current local time is "); printExplodedTime(&et); printf("\n"); printf("GMT offset is %ld, DST offset is %ld\n", et.tm_params.tp_gmt_offset, et.tm_params.tp_dst_offset); t2 = PR_ImplodeTime(&et); if (LL_NE(t1, t2)) { printf("ERROR: Explode and implode are NOT inverse.\n"); return 1; } } printf("Please examine the results\n"); return 0; }