mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-31 22:25:30 +00:00
740 lines
21 KiB
C
740 lines
21 KiB
C
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* file: timetest.c
|
|
* description: test time and date routines
|
|
*/
|
|
/***********************************************************************
|
|
** Includes
|
|
***********************************************************************/
|
|
/* Used to get the command line option */
|
|
#include "plgetopt.h"
|
|
|
|
#include "prinit.h"
|
|
#include "prtime.h"
|
|
#include "prprf.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
int failed_already=0;
|
|
PRBool debug_mode = PR_FALSE;
|
|
|
|
static char *dayOfWeek[] =
|
|
{ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "???" };
|
|
static char *month[] =
|
|
{ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
|
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "???" };
|
|
|
|
static void PrintExplodedTime(const PRExplodedTime *et) {
|
|
PRInt32 totalOffset;
|
|
PRInt32 hourOffset, minOffset;
|
|
const char *sign;
|
|
|
|
/* Print day of the week, month, day, hour, minute, and second */
|
|
if (debug_mode) printf("%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) {
|
|
if (debug_mode) printf("UTC ");
|
|
} else {
|
|
sign = "+";
|
|
if (totalOffset < 0) {
|
|
totalOffset = -totalOffset;
|
|
sign = "-";
|
|
}
|
|
hourOffset = totalOffset / 3600;
|
|
minOffset = (totalOffset % 3600) / 60;
|
|
if (debug_mode)
|
|
printf("%s%02ld%02ld ", sign, hourOffset, minOffset);
|
|
}
|
|
|
|
/* Print year */
|
|
if (debug_mode) printf("%hd", et->tm_year);
|
|
}
|
|
|
|
static int ExplodedTimeIsEqual(const PRExplodedTime *et1,
|
|
const PRExplodedTime *et2)
|
|
{
|
|
if (et1->tm_usec == et2->tm_usec &&
|
|
et1->tm_sec == et2->tm_sec &&
|
|
et1->tm_min == et2->tm_min &&
|
|
et1->tm_hour == et2->tm_hour &&
|
|
et1->tm_mday == et2->tm_mday &&
|
|
et1->tm_month == et2->tm_month &&
|
|
et1->tm_year == et2->tm_year &&
|
|
et1->tm_wday == et2->tm_wday &&
|
|
et1->tm_yday == et2->tm_yday &&
|
|
et1->tm_params.tp_gmt_offset == et2->tm_params.tp_gmt_offset &&
|
|
et1->tm_params.tp_dst_offset == et2->tm_params.tp_dst_offset) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
/* 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, 2005, 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 Pacific Time **\n");
|
|
printf("** Starting from midnight Jan. 1, 2005 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, 2005 */
|
|
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 = 2005;
|
|
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)) {
|
|
printf("ERROR: componentwise comparison failed\n");
|
|
PrintExplodedTime(&et1);
|
|
printf("\n");
|
|
PrintExplodedTime(&et2);
|
|
printf("\n");
|
|
failed_already=1;
|
|
return 1;
|
|
}
|
|
|
|
if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
|
|
printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
|
|
PrintExplodedTime(&et1);
|
|
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);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
printf(".\n");
|
|
}
|
|
} else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
|
|
dstInEffect = 0;
|
|
if (debug_mode) {
|
|
printf("DST changeover from ");
|
|
PrintExplodedTime(&et);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
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 Local Time **\n");
|
|
printf("** Starting from midnight Jan. 1, 2005 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, 2005 */
|
|
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 = 2005;
|
|
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)) {
|
|
printf("ERROR: componentwise comparison failed\n");
|
|
PrintExplodedTime(&et1);
|
|
printf("\n");
|
|
PrintExplodedTime(&et2);
|
|
printf("\n");
|
|
return 1;
|
|
}
|
|
|
|
if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
|
|
printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
|
|
PrintExplodedTime(&et1);
|
|
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);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
printf(".\n");
|
|
}
|
|
} else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
|
|
dstInEffect = 0;
|
|
if (debug_mode) {
|
|
printf("DST changeover from ");
|
|
PrintExplodedTime(&et);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
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 Local Time **\n");
|
|
printf("** Starting from midnight Jan. 1, 2009 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, 2009 */
|
|
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 = 2009;
|
|
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)) {
|
|
printf("ERROR: componentwise comparison failed\n");
|
|
PrintExplodedTime(&et1);
|
|
printf("\n");
|
|
PrintExplodedTime(&et2);
|
|
printf("\n");
|
|
return 1;
|
|
}
|
|
|
|
if (LL_NE(usecs, PR_ImplodeTime(&et1))) {
|
|
printf("ERROR: PR_ExplodeTime and PR_ImplodeTime are not inverse\n");
|
|
PrintExplodedTime(&et1);
|
|
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);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
printf(".\n");
|
|
}
|
|
} else if (dstInEffect && !et1.tm_params.tp_dst_offset) {
|
|
dstInEffect = 0;
|
|
if (debug_mode) {
|
|
printf("DST changeover from ");
|
|
PrintExplodedTime(&et);
|
|
printf(" to ");
|
|
PrintExplodedTime(&et1);
|
|
printf(".\n");
|
|
}
|
|
}
|
|
|
|
et = et1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (failed_already) return 1;
|
|
else return 0;
|
|
|
|
}
|