Source file
src/time/zoneinfo_test.go
Documentation: time
1
2
3
4
5 package time_test
6
7 import (
8 "errors"
9 "fmt"
10 "os"
11 "reflect"
12 "testing"
13 "time"
14 )
15
16 func init() {
17 if time.ZoneinfoForTesting() != nil {
18 panic(fmt.Errorf("zoneinfo initialized before first LoadLocation"))
19 }
20 }
21
22 func TestEnvVarUsage(t *testing.T) {
23 time.ResetZoneinfoForTesting()
24
25 const testZoneinfo = "foo.zip"
26 const env = "ZONEINFO"
27
28 t.Setenv(env, testZoneinfo)
29
30
31 time.LoadLocation("Asia/Jerusalem")
32 defer time.ResetZoneinfoForTesting()
33
34 if zoneinfo := time.ZoneinfoForTesting(); testZoneinfo != *zoneinfo {
35 t.Errorf("zoneinfo does not match env variable: got %q want %q", *zoneinfo, testZoneinfo)
36 }
37 }
38
39 func TestBadLocationErrMsg(t *testing.T) {
40 time.ResetZoneinfoForTesting()
41 loc := "Asia/SomethingNotExist"
42 want := errors.New("unknown time zone " + loc)
43 _, err := time.LoadLocation(loc)
44 if err.Error() != want.Error() {
45 t.Errorf("LoadLocation(%q) error = %v; want %v", loc, err, want)
46 }
47 }
48
49 func TestLoadLocationValidatesNames(t *testing.T) {
50 time.ResetZoneinfoForTesting()
51 const env = "ZONEINFO"
52 t.Setenv(env, "")
53
54 bad := []string{
55 "/usr/foo/Foo",
56 "\\UNC\foo",
57 "..",
58 "a..",
59 }
60 for _, v := range bad {
61 _, err := time.LoadLocation(v)
62 if err != time.ErrLocation {
63 t.Errorf("LoadLocation(%q) error = %v; want ErrLocation", v, err)
64 }
65 }
66 }
67
68 func TestVersion3(t *testing.T) {
69 time.ForceZipFileForTesting(true)
70 defer time.ForceZipFileForTesting(false)
71 _, err := time.LoadLocation("Asia/Jerusalem")
72 if err != nil {
73 t.Fatal(err)
74 }
75 }
76
77
78
79
80 func TestFirstZone(t *testing.T) {
81 time.ForceZipFileForTesting(true)
82 defer time.ForceZipFileForTesting(false)
83
84 const format = "Mon, 02 Jan 2006 15:04:05 -0700 (MST)"
85 var tests = []struct {
86 zone string
87 unix int64
88 want1 string
89 want2 string
90 }{
91 {
92 "PST8PDT",
93 -1633269601,
94 "Sun, 31 Mar 1918 01:59:59 -0800 (PST)",
95 "Sun, 31 Mar 1918 03:00:00 -0700 (PDT)",
96 },
97 {
98 "Pacific/Fakaofo",
99 1325242799,
100 "Thu, 29 Dec 2011 23:59:59 -1100 (-11)",
101 "Sat, 31 Dec 2011 00:00:00 +1300 (+13)",
102 },
103 }
104
105 for _, test := range tests {
106 z, err := time.LoadLocation(test.zone)
107 if err != nil {
108 t.Fatal(err)
109 }
110 s := time.Unix(test.unix, 0).In(z).Format(format)
111 if s != test.want1 {
112 t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want1)
113 }
114 s = time.Unix(test.unix+1, 0).In(z).Format(format)
115 if s != test.want2 {
116 t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want2)
117 }
118 }
119 }
120
121 func TestLocationNames(t *testing.T) {
122 if time.Local.String() != "Local" {
123 t.Errorf(`invalid Local location name: got %q want "Local"`, time.Local)
124 }
125 if time.UTC.String() != "UTC" {
126 t.Errorf(`invalid UTC location name: got %q want "UTC"`, time.UTC)
127 }
128 }
129
130 func TestLoadLocationFromTZData(t *testing.T) {
131 time.ForceZipFileForTesting(true)
132 defer time.ForceZipFileForTesting(false)
133
134 const locationName = "Asia/Jerusalem"
135 reference, err := time.LoadLocation(locationName)
136 if err != nil {
137 t.Fatal(err)
138 }
139
140 tzinfo, err := time.LoadTzinfo(locationName, time.OrigZoneSources[len(time.OrigZoneSources)-1])
141 if err != nil {
142 t.Fatal(err)
143 }
144 sample, err := time.LoadLocationFromTZData(locationName, tzinfo)
145 if err != nil {
146 t.Fatal(err)
147 }
148
149 if !reflect.DeepEqual(reference, sample) {
150 t.Errorf("return values of LoadLocationFromTZData and LoadLocation don't match")
151 }
152 }
153
154
155 func TestEarlyLocation(t *testing.T) {
156 time.ForceZipFileForTesting(true)
157 defer time.ForceZipFileForTesting(false)
158
159 const locName = "America/New_York"
160 loc, err := time.LoadLocation(locName)
161 if err != nil {
162 t.Fatal(err)
163 }
164
165 d := time.Date(1900, time.January, 1, 0, 0, 0, 0, loc)
166 tzName, tzOffset := d.Zone()
167 if want := "EST"; tzName != want {
168 t.Errorf("Zone name == %s, want %s", tzName, want)
169 }
170 if want := -18000; tzOffset != want {
171 t.Errorf("Zone offset == %d, want %d", tzOffset, want)
172 }
173 }
174
175 func TestMalformedTZData(t *testing.T) {
176
177 issue29437 := "TZif\x00000000000000000\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0000"
178 _, err := time.LoadLocationFromTZData("abc", []byte(issue29437))
179 if err == nil {
180 t.Error("expected error, got none")
181 }
182 }
183
184 var slimTests = []struct {
185 zoneName string
186 fileName string
187 date func(*time.Location) time.Time
188 wantName string
189 wantOffset int
190 }{
191 {
192
193 zoneName: "Europe/Berlin",
194 fileName: "2020b_Europe_Berlin",
195 date: func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
196 wantName: "CET",
197 wantOffset: 3600,
198 },
199 {
200
201 zoneName: "America/Nuuk",
202 fileName: "2021a_America_Nuuk",
203 date: func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
204 wantName: "-03",
205 wantOffset: -10800,
206 },
207 {
208
209 zoneName: "Asia/Gaza",
210 fileName: "2021a_Asia_Gaza",
211 date: func(loc *time.Location) time.Time { return time.Date(2020, time.October, 29, 15, 30, 0, 0, loc) },
212 wantName: "EET",
213 wantOffset: 7200,
214 },
215 {
216
217 zoneName: "Europe/Dublin",
218 fileName: "2021a_Europe_Dublin",
219 date: func(loc *time.Location) time.Time { return time.Date(2021, time.April, 2, 11, 12, 13, 0, loc) },
220 wantName: "IST",
221 wantOffset: 3600,
222 },
223 }
224
225 func TestLoadLocationFromTZDataSlim(t *testing.T) {
226 for _, test := range slimTests {
227 tzData, err := os.ReadFile("testdata/" + test.fileName)
228 if err != nil {
229 t.Error(err)
230 continue
231 }
232 reference, err := time.LoadLocationFromTZData(test.zoneName, tzData)
233 if err != nil {
234 t.Error(err)
235 continue
236 }
237
238 d := test.date(reference)
239 tzName, tzOffset := d.Zone()
240 if tzName != test.wantName {
241 t.Errorf("Zone name == %s, want %s", tzName, test.wantName)
242 }
243 if tzOffset != test.wantOffset {
244 t.Errorf("Zone offset == %d, want %d", tzOffset, test.wantOffset)
245 }
246 }
247 }
248
249 func TestTzset(t *testing.T) {
250 for _, test := range []struct {
251 inStr string
252 inEnd int64
253 inSec int64
254 name string
255 off int
256 start int64
257 end int64
258 isDST bool
259 ok bool
260 }{
261 {"", 0, 0, "", 0, 0, 0, false, false},
262 {"PST8PDT,M3.2.0,M11.1.0", 0, 2159200800, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
263 {"PST8PDT,M3.2.0,M11.1.0", 0, 2152173599, "PST", -8 * 60 * 60, 2145916800, 2152173600, false, true},
264 {"PST8PDT,M3.2.0,M11.1.0", 0, 2152173600, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
265 {"PST8PDT,M3.2.0,M11.1.0", 0, 2152173601, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
266 {"PST8PDT,M3.2.0,M11.1.0", 0, 2172733199, "PDT", -7 * 60 * 60, 2152173600, 2172733200, true, true},
267 {"PST8PDT,M3.2.0,M11.1.0", 0, 2172733200, "PST", -8 * 60 * 60, 2172733200, 2177452800, false, true},
268 {"PST8PDT,M3.2.0,M11.1.0", 0, 2172733201, "PST", -8 * 60 * 60, 2172733200, 2177452800, false, true},
269 } {
270 name, off, start, end, isDST, ok := time.Tzset(test.inStr, test.inEnd, test.inSec)
271 if name != test.name || off != test.off || start != test.start || end != test.end || isDST != test.isDST || ok != test.ok {
272 t.Errorf("tzset(%q, %d, %d) = %q, %d, %d, %d, %t, %t, want %q, %d, %d, %d, %t, %t", test.inStr, test.inEnd, test.inSec, name, off, start, end, isDST, ok, test.name, test.off, test.start, test.end, test.isDST, test.ok)
273 }
274 }
275 }
276
277 func TestTzsetName(t *testing.T) {
278 for _, test := range []struct {
279 in string
280 name string
281 out string
282 ok bool
283 }{
284 {"", "", "", false},
285 {"X", "", "", false},
286 {"PST", "PST", "", true},
287 {"PST8PDT", "PST", "8PDT", true},
288 {"PST-08", "PST", "-08", true},
289 {"<A+B>+08", "A+B", "+08", true},
290 } {
291 name, out, ok := time.TzsetName(test.in)
292 if name != test.name || out != test.out || ok != test.ok {
293 t.Errorf("tzsetName(%q) = %q, %q, %t, want %q, %q, %t", test.in, name, out, ok, test.name, test.out, test.ok)
294 }
295 }
296 }
297
298 func TestTzsetOffset(t *testing.T) {
299 for _, test := range []struct {
300 in string
301 off int
302 out string
303 ok bool
304 }{
305 {"", 0, "", false},
306 {"X", 0, "", false},
307 {"+", 0, "", false},
308 {"+08", 8 * 60 * 60, "", true},
309 {"-01:02:03", -1*60*60 - 2*60 - 3, "", true},
310 {"01", 1 * 60 * 60, "", true},
311 {"100", 100 * 60 * 60, "", true},
312 {"1000", 0, "", false},
313 {"8PDT", 8 * 60 * 60, "PDT", true},
314 } {
315 off, out, ok := time.TzsetOffset(test.in)
316 if off != test.off || out != test.out || ok != test.ok {
317 t.Errorf("tzsetName(%q) = %d, %q, %t, want %d, %q, %t", test.in, off, out, ok, test.off, test.out, test.ok)
318 }
319 }
320 }
321
322 func TestTzsetRule(t *testing.T) {
323 for _, test := range []struct {
324 in string
325 r time.Rule
326 out string
327 ok bool
328 }{
329 {"", time.Rule{}, "", false},
330 {"X", time.Rule{}, "", false},
331 {"J10", time.Rule{Kind: time.RuleJulian, Day: 10, Time: 2 * 60 * 60}, "", true},
332 {"20", time.Rule{Kind: time.RuleDOY, Day: 20, Time: 2 * 60 * 60}, "", true},
333 {"M1.2.3", time.Rule{Kind: time.RuleMonthWeekDay, Mon: 1, Week: 2, Day: 3, Time: 2 * 60 * 60}, "", true},
334 {"30/03:00:00", time.Rule{Kind: time.RuleDOY, Day: 30, Time: 3 * 60 * 60}, "", true},
335 {"M4.5.6/03:00:00", time.Rule{Kind: time.RuleMonthWeekDay, Mon: 4, Week: 5, Day: 6, Time: 3 * 60 * 60}, "", true},
336 {"M4.5.7/03:00:00", time.Rule{}, "", false},
337 {"M4.5.6/-04", time.Rule{Kind: time.RuleMonthWeekDay, Mon: 4, Week: 5, Day: 6, Time: -4 * 60 * 60}, "", true},
338 } {
339 r, out, ok := time.TzsetRule(test.in)
340 if r != test.r || out != test.out || ok != test.ok {
341 t.Errorf("tzsetName(%q) = %#v, %q, %t, want %#v, %q, %t", test.in, r, out, ok, test.r, test.out, test.ok)
342 }
343 }
344 }
345
View as plain text