[dev.power64] code review 152570049: all: merge default into dev.power64

src/encoding/asn1/asn1_test.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package asn1
 
 import (
         "bytes"
         "fmt"
         "math/big"
@@ skipping 374 matching lines @@
 
 type TestContextSpecificTags struct {
         A int `asn1:"tag:1"`
 }
 
 type TestContextSpecificTags2 struct {
         A int `asn1:"explicit,tag:1"`
         B int
 }
 
+type TestContextSpecificTags3 struct {
+        S string `asn1:"tag:1,utf8"`
+}
+
 type TestElementsAfterString struct {
         S    string
         A, B int
 }
 
 type TestBigInt struct {
         X *big.Int
 }
 
 type TestSet struct {
         Ints []int `asn1:"set"`
 }
 
 var unmarshalTestData = []struct {
         in  []byte
         out interface{}
 }{
         {[]byte{0x02, 0x01, 0x42}, newInt(0x42)},
         {[]byte{0x30, 0x08, 0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d}, &TestObjectIdentifierStruct{[]int{1, 2, 840, 113549}}},
         {[]byte{0x03, 0x04, 0x06, 0x6e, 0x5d, 0xc0}, &BitString{[]byte{110, 93, 192}, 18}},
         {[]byte{0x30, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03}, &[]int{1, 2, 3}},
         {[]byte{0x02, 0x01, 0x10}, newInt(16)},
         {[]byte{0x13, 0x04, 't', 'e', 's', 't'}, newString("test")},
         {[]byte{0x16, 0x04, 't', 'e', 's', 't'}, newString("test")},
         {[]byte{0x16, 0x04, 't', 'e', 's', 't'}, &RawValue{0, 22, false, []byte("test"), []byte("\x16\x04test")}},
         {[]byte{0x04, 0x04, 1, 2, 3, 4}, &RawValue{0, 4, false, []byte{1, 2, 3, 4}, []byte{4, 4, 1, 2, 3, 4}}},
         {[]byte{0x30, 0x03, 0x81, 0x01, 0x01}, &TestContextSpecificTags{1}},
         {[]byte{0x30, 0x08, 0xa1, 0x03, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02}, &TestContextSpecificTags2{1, 2}},
+        {[]byte{0x30, 0x03, 0x81, 0x01, '@'}, &TestContextSpecificTags3{"@"}},
         {[]byte{0x01, 0x01, 0x00}, newBool(false)},
         {[]byte{0x01, 0x01, 0xff}, newBool(true)},
         {[]byte{0x30, 0x0b, 0x13, 0x03, 0x66, 0x6f, 0x6f, 0x02, 0x01, 0x22, 0x02, 0x01, 0x33}, &TestElementsAfterString{"foo", 0x22, 0x33}},
         {[]byte{0x30, 0x05, 0x02, 0x03, 0x12, 0x34, 0x56}, &TestBigInt{big.NewInt(0x123456)}},
         {[]byte{0x30, 0x0b, 0x31, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03}, &TestSet{Ints: []int{1, 2, 3}}},
 }
 
 func TestUnmarshal(t *testing.T) {
         for i, test := range unmarshalTestData {
                 pv := reflect.New(reflect.TypeOf(test.out).Elem())
@@ skipping 372 matching lines @@
                 _, err = Unmarshal(bs, &res)
                 if err != nil {
                         t.Error(err)
                 }
 
                 if fmt.Sprintf("%v", res) != fmt.Sprintf("%v", test) {
                         t.Errorf("incorrect marshal/unmarshal; %v != %v", res, test)
                 }
         }
 }
+
+type explicitTaggedTimeTest struct {
+        Time time.Time `asn1:"explicit,tag:0"`
+}
+
+var explicitTaggedTimeTestData = []struct {
+        in  []byte
+        out explicitTaggedTimeTest
+}{
+        {[]byte{0x30, 0x11, 0xa0, 0xf, 0x17, 0xd, '9', '1', '0', '5', '0', '6', '1', '6', '4', '5', '4', '0', 'Z'},
+                explicitTaggedTimeTest{time.Date(1991, 05, 06, 16, 45, 40, 0, time.UTC)}},
+        {[]byte{0x30, 0x17, 0xa0, 0xf, 0x18, 0x13, '2', '0', '1', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '+', '0', '6', '0', '7'},
+                explicitTaggedTimeTest{time.Date(2010, 01, 02, 03, 04, 05, 0, time.FixedZone("", 6*60*60+7*60))}},
+}
+
+func TestExplicitTaggedTime(t *testing.T) {
+        // Test that a time.Time will match either tagUTCTime or
+        // tagGeneralizedTime.
+        for i, test := range explicitTaggedTimeTestData {
+                var got explicitTaggedTimeTest
+                _, err := Unmarshal(test.in, &got)
+                if err != nil {
+                        t.Errorf("Unmarshal failed at index %d %v", i, err)
+                }
+                if !got.Time.Equal(test.out.Time) {
+                        t.Errorf("#%d: got %v, want %v", i, got.Time, test.out.Time)
+                }
+        }
+}
+
+type implicitTaggedTimeTest struct {
+        Time time.Time `asn1:"tag:24"`
+}
+
+func TestImplicitTaggedTime(t *testing.T) {
+        // An implicitly tagged time value, that happens to have an implicit
+        // tag equal to a GENERALIZEDTIME, should still be parsed as a UTCTime.
+        // (There's no "timeType" in fieldParameters to determine what type of
+        // time should be expected when implicitly tagged.)
+        der := []byte{0x30, 0x0f, 0x80 | 24, 0xd, '9', '1', '0', '5', '0', '6', '1', '6', '4', '5', '4', '0', 'Z'}
+        var result implicitTaggedTimeTest
+        if _, err := Unmarshal(der, &result); err != nil {
+                t.Fatalf("Error while parsing: %s", err)
+        }
+        if expected := time.Date(1991, 05, 06, 16, 45, 40, 0, time.UTC); !result.Time.Equal(expected) {
+                t.Errorf("Wrong result. Got %v, want %v", result.Time, expected)
+        }
+}