1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
var BUGNUMBER;
var summary;
function runDSTOffsetCachingTestsFraction(part, parts)
{
BUGNUMBER = 563938;
summary = 'Cache DST offsets to improve SunSpider score';
print(BUGNUMBER + ": " + summary);
var MAX_UNIX_TIMET = 2145859200;
var RANGE_EXPANSION_AMOUNT = 30 * 24 * 60 * 60;
/**
* Computes the time zone offset in minutes at the given timestamp.
*/
function tzOffsetFromUnixTimestamp(timestamp)
{
var d = new Date(NaN);
d.setTime(timestamp); // local slot = NaN, UTC slot = timestamp
return d.getTimezoneOffset(); // get UTC, calculate local => diff in minutes
}
/**
* Clear the DST offset cache, leaving it initialized to include a timestamp
* completely unlike the provided one (i.e. one very, very far away in time
* from it). Thus an immediately following lookup for the provided timestamp
* will cache-miss and compute a clean value.
*/
function clearDSTOffsetCache(undesiredTimestamp)
{
var opposite = (undesiredTimestamp + MAX_UNIX_TIMET / 2) % MAX_UNIX_TIMET;
// Generic purge to known, but not necessarily desired, state
tzOffsetFromUnixTimestamp(0);
tzOffsetFromUnixTimestamp(MAX_UNIX_TIMET);
// Purge to desired state. Cycle 2x in case opposite or undesiredTimestamp
// is close to 0 or MAX_UNIX_TIMET.
tzOffsetFromUnixTimestamp(opposite);
tzOffsetFromUnixTimestamp(undesiredTimestamp);
tzOffsetFromUnixTimestamp(opposite);
tzOffsetFromUnixTimestamp(undesiredTimestamp);
}
function computeCanonicalTZOffset(timestamp)
{
clearDSTOffsetCache(timestamp);
return tzOffsetFromUnixTimestamp(timestamp);
}
var TEST_TIMESTAMPS_SECONDS =
[
// Special-ish timestamps
0,
RANGE_EXPANSION_AMOUNT,
MAX_UNIX_TIMET,
];
var ONE_DAY = 24 * 60 * 60;
var EIGHTY_THREE_HOURS = 83 * 60 * 60;
var NINETY_EIGHT_HOURS = 98 * 60 * 60;
function nextIncrement(i)
{
return i === EIGHTY_THREE_HOURS ? NINETY_EIGHT_HOURS : EIGHTY_THREE_HOURS;
}
// Now add a long sequence of non-special timestamps, from a fixed range, that
// overlaps a DST change by "a bit" on each side. 67 days should be enough
// displacement that we can occasionally exercise the implementation's
// thirty-day expansion and the DST-offset-change logic. Use two different
// increments just to be safe and catch something a single increment might not.
var DST_CHANGE_DATE = 1268553600; // March 14, 2010
for (var t = DST_CHANGE_DATE - 67 * ONE_DAY,
i = nextIncrement(NINETY_EIGHT_HOURS),
end = DST_CHANGE_DATE + 67 * ONE_DAY;
t < end;
i = nextIncrement(i), t += i)
{
TEST_TIMESTAMPS_SECONDS.push(t);
}
var TEST_TIMESTAMPS =
TEST_TIMESTAMPS_SECONDS.map(function(v) { return v * 1000; });
/**************
* BEGIN TEST *
**************/
// Compute the correct time zone offsets for all timestamps to be tested.
var CORRECT_TZOFFSETS = TEST_TIMESTAMPS.map(computeCanonicalTZOffset);
// Intentionally and knowingly invoking every single logic path in the cache
// isn't easy for a human to get right (and know he's gotten it right), so
// let's do it the easy way: exhaustively try all possible four-date sequences
// selecting from our array of possible timestamps.
var sz = TEST_TIMESTAMPS.length;
var start = Math.floor((part - 1) / parts * sz);
var end = Math.floor(part / parts * sz);
print("Exhaustively testing timestamps " +
"[" + start + ", " + end + ") of " + sz + "...");
try
{
for (var i = start; i < end; i++)
{
print("Testing timestamp " + i + "...");
var t1 = TEST_TIMESTAMPS[i];
for (var j = 0; j < sz; j++)
{
var t2 = TEST_TIMESTAMPS[j];
for (var k = 0; k < sz; k++)
{
var t3 = TEST_TIMESTAMPS[k];
for (var w = 0; w < sz; w++)
{
var t4 = TEST_TIMESTAMPS[w];
clearDSTOffsetCache(t1);
var tzo1 = tzOffsetFromUnixTimestamp(t1);
var tzo2 = tzOffsetFromUnixTimestamp(t2);
var tzo3 = tzOffsetFromUnixTimestamp(t3);
var tzo4 = tzOffsetFromUnixTimestamp(t4);
assertEq(tzo1, CORRECT_TZOFFSETS[i]);
assertEq(tzo2, CORRECT_TZOFFSETS[j]);
assertEq(tzo3, CORRECT_TZOFFSETS[k]);
assertEq(tzo4, CORRECT_TZOFFSETS[w]);
}
}
}
}
}
catch (e)
{
assertEq(true, false,
"Error when testing with timestamps " +
i + ", " + j + ", " + k + ", " + w +
" (" + t1 + ", " + t2 + ", " + t3 + ", " + t4 + ")!");
}
reportCompare(true, true);
print("All tests passed!");
}
|
