| package yaml_test |
| |
| import ( |
| . "gopkg.in/check.v1" |
| "gopkg.in/yaml.v1" |
| "math" |
| "reflect" |
| "strings" |
| "time" |
| ) |
| |
| var unmarshalIntTest = 123 |
| |
| var unmarshalTests = []struct { |
| data string |
| value interface{} |
| }{ |
| { |
| "", |
| &struct{}{}, |
| }, { |
| "{}", &struct{}{}, |
| }, { |
| "v: hi", |
| map[string]string{"v": "hi"}, |
| }, { |
| "v: hi", map[string]interface{}{"v": "hi"}, |
| }, { |
| "v: true", |
| map[string]string{"v": "true"}, |
| }, { |
| "v: true", |
| map[string]interface{}{"v": true}, |
| }, { |
| "v: 10", |
| map[string]interface{}{"v": 10}, |
| }, { |
| "v: 0b10", |
| map[string]interface{}{"v": 2}, |
| }, { |
| "v: 0xA", |
| map[string]interface{}{"v": 10}, |
| }, { |
| "v: 4294967296", |
| map[string]int64{"v": 4294967296}, |
| }, { |
| "v: 0.1", |
| map[string]interface{}{"v": 0.1}, |
| }, { |
| "v: .1", |
| map[string]interface{}{"v": 0.1}, |
| }, { |
| "v: .Inf", |
| map[string]interface{}{"v": math.Inf(+1)}, |
| }, { |
| "v: -.Inf", |
| map[string]interface{}{"v": math.Inf(-1)}, |
| }, { |
| "v: -10", |
| map[string]interface{}{"v": -10}, |
| }, { |
| "v: -.1", |
| map[string]interface{}{"v": -0.1}, |
| }, |
| |
| // Simple values. |
| { |
| "123", |
| &unmarshalIntTest, |
| }, |
| |
| // Floats from spec |
| { |
| "canonical: 6.8523e+5", |
| map[string]interface{}{"canonical": 6.8523e+5}, |
| }, { |
| "expo: 685.230_15e+03", |
| map[string]interface{}{"expo": 685.23015e+03}, |
| }, { |
| "fixed: 685_230.15", |
| map[string]interface{}{"fixed": 685230.15}, |
| }, { |
| "neginf: -.inf", |
| map[string]interface{}{"neginf": math.Inf(-1)}, |
| }, { |
| "fixed: 685_230.15", |
| map[string]float64{"fixed": 685230.15}, |
| }, |
| //{"sexa: 190:20:30.15", map[string]interface{}{"sexa": 0}}, // Unsupported |
| //{"notanum: .NaN", map[string]interface{}{"notanum": math.NaN()}}, // Equality of NaN fails. |
| |
| // Bools from spec |
| { |
| "canonical: y", |
| map[string]interface{}{"canonical": true}, |
| }, { |
| "answer: NO", |
| map[string]interface{}{"answer": false}, |
| }, { |
| "logical: True", |
| map[string]interface{}{"logical": true}, |
| }, { |
| "option: on", |
| map[string]interface{}{"option": true}, |
| }, { |
| "option: on", |
| map[string]bool{"option": true}, |
| }, |
| // Ints from spec |
| { |
| "canonical: 685230", |
| map[string]interface{}{"canonical": 685230}, |
| }, { |
| "decimal: +685_230", |
| map[string]interface{}{"decimal": 685230}, |
| }, { |
| "octal: 02472256", |
| map[string]interface{}{"octal": 685230}, |
| }, { |
| "hexa: 0x_0A_74_AE", |
| map[string]interface{}{"hexa": 685230}, |
| }, { |
| "bin: 0b1010_0111_0100_1010_1110", |
| map[string]interface{}{"bin": 685230}, |
| }, { |
| "bin: -0b101010", |
| map[string]interface{}{"bin": -42}, |
| }, { |
| "decimal: +685_230", |
| map[string]int{"decimal": 685230}, |
| }, |
| |
| //{"sexa: 190:20:30", map[string]interface{}{"sexa": 0}}, // Unsupported |
| |
| // Nulls from spec |
| { |
| "empty:", |
| map[string]interface{}{"empty": nil}, |
| }, { |
| "canonical: ~", |
| map[string]interface{}{"canonical": nil}, |
| }, { |
| "english: null", |
| map[string]interface{}{"english": nil}, |
| }, { |
| "~: null key", |
| map[interface{}]string{nil: "null key"}, |
| }, { |
| "empty:", |
| map[string]*bool{"empty": nil}, |
| }, |
| |
| // Flow sequence |
| { |
| "seq: [A,B]", |
| map[string]interface{}{"seq": []interface{}{"A", "B"}}, |
| }, { |
| "seq: [A,B,C,]", |
| map[string][]string{"seq": []string{"A", "B", "C"}}, |
| }, { |
| "seq: [A,1,C]", |
| map[string][]string{"seq": []string{"A", "1", "C"}}, |
| }, { |
| "seq: [A,1,C]", |
| map[string][]int{"seq": []int{1}}, |
| }, { |
| "seq: [A,1,C]", |
| map[string]interface{}{"seq": []interface{}{"A", 1, "C"}}, |
| }, |
| // Block sequence |
| { |
| "seq:\n - A\n - B", |
| map[string]interface{}{"seq": []interface{}{"A", "B"}}, |
| }, { |
| "seq:\n - A\n - B\n - C", |
| map[string][]string{"seq": []string{"A", "B", "C"}}, |
| }, { |
| "seq:\n - A\n - 1\n - C", |
| map[string][]string{"seq": []string{"A", "1", "C"}}, |
| }, { |
| "seq:\n - A\n - 1\n - C", |
| map[string][]int{"seq": []int{1}}, |
| }, { |
| "seq:\n - A\n - 1\n - C", |
| map[string]interface{}{"seq": []interface{}{"A", 1, "C"}}, |
| }, |
| |
| // Literal block scalar |
| { |
| "scalar: | # Comment\n\n literal\n\n \ttext\n\n", |
| map[string]string{"scalar": "\nliteral\n\n\ttext\n"}, |
| }, |
| |
| // Folded block scalar |
| { |
| "scalar: > # Comment\n\n folded\n line\n \n next\n line\n * one\n * two\n\n last\n line\n\n", |
| map[string]string{"scalar": "\nfolded line\nnext line\n * one\n * two\n\nlast line\n"}, |
| }, |
| |
| // Map inside interface with no type hints. |
| { |
| "a: {b: c}", |
| map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}}, |
| }, |
| |
| // Structs and type conversions. |
| { |
| "hello: world", |
| &struct{ Hello string }{"world"}, |
| }, { |
| "a: {b: c}", |
| &struct{ A struct{ B string } }{struct{ B string }{"c"}}, |
| }, { |
| "a: {b: c}", |
| &struct{ A *struct{ B string } }{&struct{ B string }{"c"}}, |
| }, { |
| "a: {b: c}", |
| &struct{ A map[string]string }{map[string]string{"b": "c"}}, |
| }, { |
| "a: {b: c}", |
| &struct{ A *map[string]string }{&map[string]string{"b": "c"}}, |
| }, { |
| "a:", |
| &struct{ A map[string]string }{}, |
| }, { |
| "a: 1", |
| &struct{ A int }{1}, |
| }, { |
| "a: 1", |
| &struct{ A float64 }{1}, |
| }, { |
| "a: 1.0", |
| &struct{ A int }{1}, |
| }, { |
| "a: 1.0", |
| &struct{ A uint }{1}, |
| }, { |
| "a: [1, 2]", |
| &struct{ A []int }{[]int{1, 2}}, |
| }, { |
| "a: 1", |
| &struct{ B int }{0}, |
| }, { |
| "a: 1", |
| &struct { |
| B int "a" |
| }{1}, |
| }, { |
| "a: y", |
| &struct{ A bool }{true}, |
| }, |
| |
| // Some cross type conversions |
| { |
| "v: 42", |
| map[string]uint{"v": 42}, |
| }, { |
| "v: -42", |
| map[string]uint{}, |
| }, { |
| "v: 4294967296", |
| map[string]uint64{"v": 4294967296}, |
| }, { |
| "v: -4294967296", |
| map[string]uint64{}, |
| }, |
| |
| // Overflow cases. |
| { |
| "v: 4294967297", |
| map[string]int32{}, |
| }, { |
| "v: 128", |
| map[string]int8{}, |
| }, |
| |
| // Quoted values. |
| { |
| "'1': '\"2\"'", |
| map[interface{}]interface{}{"1": "\"2\""}, |
| }, { |
| "v:\n- A\n- 'B\n\n C'\n", |
| map[string][]string{"v": []string{"A", "B\nC"}}, |
| }, |
| |
| // Explicit tags. |
| { |
| "v: !!float '1.1'", |
| map[string]interface{}{"v": 1.1}, |
| }, { |
| "v: !!null ''", |
| map[string]interface{}{"v": nil}, |
| }, { |
| "%TAG !y! tag:yaml.org,2002:\n---\nv: !y!int '1'", |
| map[string]interface{}{"v": 1}, |
| }, |
| |
| // Anchors and aliases. |
| { |
| "a: &x 1\nb: &y 2\nc: *x\nd: *y\n", |
| &struct{ A, B, C, D int }{1, 2, 1, 2}, |
| }, { |
| "a: &a {c: 1}\nb: *a", |
| &struct { |
| A, B struct { |
| C int |
| } |
| }{struct{ C int }{1}, struct{ C int }{1}}, |
| }, { |
| "a: &a [1, 2]\nb: *a", |
| &struct{ B []int }{[]int{1, 2}}, |
| }, |
| |
| // Bug #1133337 |
| { |
| "foo: ''", |
| map[string]*string{"foo": new(string)}, |
| }, { |
| "foo: null", |
| map[string]string{"foo": ""}, |
| }, { |
| "foo: null", |
| map[string]interface{}{"foo": nil}, |
| }, |
| |
| // Ignored field |
| { |
| "a: 1\nb: 2\n", |
| &struct { |
| A int |
| B int "-" |
| }{1, 0}, |
| }, |
| |
| // Bug #1191981 |
| { |
| "" + |
| "%YAML 1.1\n" + |
| "--- !!str\n" + |
| `"Generic line break (no glyph)\n\` + "\n" + |
| ` Generic line break (glyphed)\n\` + "\n" + |
| ` Line separator\u2028\` + "\n" + |
| ` Paragraph separator\u2029"` + "\n", |
| "" + |
| "Generic line break (no glyph)\n" + |
| "Generic line break (glyphed)\n" + |
| "Line separator\u2028Paragraph separator\u2029", |
| }, |
| |
| // Struct inlining |
| { |
| "a: 1\nb: 2\nc: 3\n", |
| &struct { |
| A int |
| C inlineB `yaml:",inline"` |
| }{1, inlineB{2, inlineC{3}}}, |
| }, |
| |
| // bug 1243827 |
| { |
| "a: -b_c", |
| map[string]interface{}{"a": "-b_c"}, |
| }, |
| { |
| "a: +b_c", |
| map[string]interface{}{"a": "+b_c"}, |
| }, |
| { |
| "a: 50cent_of_dollar", |
| map[string]interface{}{"a": "50cent_of_dollar"}, |
| }, |
| |
| // Duration |
| { |
| "a: 3s", |
| map[string]time.Duration{"a": 3 * time.Second}, |
| }, |
| |
| // Issue #24. |
| { |
| "a: <foo>", |
| map[string]string{"a": "<foo>"}, |
| }, |
| |
| // Base 60 floats are obsolete and unsupported. |
| { |
| "a: 1:1\n", |
| map[string]string{"a": "1:1"}, |
| }, |
| |
| // Binary data. |
| { |
| "a: !!binary gIGC\n", |
| map[string]string{"a": "\x80\x81\x82"}, |
| }, { |
| "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n", |
| map[string]string{"a": strings.Repeat("\x90", 54)}, |
| }, { |
| "a: !!binary |\n " + strings.Repeat("A", 70) + "\n ==\n", |
| map[string]string{"a": strings.Repeat("\x00", 52)}, |
| }, |
| } |
| |
| type inlineB struct { |
| B int |
| inlineC `yaml:",inline"` |
| } |
| |
| type inlineC struct { |
| C int |
| } |
| |
| func (s *S) TestUnmarshal(c *C) { |
| for i, item := range unmarshalTests { |
| t := reflect.ValueOf(item.value).Type() |
| var value interface{} |
| switch t.Kind() { |
| case reflect.Map: |
| value = reflect.MakeMap(t).Interface() |
| case reflect.String: |
| t := reflect.ValueOf(item.value).Type() |
| v := reflect.New(t) |
| value = v.Interface() |
| default: |
| pt := reflect.ValueOf(item.value).Type() |
| pv := reflect.New(pt.Elem()) |
| value = pv.Interface() |
| } |
| err := yaml.Unmarshal([]byte(item.data), value) |
| c.Assert(err, IsNil, Commentf("Item #%d", i)) |
| if t.Kind() == reflect.String { |
| c.Assert(*value.(*string), Equals, item.value, Commentf("Item #%d", i)) |
| } else { |
| c.Assert(value, DeepEquals, item.value, Commentf("Item #%d", i)) |
| } |
| } |
| } |
| |
| func (s *S) TestUnmarshalNaN(c *C) { |
| value := map[string]interface{}{} |
| err := yaml.Unmarshal([]byte("notanum: .NaN"), &value) |
| c.Assert(err, IsNil) |
| c.Assert(math.IsNaN(value["notanum"].(float64)), Equals, true) |
| } |
| |
| var unmarshalErrorTests = []struct { |
| data, error string |
| }{ |
| {"v: !!float 'error'", "YAML error: cannot decode !!str `error` as a !!float"}, |
| {"v: [A,", "YAML error: line 1: did not find expected node content"}, |
| {"v:\n- [A,", "YAML error: line 2: did not find expected node content"}, |
| {"a: *b\n", "YAML error: Unknown anchor 'b' referenced"}, |
| {"a: &a\n b: *a\n", "YAML error: Anchor 'a' value contains itself"}, |
| {"value: -", "YAML error: block sequence entries are not allowed in this context"}, |
| {"a: !!binary ==", "YAML error: !!binary value contains invalid base64 data"}, |
| {"{[.]}", `YAML error: invalid map key: \[\]interface \{\}\{"\."\}`}, |
| {"{{.}}", `YAML error: invalid map key: map\[interface\ \{\}\]interface \{\}\{".":interface \{\}\(nil\)\}`}, |
| } |
| |
| func (s *S) TestUnmarshalErrors(c *C) { |
| for _, item := range unmarshalErrorTests { |
| var value interface{} |
| err := yaml.Unmarshal([]byte(item.data), &value) |
| c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value)) |
| } |
| } |
| |
| var setterTests = []struct { |
| data, tag string |
| value interface{} |
| }{ |
| {"_: {hi: there}", "!!map", map[interface{}]interface{}{"hi": "there"}}, |
| {"_: [1,A]", "!!seq", []interface{}{1, "A"}}, |
| {"_: 10", "!!int", 10}, |
| {"_: null", "!!null", nil}, |
| {`_: BAR!`, "!!str", "BAR!"}, |
| {`_: "BAR!"`, "!!str", "BAR!"}, |
| {"_: !!foo 'BAR!'", "!!foo", "BAR!"}, |
| } |
| |
| var setterResult = map[int]bool{} |
| |
| type typeWithSetter struct { |
| tag string |
| value interface{} |
| } |
| |
| func (o *typeWithSetter) SetYAML(tag string, value interface{}) (ok bool) { |
| o.tag = tag |
| o.value = value |
| if i, ok := value.(int); ok { |
| if result, ok := setterResult[i]; ok { |
| return result |
| } |
| } |
| return true |
| } |
| |
| type setterPointerType struct { |
| Field *typeWithSetter "_" |
| } |
| |
| type setterValueType struct { |
| Field typeWithSetter "_" |
| } |
| |
| func (s *S) TestUnmarshalWithPointerSetter(c *C) { |
| for _, item := range setterTests { |
| obj := &setterPointerType{} |
| err := yaml.Unmarshal([]byte(item.data), obj) |
| c.Assert(err, IsNil) |
| c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value)) |
| c.Assert(obj.Field.tag, Equals, item.tag) |
| c.Assert(obj.Field.value, DeepEquals, item.value) |
| } |
| } |
| |
| func (s *S) TestUnmarshalWithValueSetter(c *C) { |
| for _, item := range setterTests { |
| obj := &setterValueType{} |
| err := yaml.Unmarshal([]byte(item.data), obj) |
| c.Assert(err, IsNil) |
| c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value)) |
| c.Assert(obj.Field.tag, Equals, item.tag) |
| c.Assert(obj.Field.value, DeepEquals, item.value) |
| } |
| } |
| |
| func (s *S) TestUnmarshalWholeDocumentWithSetter(c *C) { |
| obj := &typeWithSetter{} |
| err := yaml.Unmarshal([]byte(setterTests[0].data), obj) |
| c.Assert(err, IsNil) |
| c.Assert(obj.tag, Equals, setterTests[0].tag) |
| value, ok := obj.value.(map[interface{}]interface{}) |
| c.Assert(ok, Equals, true) |
| c.Assert(value["_"], DeepEquals, setterTests[0].value) |
| } |
| |
| func (s *S) TestUnmarshalWithFalseSetterIgnoresValue(c *C) { |
| setterResult[2] = false |
| setterResult[4] = false |
| defer func() { |
| delete(setterResult, 2) |
| delete(setterResult, 4) |
| }() |
| |
| m := map[string]*typeWithSetter{} |
| data := `{abc: 1, def: 2, ghi: 3, jkl: 4}` |
| err := yaml.Unmarshal([]byte(data), m) |
| c.Assert(err, IsNil) |
| c.Assert(m["abc"], NotNil) |
| c.Assert(m["def"], IsNil) |
| c.Assert(m["ghi"], NotNil) |
| c.Assert(m["jkl"], IsNil) |
| |
| c.Assert(m["abc"].value, Equals, 1) |
| c.Assert(m["ghi"].value, Equals, 3) |
| } |
| |
| // From http://yaml.org/type/merge.html |
| var mergeTests = ` |
| anchors: |
| - &CENTER { "x": 1, "y": 2 } |
| - &LEFT { "x": 0, "y": 2 } |
| - &BIG { "r": 10 } |
| - &SMALL { "r": 1 } |
| |
| # All the following maps are equal: |
| |
| plain: |
| # Explicit keys |
| "x": 1 |
| "y": 2 |
| "r": 10 |
| label: center/big |
| |
| mergeOne: |
| # Merge one map |
| << : *CENTER |
| "r": 10 |
| label: center/big |
| |
| mergeMultiple: |
| # Merge multiple maps |
| << : [ *CENTER, *BIG ] |
| label: center/big |
| |
| override: |
| # Override |
| << : [ *BIG, *LEFT, *SMALL ] |
| "x": 1 |
| label: center/big |
| |
| shortTag: |
| # Explicit short merge tag |
| !!merge "<<" : [ *CENTER, *BIG ] |
| label: center/big |
| |
| longTag: |
| # Explicit merge long tag |
| !<tag:yaml.org,2002:merge> "<<" : [ *CENTER, *BIG ] |
| label: center/big |
| |
| inlineMap: |
| # Inlined map |
| << : {"x": 1, "y": 2, "r": 10} |
| label: center/big |
| |
| inlineSequenceMap: |
| # Inlined map in sequence |
| << : [ *CENTER, {"r": 10} ] |
| label: center/big |
| ` |
| |
| func (s *S) TestMerge(c *C) { |
| var want = map[interface{}]interface{}{ |
| "x": 1, |
| "y": 2, |
| "r": 10, |
| "label": "center/big", |
| } |
| |
| var m map[string]interface{} |
| err := yaml.Unmarshal([]byte(mergeTests), &m) |
| c.Assert(err, IsNil) |
| for name, test := range m { |
| if name == "anchors" { |
| continue |
| } |
| c.Assert(test, DeepEquals, want, Commentf("test %q failed", name)) |
| } |
| } |
| |
| func (s *S) TestMergeStruct(c *C) { |
| type Data struct { |
| X, Y, R int |
| Label string |
| } |
| want := Data{1, 2, 10, "center/big"} |
| |
| var m map[string]Data |
| err := yaml.Unmarshal([]byte(mergeTests), &m) |
| c.Assert(err, IsNil) |
| for name, test := range m { |
| if name == "anchors" { |
| continue |
| } |
| c.Assert(test, Equals, want, Commentf("test %q failed", name)) |
| } |
| } |
| |
| var unmarshalNullTests = []func() interface{}{ |
| func() interface{} { var v interface{}; v = "v"; return &v }, |
| func() interface{} { var s = "s"; return &s }, |
| func() interface{} { var s = "s"; sptr := &s; return &sptr }, |
| func() interface{} { var i = 1; return &i }, |
| func() interface{} { var i = 1; iptr := &i; return &iptr }, |
| func() interface{} { m := map[string]int{"s": 1}; return &m }, |
| func() interface{} { m := map[string]int{"s": 1}; return m }, |
| } |
| |
| func (s *S) TestUnmarshalNull(c *C) { |
| for _, test := range unmarshalNullTests { |
| item := test() |
| zero := reflect.Zero(reflect.TypeOf(item).Elem()).Interface() |
| err := yaml.Unmarshal([]byte("null"), item) |
| c.Assert(err, IsNil) |
| if reflect.TypeOf(item).Kind() == reflect.Map { |
| c.Assert(reflect.ValueOf(item).Interface(), DeepEquals, reflect.MakeMap(reflect.TypeOf(item)).Interface()) |
| } else { |
| c.Assert(reflect.ValueOf(item).Elem().Interface(), DeepEquals, zero) |
| } |
| } |
| } |
| |
| //var data []byte |
| //func init() { |
| // var err error |
| // data, err = ioutil.ReadFile("/tmp/file.yaml") |
| // if err != nil { |
| // panic(err) |
| // } |
| //} |
| // |
| //func (s *S) BenchmarkUnmarshal(c *C) { |
| // var err error |
| // for i := 0; i < c.N; i++ { |
| // var v map[string]interface{} |
| // err = yaml.Unmarshal(data, &v) |
| // } |
| // if err != nil { |
| // panic(err) |
| // } |
| //} |
| // |
| //func (s *S) BenchmarkMarshal(c *C) { |
| // var v map[string]interface{} |
| // yaml.Unmarshal(data, &v) |
| // c.ResetTimer() |
| // for i := 0; i < c.N; i++ { |
| // yaml.Marshal(&v) |
| // } |
| //} |
