Source file src/time/zoneinfo_test.go

Documentation: time

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     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  	defer os.Setenv(env, os.Getenv(env))
    29  	os.Setenv(env, testZoneinfo)
    30  
    31  	// Result isn't important, we're testing the side effect of this command
    32  	time.LoadLocation("Asia/Jerusalem")
    33  	defer time.ResetZoneinfoForTesting()
    34  
    35  	if zoneinfo := time.ZoneinfoForTesting(); testZoneinfo != *zoneinfo {
    36  		t.Errorf("zoneinfo does not match env variable: got %q want %q", *zoneinfo, testZoneinfo)
    37  	}
    38  }
    39  
    40  func TestBadLocationErrMsg(t *testing.T) {
    41  	time.ResetZoneinfoForTesting()
    42  	loc := "Asia/SomethingNotExist"
    43  	want := errors.New("unknown time zone " + loc)
    44  	_, err := time.LoadLocation(loc)
    45  	if err.Error() != want.Error() {
    46  		t.Errorf("LoadLocation(%q) error = %v; want %v", loc, err, want)
    47  	}
    48  }
    49  
    50  func TestLoadLocationValidatesNames(t *testing.T) {
    51  	time.ResetZoneinfoForTesting()
    52  	const env = "ZONEINFO"
    53  	defer os.Setenv(env, os.Getenv(env))
    54  	os.Setenv(env, "")
    55  
    56  	bad := []string{
    57  		"/usr/foo/Foo",
    58  		"\\UNC\foo",
    59  		"..",
    60  		"a..",
    61  	}
    62  	for _, v := range bad {
    63  		_, err := time.LoadLocation(v)
    64  		if err != time.ErrLocation {
    65  			t.Errorf("LoadLocation(%q) error = %v; want ErrLocation", v, err)
    66  		}
    67  	}
    68  }
    69  
    70  func TestVersion3(t *testing.T) {
    71  	time.ForceZipFileForTesting(true)
    72  	defer time.ForceZipFileForTesting(false)
    73  	_, err := time.LoadLocation("Asia/Jerusalem")
    74  	if err != nil {
    75  		t.Fatal(err)
    76  	}
    77  }
    78  
    79  // Test that we get the correct results for times before the first
    80  // transition time. To do this we explicitly check early dates in a
    81  // couple of specific timezones.
    82  func TestFirstZone(t *testing.T) {
    83  	time.ForceZipFileForTesting(true)
    84  	defer time.ForceZipFileForTesting(false)
    85  
    86  	const format = "Mon, 02 Jan 2006 15:04:05 -0700 (MST)"
    87  	var tests = []struct {
    88  		zone  string
    89  		unix  int64
    90  		want1 string
    91  		want2 string
    92  	}{
    93  		{
    94  			"PST8PDT",
    95  			-1633269601,
    96  			"Sun, 31 Mar 1918 01:59:59 -0800 (PST)",
    97  			"Sun, 31 Mar 1918 03:00:00 -0700 (PDT)",
    98  		},
    99  		{
   100  			"Pacific/Fakaofo",
   101  			1325242799,
   102  			"Thu, 29 Dec 2011 23:59:59 -1100 (-11)",
   103  			"Sat, 31 Dec 2011 00:00:00 +1300 (+13)",
   104  		},
   105  	}
   106  
   107  	for _, test := range tests {
   108  		z, err := time.LoadLocation(test.zone)
   109  		if err != nil {
   110  			t.Fatal(err)
   111  		}
   112  		s := time.Unix(test.unix, 0).In(z).Format(format)
   113  		if s != test.want1 {
   114  			t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want1)
   115  		}
   116  		s = time.Unix(test.unix+1, 0).In(z).Format(format)
   117  		if s != test.want2 {
   118  			t.Errorf("for %s %d got %q want %q", test.zone, test.unix, s, test.want2)
   119  		}
   120  	}
   121  }
   122  
   123  func TestLocationNames(t *testing.T) {
   124  	if time.Local.String() != "Local" {
   125  		t.Errorf(`invalid Local location name: got %q want "Local"`, time.Local)
   126  	}
   127  	if time.UTC.String() != "UTC" {
   128  		t.Errorf(`invalid UTC location name: got %q want "UTC"`, time.UTC)
   129  	}
   130  }
   131  
   132  func TestLoadLocationFromTZData(t *testing.T) {
   133  	time.ForceZipFileForTesting(true)
   134  	defer time.ForceZipFileForTesting(false)
   135  
   136  	const locationName = "Asia/Jerusalem"
   137  	reference, err := time.LoadLocation(locationName)
   138  	if err != nil {
   139  		t.Fatal(err)
   140  	}
   141  
   142  	tzinfo, err := time.LoadTzinfo(locationName, time.OrigZoneSources[len(time.OrigZoneSources)-1])
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  	sample, err := time.LoadLocationFromTZData(locationName, tzinfo)
   147  	if err != nil {
   148  		t.Fatal(err)
   149  	}
   150  
   151  	if !reflect.DeepEqual(reference, sample) {
   152  		t.Errorf("return values of LoadLocationFromTZData and LoadLocation don't match")
   153  	}
   154  }
   155  
   156  // Issue 30099.
   157  func TestEarlyLocation(t *testing.T) {
   158  	time.ForceZipFileForTesting(true)
   159  	defer time.ForceZipFileForTesting(false)
   160  
   161  	const locName = "America/New_York"
   162  	loc, err := time.LoadLocation(locName)
   163  	if err != nil {
   164  		t.Fatal(err)
   165  	}
   166  
   167  	d := time.Date(1900, time.January, 1, 0, 0, 0, 0, loc)
   168  	tzName, tzOffset := d.Zone()
   169  	if want := "EST"; tzName != want {
   170  		t.Errorf("Zone name == %s, want %s", tzName, want)
   171  	}
   172  	if want := -18000; tzOffset != want {
   173  		t.Errorf("Zone offset == %d, want %d", tzOffset, want)
   174  	}
   175  }
   176  
   177  func TestMalformedTZData(t *testing.T) {
   178  	// The goal here is just that malformed tzdata results in an error, not a panic.
   179  	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"
   180  	_, err := time.LoadLocationFromTZData("abc", []byte(issue29437))
   181  	if err == nil {
   182  		t.Error("expected error, got none")
   183  	}
   184  }
   185  

View as plain text