diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 12:36:04 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 12:36:04 +0000 |
commit | b09c6d56832eb1718c07d74abf3bc6ae3fe4e030 (patch) | |
tree | d2caec2610d4ea887803ec9e9c3cd77136c448ba /dependencies/pkg/mod/github.com/goccy/go-yaml@v1.9.6/decode_test.go | |
parent | Initial commit. (diff) | |
download | icingadb-upstream.tar.xz icingadb-upstream.zip |
Adding upstream version 1.1.0.upstream/1.1.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | dependencies/pkg/mod/github.com/goccy/go-yaml@v1.9.6/decode_test.go | 2734 |
1 files changed, 2734 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/github.com/goccy/go-yaml@v1.9.6/decode_test.go b/dependencies/pkg/mod/github.com/goccy/go-yaml@v1.9.6/decode_test.go new file mode 100644 index 0000000..af6e454 --- /dev/null +++ b/dependencies/pkg/mod/github.com/goccy/go-yaml@v1.9.6/decode_test.go @@ -0,0 +1,2734 @@ +package yaml_test + +import ( + "bytes" + "context" + "fmt" + "io" + "log" + "math" + "net" + "reflect" + "strconv" + "strings" + "testing" + "time" + + "github.com/goccy/go-yaml" + "github.com/goccy/go-yaml/ast" + "github.com/goccy/go-yaml/internal/errors" + "github.com/goccy/go-yaml/parser" + "golang.org/x/xerrors" +) + +type Child struct { + B int + C int `yaml:"-"` +} + +func TestDecoder(t *testing.T) { + tests := []struct { + source string + value interface{} + }{ + { + "null\n", + (*struct{})(nil), + }, + { + "v: hi\n", + map[string]string{"v": "hi"}, + }, + { + "v: \"true\"\n", + map[string]string{"v": "true"}, + }, + { + "v: \"false\"\n", + map[string]string{"v": "false"}, + }, + { + "v: true\n", + map[string]interface{}{"v": true}, + }, + { + "v: true\n", + map[string]string{"v": "true"}, + }, + { + "v: 10\n", + map[string]string{"v": "10"}, + }, + { + "v: -10\n", + map[string]string{"v": "-10"}, + }, + { + "v: 1.234\n", + map[string]string{"v": "1.234"}, + }, + { + "v: false\n", + map[string]bool{"v": false}, + }, + { + "v: 10\n", + map[string]int{"v": 10}, + }, + { + "v: 10", + map[string]interface{}{"v": 10}, + }, + { + "v: 0b10", + map[string]interface{}{"v": 2}, + }, + { + "v: -0b101010", + map[string]interface{}{"v": -42}, + }, + { + "v: -0b1000000000000000000000000000000000000000000000000000000000000000", + map[string]interface{}{"v": int64(-9223372036854775808)}, + }, + { + "v: 0xA", + map[string]interface{}{"v": 10}, + }, + { + "v: .1", + map[string]interface{}{"v": 0.1}, + }, + { + "v: -.1", + map[string]interface{}{"v": -0.1}, + }, + { + "v: -10\n", + map[string]int{"v": -10}, + }, + { + "v: 4294967296\n", + map[string]int64{"v": int64(4294967296)}, + }, + { + "v: 0.1\n", + map[string]interface{}{"v": 0.1}, + }, + { + "v: 0.99\n", + map[string]float32{"v": 0.99}, + }, + { + "v: -0.1\n", + map[string]float64{"v": -0.1}, + }, + { + "v: 6.8523e+5", + map[string]interface{}{"v": 6.8523e+5}, + }, + { + "v: 685.230_15e+03", + map[string]interface{}{"v": 685.23015e+03}, + }, + { + "v: 685_230.15", + map[string]interface{}{"v": 685230.15}, + }, + { + "v: 685_230.15", + map[string]float64{"v": 685230.15}, + }, + { + "v: 685230", + map[string]interface{}{"v": 685230}, + }, + { + "v: +685_230", + map[string]interface{}{"v": 685230}, + }, + { + "v: 02472256", + map[string]interface{}{"v": 685230}, + }, + { + "v: 0x_0A_74_AE", + map[string]interface{}{"v": 685230}, + }, + { + "v: 0b1010_0111_0100_1010_1110", + map[string]interface{}{"v": 685230}, + }, + { + "v: +685_230", + map[string]int{"v": 685230}, + }, + + // Bools from spec + { + "v: True", + map[string]interface{}{"v": true}, + }, + { + "v: TRUE", + map[string]interface{}{"v": true}, + }, + { + "v: False", + map[string]interface{}{"v": false}, + }, + { + "v: FALSE", + map[string]interface{}{"v": false}, + }, + { + "v: y", + map[string]interface{}{"v": "y"}, // y or yes or Yes is string + }, + { + "v: NO", + map[string]interface{}{"v": "NO"}, // no or No or NO is string + }, + { + "v: on", + map[string]interface{}{"v": "on"}, // on is string + }, + + // Some cross type conversions + { + "v: 42", + map[string]uint{"v": 42}, + }, { + "v: 4294967296", + map[string]uint64{"v": uint64(4294967296)}, + }, + + // int + { + "v: 2147483647", + map[string]int{"v": math.MaxInt32}, + }, + { + "v: -2147483648", + map[string]int{"v": math.MinInt32}, + }, + + // int64 + { + "v: 9223372036854775807", + map[string]int64{"v": math.MaxInt64}, + }, + { + "v: 0b111111111111111111111111111111111111111111111111111111111111111", + map[string]int64{"v": math.MaxInt64}, + }, + { + "v: -9223372036854775808", + map[string]int64{"v": math.MinInt64}, + }, + { + "v: -0b111111111111111111111111111111111111111111111111111111111111111", + map[string]int64{"v": -math.MaxInt64}, + }, + + // uint + { + "v: 0", + map[string]uint{"v": 0}, + }, + { + "v: 4294967295", + map[string]uint{"v": math.MaxUint32}, + }, + + // uint64 + { + "v: 0", + map[string]uint{"v": 0}, + }, + { + "v: 18446744073709551615", + map[string]uint64{"v": math.MaxUint64}, + }, + { + "v: 0b1111111111111111111111111111111111111111111111111111111111111111", + map[string]uint64{"v": math.MaxUint64}, + }, + { + "v: 9223372036854775807", + map[string]uint64{"v": math.MaxInt64}, + }, + + // float32 + { + "v: 3.40282346638528859811704183484516925440e+38", + map[string]float32{"v": math.MaxFloat32}, + }, + { + "v: 1.401298464324817070923729583289916131280e-45", + map[string]float32{"v": math.SmallestNonzeroFloat32}, + }, + { + "v: 18446744073709551615", + map[string]float32{"v": float32(math.MaxUint64)}, + }, + { + "v: 18446744073709551616", + map[string]float32{"v": float32(math.MaxUint64 + 1)}, + }, + + // float64 + { + "v: 1.797693134862315708145274237317043567981e+308", + map[string]float64{"v": math.MaxFloat64}, + }, + { + "v: 4.940656458412465441765687928682213723651e-324", + map[string]float64{"v": math.SmallestNonzeroFloat64}, + }, + { + "v: 18446744073709551615", + map[string]float64{"v": float64(math.MaxUint64)}, + }, + { + "v: 18446744073709551616", + map[string]float64{"v": float64(math.MaxUint64 + 1)}, + }, + + // Timestamps + { + // Date only. + "v: 2015-01-01\n", + map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, + }, + { + // RFC3339 + "v: 2015-02-24T18:19:39.12Z\n", + map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, .12e9, time.UTC)}, + }, + { + // RFC3339 with short dates. + "v: 2015-2-3T3:4:5Z", + map[string]time.Time{"v": time.Date(2015, 2, 3, 3, 4, 5, 0, time.UTC)}, + }, + { + // ISO8601 lower case t + "v: 2015-02-24t18:19:39Z\n", + map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)}, + }, + { + // space separate, no time zone + "v: 2015-02-24 18:19:39\n", + map[string]time.Time{"v": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)}, + }, + { + "v: 60s\n", + map[string]time.Duration{"v": time.Minute}, + }, + { + "v: -0.5h\n", + map[string]time.Duration{"v": -30 * time.Minute}, + }, + + // Single Quoted values. + { + `'1': '2'`, + map[interface{}]interface{}{"1": `2`}, + }, + { + `'1': '"2"'`, + map[interface{}]interface{}{"1": `"2"`}, + }, + { + `'1': ''''`, + map[interface{}]interface{}{"1": `'`}, + }, + { + `'1': '''2'''`, + map[interface{}]interface{}{"1": `'2'`}, + }, + { + `'1': 'B''z'`, + map[interface{}]interface{}{"1": `B'z`}, + }, + { + `'1': '\'`, + map[interface{}]interface{}{"1": `\`}, + }, + { + `'1': '\\'`, + map[interface{}]interface{}{"1": `\\`}, + }, + { + `'1': '\"2\"'`, + map[interface{}]interface{}{"1": `\"2\"`}, + }, + { + `'1': '\\"2\\"'`, + map[interface{}]interface{}{"1": `\\"2\\"`}, + }, + { + "'1': ' 1\n 2\n 3'", + map[interface{}]interface{}{"1": " 1 2 3"}, + }, + { + "'1': '\n 2\n 3'", + map[interface{}]interface{}{"1": " 2 3"}, + }, + + // Double Quoted values. + { + `"1": "2"`, + map[interface{}]interface{}{"1": `2`}, + }, + { + `"1": "\"2\""`, + map[interface{}]interface{}{"1": `"2"`}, + }, + { + `"1": "\""`, + map[interface{}]interface{}{"1": `"`}, + }, + { + `"1": "X\"z"`, + map[interface{}]interface{}{"1": `X"z`}, + }, + { + `"1": "\\"`, + map[interface{}]interface{}{"1": `\`}, + }, + { + `"1": "\\\\"`, + map[interface{}]interface{}{"1": `\\`}, + }, + { + `"1": "\\\"2\\\""`, + map[interface{}]interface{}{"1": `\"2\"`}, + }, + { + "'1': \" 1\n 2\n 3\"", + map[interface{}]interface{}{"1": " 1 2 3"}, + }, + { + "'1': \"\n 2\n 3\"", + map[interface{}]interface{}{"1": " 2 3"}, + }, + { + `"1": "a\x2Fb"`, + map[interface{}]interface{}{"1": `a/b`}, + }, + { + `"1": "a\u002Fb"`, + map[interface{}]interface{}{"1": `a/b`}, + }, + { + `"1": "a\x2Fb\u002Fc\U0000002Fd"`, + map[interface{}]interface{}{"1": `a/b/c/d`}, + }, + + { + "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"}, + }, + + // Nulls + { + "v:", + map[string]interface{}{"v": nil}, + }, + { + "v: ~", + map[string]interface{}{"v": nil}, + }, + { + "~: null key", + map[interface{}]string{nil: "null key"}, + }, + { + "v:", + map[string]*bool{"v": nil}, + }, + { + "v: null", + map[string]*string{"v": nil}, + }, + { + "v: null", + map[string]string{"v": ""}, + }, + { + "v: null", + map[string]interface{}{"v": nil}, + }, + { + "v: Null", + map[string]interface{}{"v": nil}, + }, + { + "v: NULL", + map[string]interface{}{"v": nil}, + }, + { + "v: ~", + map[string]*string{"v": nil}, + }, + { + "v: ~", + map[string]string{"v": ""}, + }, + + { + "v: .inf\n", + map[string]interface{}{"v": math.Inf(0)}, + }, + { + "v: .Inf\n", + map[string]interface{}{"v": math.Inf(0)}, + }, + { + "v: .INF\n", + map[string]interface{}{"v": math.Inf(0)}, + }, + { + "v: -.inf\n", + map[string]interface{}{"v": math.Inf(-1)}, + }, + { + "v: -.Inf\n", + map[string]interface{}{"v": math.Inf(-1)}, + }, + { + "v: -.INF\n", + map[string]interface{}{"v": math.Inf(-1)}, + }, + { + "v: .nan\n", + map[string]interface{}{"v": math.NaN()}, + }, + { + "v: .NaN\n", + map[string]interface{}{"v": math.NaN()}, + }, + { + "v: .NAN\n", + map[string]interface{}{"v": math.NaN()}, + }, + + // Explicit tags. + { + "v: !!float '1.1'", + map[string]interface{}{"v": 1.1}, + }, + { + "v: !!float 0", + map[string]interface{}{"v": float64(0)}, + }, + { + "v: !!float -1", + map[string]interface{}{"v": float64(-1)}, + }, + { + "v: !!null ''", + map[string]interface{}{"v": nil}, + }, + { + "v: !!timestamp \"2015-01-01\"", + map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, + }, + { + "v: !!timestamp 2015-01-01", + map[string]time.Time{"v": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)}, + }, + + // Flow sequence + { + "v: [A,B]", + map[string]interface{}{"v": []interface{}{"A", "B"}}, + }, + { + "v: [A,B,C,]", + map[string][]string{"v": []string{"A", "B", "C"}}, + }, + { + "v: [A,1,C]", + map[string][]string{"v": []string{"A", "1", "C"}}, + }, + { + "v: [A,1,C]", + map[string]interface{}{"v": []interface{}{"A", 1, "C"}}, + }, + + // Block sequence + { + "v:\n - A\n - B", + map[string]interface{}{"v": []interface{}{"A", "B"}}, + }, + { + "v:\n - A\n - B\n - C", + map[string][]string{"v": []string{"A", "B", "C"}}, + }, + { + "v:\n - A\n - 1\n - C", + map[string][]string{"v": []string{"A", "1", "C"}}, + }, + { + "v:\n - A\n - 1\n - C", + map[string]interface{}{"v": []interface{}{"A", 1, "C"}}, + }, + + // Map inside interface with no type hints. + { + "a: {b: c}", + map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}}, + }, + + { + "v: \"\"\n", + map[string]string{"v": ""}, + }, + { + "v:\n- A\n- B\n", + map[string][]string{"v": {"A", "B"}}, + }, + { + "a: '-'\n", + map[string]string{"a": "-"}, + }, + { + "123\n", + 123, + }, + { + "hello: world\n", + map[string]string{"hello": "world"}, + }, + { + "hello: world\r\n", + map[string]string{"hello": "world"}, + }, + { + "hello: world\rGo: Gopher", + map[string]string{"hello": "world", "Go": "Gopher"}, + }, + + // 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 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, 2]", + struct{ A [2]int }{[2]int{1, 2}}, + }, + { + "a: 1", + struct{ B int }{0}, + }, + { + "a: 1", + struct { + B int `yaml:"a"` + }{1}, + }, + + { + "a: 1\n", + yaml.MapItem{Key: "a", Value: 1}, + }, + { + "a: 1\nb: 2\nc: 3\n", + yaml.MapSlice{ + {Key: "a", Value: 1}, + {Key: "b", Value: 2}, + {Key: "c", Value: 3}, + }, + }, + { + "v:\n- A\n- 1\n- B:\n - 2\n - 3\n", + map[string]interface{}{ + "v": []interface{}{ + "A", + 1, + map[string][]int{ + "B": {2, 3}, + }, + }, + }, + }, + { + "a:\n b: c\n", + map[string]interface{}{ + "a": map[string]string{ + "b": "c", + }, + }, + }, + { + "a: {x: 1}\n", + map[string]map[string]int{ + "a": { + "x": 1, + }, + }, + }, + { + "t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n", + map[string]string{ + "t2": "2018-01-09T10:40:47Z", + "t4": "2098-01-09T10:40:47Z", + }, + }, + { + "a: [1, 2]\n", + map[string][]int{ + "a": {1, 2}, + }, + }, + { + "a: {b: c, d: e}\n", + map[string]interface{}{ + "a": map[string]string{ + "b": "c", + "d": "e", + }, + }, + }, + { + "a: 3s\n", + map[string]string{ + "a": "3s", + }, + }, + { + "a: <foo>\n", + map[string]string{"a": "<foo>"}, + }, + { + "a: \"1:1\"\n", + map[string]string{"a": "1:1"}, + }, + { + "a: 1.2.3.4\n", + map[string]string{"a": "1.2.3.4"}, + }, + { + "a: 'b: c'\n", + map[string]string{"a": "b: c"}, + }, + { + "a: 'Hello #comment'\n", + map[string]string{"a": "Hello #comment"}, + }, + { + "a: 100.5\n", + map[string]interface{}{ + "a": 100.5, + }, + }, + { + "a: \"\\0\"\n", + map[string]string{"a": "\\0"}, + }, + { + "b: 2\na: 1\nd: 4\nc: 3\nsub:\n e: 5\n", + map[string]interface{}{ + "b": 2, + "a": 1, + "d": 4, + "c": 3, + "sub": map[string]int{ + "e": 5, + }, + }, + }, + { + " a : b \n", + map[string]string{"a": "b"}, + }, + { + "a: b # comment\nb: c\n", + map[string]string{ + "a": "b", + "b": "c", + }, + }, + { + "---\na: b\n", + map[string]string{"a": "b"}, + }, + { + "a: b\n...\n", + map[string]string{"a": "b"}, + }, + { + "%YAML 1.2\n---\n", + (*struct{})(nil), + }, + { + "---\n", + (*struct{})(nil), + }, + { + "...", + (*struct{})(nil), + }, + { + "v: go test ./...", + map[string]string{"v": "go test ./..."}, + }, + { + "v: echo ---", + map[string]string{"v": "echo ---"}, + }, + { + "v: |\n hello\n ...\n world\n", + map[string]string{"v": "hello\n...\nworld\n"}, + }, + { + "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)}, + }, + { + "v:\n- A\n- |-\n B\n C\n", + map[string][]string{ + "v": { + "A", "B\nC", + }, + }, + }, + { + "v:\n- A\n- >-\n B\n C\n", + map[string][]string{ + "v": { + "A", "B C", + }, + }, + }, + { + "a: b\nc: d\n", + struct { + A string + C string `yaml:"c"` + }{ + "b", "d", + }, + }, + { + "a: 1\nb: 2\n", + struct { + A int + B int `yaml:"-"` + }{ + 1, 0, + }, + }, + { + "a: 1\nb: 2\n", + struct { + A int + Child `yaml:",inline"` + }{ + 1, + Child{ + B: 2, + C: 0, + }, + }, + }, + + // 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\n", + struct { + A, B struct { + C int + } + }{struct{ C int }{1}, struct{ C int }{1}}, + }, + { + "a: &a [1, 2]\nb: *a\n", + struct{ B []int }{[]int{1, 2}}, + }, + + { + "tags:\n- hello-world\na: foo", + struct { + Tags []string + A string + }{Tags: []string{"hello-world"}, A: "foo"}, + }, + { + "", + (*struct{})(nil), + }, + { + "{}", struct{}{}, + }, + { + "v: /a/{b}", + map[string]string{"v": "/a/{b}"}, + }, + { + "v: 1[]{},!%?&*", + map[string]string{"v": "1[]{},!%?&*"}, + }, + { + "v: user's item", + map[string]string{"v": "user's item"}, + }, + { + "v: [1,[2,[3,[4,5],6],7],8]", + map[string]interface{}{ + "v": []interface{}{ + 1, + []interface{}{ + 2, + []interface{}{ + 3, + []int{4, 5}, + 6, + }, + 7, + }, + 8, + }, + }, + }, + { + "v: {a: {b: {c: {d: e},f: g},h: i},j: k}", + map[string]interface{}{ + "v": map[string]interface{}{ + "a": map[string]interface{}{ + "b": map[string]interface{}{ + "c": map[string]string{ + "d": "e", + }, + "f": "g", + }, + "h": "i", + }, + "j": "k", + }, + }, + }, + { + `--- +- a: + b: +- c: d +`, + []map[string]interface{}{ + { + "a": map[string]interface{}{ + "b": nil, + }, + }, + { + "c": "d", + }, + }, + }, + { + `--- +a: + b: +c: d +`, + map[string]interface{}{ + "a": map[string]interface{}{ + "b": nil, + }, + "c": "d", + }, + }, + { + `--- +a: +b: +c: +`, + map[string]interface{}{ + "a": nil, + "b": nil, + "c": nil, + }, + }, + { + `--- +a: go test ./... +b: +c: +`, + map[string]interface{}{ + "a": "go test ./...", + "b": nil, + "c": nil, + }, + }, + { + `--- +a: | + hello + ... + world +b: +c: +`, + map[string]interface{}{ + "a": "hello\n...\nworld\n", + "b": nil, + "c": nil, + }, + }, + + // Multi bytes + { + "v: あいうえお\nv2: かきくけこ", + map[string]string{"v": "あいうえお", "v2": "かきくけこ"}, + }, + } + for _, test := range tests { + t.Run(test.source, func(t *testing.T) { + buf := bytes.NewBufferString(test.source) + dec := yaml.NewDecoder(buf) + typ := reflect.ValueOf(test.value).Type() + value := reflect.New(typ) + if err := dec.Decode(value.Interface()); err != nil { + if err == io.EOF { + return + } + t.Fatalf("%s: %+v", test.source, err) + } + actual := fmt.Sprintf("%+v", value.Elem().Interface()) + expect := fmt.Sprintf("%+v", test.value) + if actual != expect { + t.Fatalf("failed to test [%s], actual=[%s], expect=[%s]", test.source, actual, expect) + } + }) + } +} + +func TestDecoder_TypeConversionError(t *testing.T) { + t.Run("type conversion for struct", func(t *testing.T) { + type T struct { + A int + B uint + C float32 + D bool + } + type U struct { + *T `yaml:",inline"` + } + t.Run("string to int", func(t *testing.T) { + var v T + err := yaml.Unmarshal([]byte(`a: str`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal string into Go struct field T.A of type int" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + t.Run("string to bool", func(t *testing.T) { + var v T + err := yaml.Unmarshal([]byte(`d: str`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal string into Go struct field T.D of type bool" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + t.Run("string to int at inline", func(t *testing.T) { + var v U + err := yaml.Unmarshal([]byte(`a: str`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal string into Go struct field U.T.A of type int" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + }) + t.Run("type conversion for array", func(t *testing.T) { + t.Run("string to int", func(t *testing.T) { + var v map[string][]int + err := yaml.Unmarshal([]byte(`v: [A,1,C]`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal string into Go value of type int" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if len(v) == 0 || len(v["v"]) == 0 { + t.Fatal("failed to decode value") + } + if v["v"][0] != 1 { + t.Fatal("failed to decode value") + } + }) + t.Run("string to int", func(t *testing.T) { + var v map[string][]int + err := yaml.Unmarshal([]byte("v:\n - A\n - 1\n - C"), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal string into Go value of type int" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if len(v) == 0 || len(v["v"]) == 0 { + t.Fatal("failed to decode value") + } + if v["v"][0] != 1 { + t.Fatal("failed to decode value") + } + }) + }) + t.Run("overflow error", func(t *testing.T) { + t.Run("negative number to uint", func(t *testing.T) { + var v map[string]uint + err := yaml.Unmarshal([]byte("v: -42"), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal -42 into Go value of type uint ( overflow )" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if v["v"] != 0 { + t.Fatal("failed to decode value") + } + }) + t.Run("negative number to uint64", func(t *testing.T) { + var v map[string]uint64 + err := yaml.Unmarshal([]byte("v: -4294967296"), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal -4294967296 into Go value of type uint64 ( overflow )" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if v["v"] != 0 { + t.Fatal("failed to decode value") + } + }) + t.Run("larger number for int32", func(t *testing.T) { + var v map[string]int32 + err := yaml.Unmarshal([]byte("v: 4294967297"), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal 4294967297 into Go value of type int32 ( overflow )" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if v["v"] != 0 { + t.Fatal("failed to decode value") + } + }) + t.Run("larger number for int8", func(t *testing.T) { + var v map[string]int8 + err := yaml.Unmarshal([]byte("v: 128"), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal 128 into Go value of type int8 ( overflow )" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + if v["v"] != 0 { + t.Fatal("failed to decode value") + } + }) + }) + t.Run("type conversion for time", func(t *testing.T) { + type T struct { + A time.Time + B time.Duration + } + t.Run("int to time", func(t *testing.T) { + var v T + err := yaml.Unmarshal([]byte(`a: 123`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal uint64 into Go struct field T.A of type time.Time" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + t.Run("string to duration", func(t *testing.T) { + var v T + err := yaml.Unmarshal([]byte(`b: str`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := `time: invalid duration "str"` + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + t.Run("int to duration", func(t *testing.T) { + var v T + err := yaml.Unmarshal([]byte(`b: 10`), &v) + if err == nil { + t.Fatal("expected to error") + } + msg := "cannot unmarshal uint64 into Go struct field T.B of type time.Duration" + if !strings.Contains(err.Error(), msg) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), msg) + } + }) + }) +} + +func TestDecoder_AnchorReferenceDirs(t *testing.T) { + buf := bytes.NewBufferString("a: *a\n") + dec := yaml.NewDecoder(buf, yaml.ReferenceDirs("testdata")) + var v struct { + A struct { + B int + C string + } + } + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.A.B != 1 { + t.Fatal("failed to decode by reference dirs") + } + if v.A.C != "hello" { + t.Fatal("failed to decode by reference dirs") + } +} + +func TestDecoder_AnchorReferenceDirsRecursive(t *testing.T) { + buf := bytes.NewBufferString("a: *a\n") + dec := yaml.NewDecoder( + buf, + yaml.RecursiveDir(true), + yaml.ReferenceDirs("testdata"), + ) + var v struct { + A struct { + B int + C string + } + } + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.A.B != 1 { + t.Fatal("failed to decode by reference dirs") + } + if v.A.C != "hello" { + t.Fatal("failed to decode by reference dirs") + } +} + +func TestDecoder_AnchorFiles(t *testing.T) { + buf := bytes.NewBufferString("a: *a\n") + dec := yaml.NewDecoder(buf, yaml.ReferenceFiles("testdata/anchor.yml")) + var v struct { + A struct { + B int + C string + } + } + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.A.B != 1 { + t.Fatal("failed to decode by reference dirs") + } + if v.A.C != "hello" { + t.Fatal("failed to decode by reference dirs") + } +} + +func TestDecodeWithMergeKey(t *testing.T) { + yml := ` +a: &a + b: 1 + c: hello +items: +- <<: *a +- <<: *a + c: world +` + type Item struct { + B int + C string + } + type T struct { + Items []*Item + } + buf := bytes.NewBufferString(yml) + dec := yaml.NewDecoder(buf) + var v T + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if len(v.Items) != 2 { + t.Fatal("failed to decode with merge key") + } + if v.Items[0].B != 1 || v.Items[0].C != "hello" { + t.Fatal("failed to decode with merge key") + } + if v.Items[1].B != 1 || v.Items[1].C != "world" { + t.Fatal("failed to decode with merge key") + } + t.Run("decode with interface{}", func(t *testing.T) { + buf := bytes.NewBufferString(yml) + dec := yaml.NewDecoder(buf) + var v interface{} + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + items := v.(map[string]interface{})["items"].([]interface{}) + if len(items) != 2 { + t.Fatal("failed to decode with merge key") + } + b0 := items[0].(map[string]interface{})["b"] + if _, ok := b0.(uint64); !ok { + t.Fatal("failed to decode with merge key") + } + if b0.(uint64) != 1 { + t.Fatal("failed to decode with merge key") + } + c0 := items[0].(map[string]interface{})["c"] + if _, ok := c0.(string); !ok { + t.Fatal("failed to decode with merge key") + } + if c0.(string) != "hello" { + t.Fatal("failed to decode with merge key") + } + b1 := items[1].(map[string]interface{})["b"] + if _, ok := b1.(uint64); !ok { + t.Fatal("failed to decode with merge key") + } + if b1.(uint64) != 1 { + t.Fatal("failed to decode with merge key") + } + c1 := items[1].(map[string]interface{})["c"] + if _, ok := c1.(string); !ok { + t.Fatal("failed to decode with merge key") + } + if c1.(string) != "world" { + t.Fatal("failed to decode with merge key") + } + }) + t.Run("decode with map", func(t *testing.T) { + var v struct { + Items []map[string]interface{} + } + buf := bytes.NewBufferString(yml) + dec := yaml.NewDecoder(buf) + if err := dec.Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if len(v.Items) != 2 { + t.Fatal("failed to decode with merge key") + } + b0 := v.Items[0]["b"] + if _, ok := b0.(uint64); !ok { + t.Fatal("failed to decode with merge key") + } + if b0.(uint64) != 1 { + t.Fatal("failed to decode with merge key") + } + c0 := v.Items[0]["c"] + if _, ok := c0.(string); !ok { + t.Fatal("failed to decode with merge key") + } + if c0.(string) != "hello" { + t.Fatal("failed to decode with merge key") + } + b1 := v.Items[1]["b"] + if _, ok := b1.(uint64); !ok { + t.Fatal("failed to decode with merge key") + } + if b1.(uint64) != 1 { + t.Fatal("failed to decode with merge key") + } + c1 := v.Items[1]["c"] + if _, ok := c1.(string); !ok { + t.Fatal("failed to decode with merge key") + } + if c1.(string) != "world" { + t.Fatal("failed to decode with merge key") + } + }) +} + +func TestDecoder_Inline(t *testing.T) { + type Base struct { + A int + B string + } + yml := `--- +a: 1 +b: hello +c: true +` + var v struct { + *Base `yaml:",inline"` + C bool + } + if err := yaml.NewDecoder(strings.NewReader(yml)).Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.A != 1 { + t.Fatal("failed to decode with inline key") + } + if v.B != "hello" { + t.Fatal("failed to decode with inline key") + } + if !v.C { + t.Fatal("failed to decode with inline key") + } + + t.Run("multiple inline with strict", func(t *testing.T) { + type Base struct { + A int + B string + } + type Base2 struct { + Base *Base `yaml:",inline"` + } + yml := `--- +a: 1 +b: hello +` + var v struct { + Base2 *Base2 `yaml:",inline"` + } + if err := yaml.NewDecoder(strings.NewReader(yml), yaml.Strict()).Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.Base2.Base.A != 1 { + t.Fatal("failed to decode with inline key") + } + if v.Base2.Base.B != "hello" { + t.Fatal("failed to decode with inline key") + } + }) +} + +func TestDecoder_InlineAndConflictKey(t *testing.T) { + type Base struct { + A int + B string + } + yml := `--- +a: 1 +b: hello +c: true +` + var v struct { + *Base `yaml:",inline"` + A int + C bool + } + if err := yaml.NewDecoder(strings.NewReader(yml)).Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if v.A != 1 { + t.Fatal("failed to decode with inline key") + } + if v.B != "hello" { + t.Fatal("failed to decode with inline key") + } + if !v.C { + t.Fatal("failed to decode with inline key") + } + if v.Base.A != 0 { + t.Fatal("failed to decode with inline key") + } +} + +func TestDecoder_InlineAndWrongTypeStrict(t *testing.T) { + type Base struct { + A int + B string + } + yml := `--- +a: notanint +b: hello +c: true +` + var v struct { + *Base `yaml:",inline"` + C bool + } + err := yaml.NewDecoder(strings.NewReader(yml), yaml.Strict()).Decode(&v) + if err == nil { + t.Fatalf("expected error") + } + + //TODO: properly check if errors are colored/have source + t.Logf("%s", err) + t.Logf("%s", yaml.FormatError(err, true, false)) + t.Logf("%s", yaml.FormatError(err, false, true)) + t.Logf("%s", yaml.FormatError(err, true, true)) +} + +func TestDecoder_InvalidCases(t *testing.T) { + const src = `--- +a: +- b + c: d +` + var v struct { + A []string + } + err := yaml.NewDecoder(strings.NewReader(src)).Decode(&v) + if err == nil { + t.Fatalf("expected error") + } + + if err.Error() != yaml.FormatError(err, false, true) { + t.Logf("err.Error() = %s", err.Error()) + t.Logf("yaml.FormatError(err, false, true) = %s", yaml.FormatError(err, false, true)) + t.Fatal(`err.Error() should match yaml.FormatError(err, false, true)`) + } + + //TODO: properly check if errors are colored/have source + t.Logf("%s", err) + t.Logf("%s", yaml.FormatError(err, true, false)) + t.Logf("%s", yaml.FormatError(err, false, true)) + t.Logf("%s", yaml.FormatError(err, true, true)) +} + +func TestDecoder_JSONTags(t *testing.T) { + var v struct { + A string `json:"a_json"` // no YAML tag + B string `json:"b_json" yaml:"b_yaml"` // both tags + } + + const src = `--- +a_json: a_json_value +b_json: b_json_value +b_yaml: b_yaml_value +` + if err := yaml.NewDecoder(strings.NewReader(src)).Decode(&v); err != nil { + t.Fatalf(`parsing should succeed: %s`, err) + } + + if v.A != "a_json_value" { + t.Fatalf("v.A should be `a_json_value`, got `%s`", v.A) + } + + if v.B != "b_yaml_value" { + t.Fatalf("v.B should be `b_yaml_value`, got `%s`", v.B) + } +} + +func TestDecoder_DisallowUnknownField(t *testing.T) { + t.Run("different level keys with same name", func(t *testing.T) { + var v struct { + C Child `yaml:"c"` + } + yml := `--- +b: 1 +c: + b: 1 +` + + err := yaml.NewDecoder(strings.NewReader(yml), yaml.DisallowUnknownField()).Decode(&v) + if err == nil { + t.Fatalf("error expected") + } + }) + t.Run("inline", func(t *testing.T) { + var v struct { + *Child `yaml:",inline"` + A string `yaml:"a"` + } + yml := `--- +a: a +b: 1 +` + + if err := yaml.NewDecoder(strings.NewReader(yml), yaml.DisallowUnknownField()).Decode(&v); err != nil { + t.Fatalf(`parsing should succeed: %s`, err) + } + if v.A != "a" { + t.Fatalf("v.A should be `a`, got `%s`", v.A) + } + if v.B != 1 { + t.Fatalf("v.B should be 1, got %d", v.B) + } + if v.C != 0 { + t.Fatalf("v.C should be 0, got %d", v.C) + } + }) + t.Run("list", func(t *testing.T) { + type C struct { + Child `yaml:",inline"` + } + + var v struct { + Children []C `yaml:"children"` + } + + yml := `--- +children: +- b: 1 +- b: 2 +` + + if err := yaml.NewDecoder(strings.NewReader(yml), yaml.DisallowUnknownField()).Decode(&v); err != nil { + t.Fatalf(`parsing should succeed: %s`, err) + } + + if len(v.Children) != 2 { + t.Fatalf(`len(v.Children) should be 2, got %d`, len(v.Children)) + } + + if v.Children[0].B != 1 { + t.Fatalf(`v.Children[0].B should be 1, got %d`, v.Children[0].B) + } + + if v.Children[1].B != 2 { + t.Fatalf(`v.Children[1].B should be 2, got %d`, v.Children[1].B) + } + }) +} + +func TestDecoder_DisallowDuplicateKey(t *testing.T) { + yml := ` +a: b +a: c +` + expected := ` +[3:1] duplicate key "a" + 2 | a: b +> 3 | a: c + ^ +` + t.Run("map", func(t *testing.T) { + var v map[string]string + err := yaml.NewDecoder(strings.NewReader(yml), yaml.DisallowDuplicateKey()).Decode(&v) + if err == nil { + t.Fatal("decoding should fail") + } + actual := "\n" + err.Error() + if expected != actual { + t.Fatalf("expected:[%s] actual:[%s]", expected, actual) + } + }) + t.Run("struct", func(t *testing.T) { + var v struct { + A string + } + err := yaml.NewDecoder(strings.NewReader(yml), yaml.DisallowDuplicateKey()).Decode(&v) + if err == nil { + t.Fatal("decoding should fail") + } + actual := "\n" + err.Error() + if expected != actual { + t.Fatalf("expected:[%s] actual:[%s]", expected, actual) + } + }) +} + +func TestDecoder_DefaultValues(t *testing.T) { + v := struct { + A string `yaml:"a"` + B string `yaml:"b"` + c string // private + D struct { + E string `yaml:"e"` + F struct { + G string `yaml:"g"` + } `yaml:"f"` + H struct { + I string `yaml:"i"` + } `yaml:",inline"` + } `yaml:"d"` + J struct { + K string `yaml:"k"` + L struct { + M string `yaml:"m"` + } `yaml:"l"` + N struct { + O string `yaml:"o"` + } `yaml:",inline"` + } `yaml:",inline"` + P struct { + Q string `yaml:"q"` + R struct { + S string `yaml:"s"` + } `yaml:"r"` + T struct { + U string `yaml:"u"` + } `yaml:",inline"` + } `yaml:"p"` + V struct { + W string `yaml:"w"` + X struct { + Y string `yaml:"y"` + } `yaml:"x"` + Z struct { + Ä string `yaml:"ä"` + } `yaml:",inline"` + } `yaml:",inline"` + }{ + B: "defaultBValue", + c: "defaultCValue", + } + + v.D.E = "defaultEValue" + v.D.F.G = "defaultGValue" + v.D.H.I = "defaultIValue" + v.J.K = "defaultKValue" + v.J.L.M = "defaultMValue" + v.J.N.O = "defaultOValue" + v.P.R.S = "defaultSValue" + v.P.T.U = "defaultUValue" + v.V.X.Y = "defaultYValue" + v.V.Z.Ä = "defaultÄValue" + + const src = `--- +a: a_value +p: + q: q_value +w: w_value +` + if err := yaml.NewDecoder(strings.NewReader(src)).Decode(&v); err != nil { + t.Fatalf(`parsing should succeed: %s`, err) + } + if v.A != "a_value" { + t.Fatalf("v.A should be `a_value`, got `%s`", v.A) + } + + if v.B != "defaultBValue" { + t.Fatalf("v.B should be `defaultValue`, got `%s`", v.B) + } + + if v.c != "defaultCValue" { + t.Fatalf("v.c should be `defaultCValue`, got `%s`", v.c) + } + + if v.D.E != "defaultEValue" { + t.Fatalf("v.D.E should be `defaultEValue`, got `%s`", v.D.E) + } + + if v.D.F.G != "defaultGValue" { + t.Fatalf("v.D.F.G should be `defaultGValue`, got `%s`", v.D.F.G) + } + + if v.D.H.I != "defaultIValue" { + t.Fatalf("v.D.H.I should be `defaultIValue`, got `%s`", v.D.H.I) + } + + if v.J.K != "defaultKValue" { + t.Fatalf("v.J.K should be `defaultKValue`, got `%s`", v.J.K) + } + + if v.J.L.M != "defaultMValue" { + t.Fatalf("v.J.L.M should be `defaultMValue`, got `%s`", v.J.L.M) + } + + if v.J.N.O != "defaultOValue" { + t.Fatalf("v.J.N.O should be `defaultOValue`, got `%s`", v.J.N.O) + } + + if v.P.Q != "q_value" { + t.Fatalf("v.P.Q should be `q_value`, got `%s`", v.P.Q) + } + + if v.P.R.S != "defaultSValue" { + t.Fatalf("v.P.R.S should be `defaultSValue`, got `%s`", v.P.R.S) + } + + if v.P.T.U != "defaultUValue" { + t.Fatalf("v.P.T.U should be `defaultUValue`, got `%s`", v.P.T.U) + } + + if v.V.W != "w_value" { + t.Fatalf("v.V.W should be `w_value`, got `%s`", v.V.W) + } + + if v.V.X.Y != "defaultYValue" { + t.Fatalf("v.V.X.Y should be `defaultYValue`, got `%s`", v.V.X.Y) + } + + if v.V.Z.Ä != "defaultÄValue" { + t.Fatalf("v.V.Z.Ä should be `defaultÄValue`, got `%s`", v.V.Z.Ä) + } +} + +func Example_YAMLTags() { + yml := `--- +foo: 1 +bar: c +A: 2 +B: d +` + var v struct { + A int `yaml:"foo" json:"A"` + B string `yaml:"bar" json:"B"` + } + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + log.Fatal(err) + } + fmt.Println(v.A) + fmt.Println(v.B) + // OUTPUT: + // 1 + // c +} + +type useJSONUnmarshalerTest struct { + s string +} + +func (t *useJSONUnmarshalerTest) UnmarshalJSON(b []byte) error { + s, err := strconv.Unquote(string(b)) + if err != nil { + return err + } + t.s = s + return nil +} + +func TestDecoder_UseJSONUnmarshaler(t *testing.T) { + var v useJSONUnmarshalerTest + if err := yaml.UnmarshalWithOptions([]byte(`"a"`), &v, yaml.UseJSONUnmarshaler()); err != nil { + t.Fatal(err) + } + if v.s != "a" { + t.Fatalf("unexpected decoded value: %s", v.s) + } +} + +type unmarshalContext struct { + v int +} + +func (c *unmarshalContext) UnmarshalYAML(ctx context.Context, b []byte) error { + v, ok := ctx.Value("k").(int) + if !ok { + return fmt.Errorf("cannot get valid context") + } + if v != 1 { + return fmt.Errorf("cannot get valid context") + } + if string(b) != "1" { + return fmt.Errorf("cannot get valid bytes") + } + c.v = v + return nil +} + +func Test_UnmarshalerContext(t *testing.T) { + ctx := context.WithValue(context.Background(), "k", 1) + var v unmarshalContext + if err := yaml.UnmarshalContext(ctx, []byte(`1`), &v); err != nil { + t.Fatalf("%+v", err) + } + if v.v != 1 { + t.Fatal("cannot call UnmarshalYAML") + } +} + +func TestDecoder_DecodeFromNode(t *testing.T) { + t.Run("has reference", func(t *testing.T) { + str := ` +anchor: &map + text: hello +map: *map` + var buf bytes.Buffer + dec := yaml.NewDecoder(&buf) + f, err := parser.ParseBytes([]byte(str), 0) + if err != nil { + t.Fatalf("failed to parse: %s", err) + } + type T struct { + Map map[string]string + } + var v T + if err := dec.DecodeFromNode(f.Docs[0].Body, &v); err != nil { + t.Fatalf("failed to decode: %s", err) + } + actual := fmt.Sprintf("%+v", v) + expect := fmt.Sprintf("%+v", T{map[string]string{"text": "hello"}}) + if actual != expect { + t.Fatalf("actual=[%s], expect=[%s]", actual, expect) + } + }) + t.Run("with reference option", func(t *testing.T) { + anchor := strings.NewReader(` +map: &map + text: hello`) + var buf bytes.Buffer + dec := yaml.NewDecoder(&buf, yaml.ReferenceReaders(anchor)) + f, err := parser.ParseBytes([]byte("map: *map"), 0) + if err != nil { + t.Fatalf("failed to parse: %s", err) + } + type T struct { + Map map[string]string + } + var v T + if err := dec.DecodeFromNode(f.Docs[0].Body, &v); err != nil { + t.Fatalf("failed to decode: %s", err) + } + actual := fmt.Sprintf("%+v", v) + expect := fmt.Sprintf("%+v", T{map[string]string{"text": "hello"}}) + if actual != expect { + t.Fatalf("actual=[%s], expect=[%s]", actual, expect) + } + }) + t.Run("value is not pointer", func(t *testing.T) { + var buf bytes.Buffer + var v bool + err := yaml.NewDecoder(&buf).DecodeFromNode(nil, v) + if !xerrors.Is(err, errors.ErrDecodeRequiredPointerType) { + t.Fatalf("unexpected error: %s", err) + } + }) +} + +func Example_JSONTags() { + yml := `--- +foo: 1 +bar: c +` + var v struct { + A int `json:"foo"` + B string `json:"bar"` + } + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + log.Fatal(err) + } + fmt.Println(v.A) + fmt.Println(v.B) + // OUTPUT: + // 1 + // c +} + +func Example_DisallowUnknownField() { + var v struct { + A string `yaml:"simple"` + C string `yaml:"complicated"` + } + + const src = `--- +simple: string +complecated: string +` + err := yaml.NewDecoder(strings.NewReader(src), yaml.DisallowUnknownField()).Decode(&v) + fmt.Printf("%v\n", err) + + // OUTPUT: + // [3:1] unknown field "complecated" + // 1 | --- + // 2 | simple: string + // > 3 | complecated: string + // ^ +} + +func Example_Unmarshal_Node() { + f, err := parser.ParseBytes([]byte("text: node example"), 0) + if err != nil { + panic(err) + } + var v struct { + Text string `yaml:"text"` + } + if err := yaml.NodeToValue(f.Docs[0].Body, &v); err != nil { + panic(err) + } + fmt.Println(v.Text) + // OUTPUT: + // node example +} + +type unmarshalableYAMLStringValue string + +func (v *unmarshalableYAMLStringValue) UnmarshalYAML(b []byte) error { + var s string + if err := yaml.Unmarshal(b, &s); err != nil { + return err + } + *v = unmarshalableYAMLStringValue(s) + return nil +} + +type unmarshalableTextStringValue string + +func (v *unmarshalableTextStringValue) UnmarshalText(b []byte) error { + *v = unmarshalableTextStringValue(string(b)) + return nil +} + +type unmarshalableStringContainer struct { + A unmarshalableYAMLStringValue `yaml:"a"` + B unmarshalableTextStringValue `yaml:"b"` +} + +func TestUnmarshalableString(t *testing.T) { + t.Run("empty string", func(t *testing.T) { + t.Parallel() + yml := ` +a: "" +b: "" +` + var container unmarshalableStringContainer + if err := yaml.Unmarshal([]byte(yml), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.A != "" { + t.Fatalf("expected empty string, but %q is set", container.A) + } + if container.B != "" { + t.Fatalf("expected empty string, but %q is set", container.B) + } + }) + t.Run("filled string", func(t *testing.T) { + t.Parallel() + yml := ` +a: "aaa" +b: "bbb" +` + var container unmarshalableStringContainer + if err := yaml.Unmarshal([]byte(yml), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.A != "aaa" { + t.Fatalf("expected \"aaa\", but %q is set", container.A) + } + if container.B != "bbb" { + t.Fatalf("expected \"bbb\", but %q is set", container.B) + } + }) + t.Run("single-quoted string", func(t *testing.T) { + t.Parallel() + yml := ` +a: 'aaa' +b: 'bbb' +` + var container unmarshalableStringContainer + if err := yaml.Unmarshal([]byte(yml), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.A != "aaa" { + t.Fatalf("expected \"aaa\", but %q is set", container.A) + } + if container.B != "bbb" { + t.Fatalf("expected \"aaa\", but %q is set", container.B) + } + }) + t.Run("literal", func(t *testing.T) { + t.Parallel() + yml := ` +a: | + a + b + c +b: | + a + b + c +` + var container unmarshalableStringContainer + if err := yaml.Unmarshal([]byte(yml), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.A != "a\nb\nc\n" { + t.Fatalf("expected \"a\nb\nc\n\", but %q is set", container.A) + } + if container.B != "a\nb\nc\n" { + t.Fatalf("expected \"a\nb\nc\n\", but %q is set", container.B) + } + }) + t.Run("anchor/alias", func(t *testing.T) { + yml := ` +a: &x 1 +b: *x +c: &y hello +d: *y +` + var v struct { + A, B, C, D unmarshalableTextStringValue + } + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatal(err) + } + if v.A != "1" { + t.Fatal("failed to unmarshal") + } + if v.B != "1" { + t.Fatal("failed to unmarshal") + } + if v.C != "hello" { + t.Fatal("failed to unmarshal") + } + if v.D != "hello" { + t.Fatal("failed to unmarshal") + } + }) + t.Run("net.IP", func(t *testing.T) { + yml := ` +a: &a 127.0.0.1 +b: *a +` + var v struct { + A, B net.IP + } + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatal(err) + } + if v.A.String() != net.IPv4(127, 0, 0, 1).String() { + t.Fatal("failed to unmarshal") + } + if v.B.String() != net.IPv4(127, 0, 0, 1).String() { + t.Fatal("failed to unmarshal") + } + }) +} + +type unmarshalablePtrStringContainer struct { + V *string `yaml:"value"` +} + +func TestUnmarshalablePtrString(t *testing.T) { + t.Run("empty string", func(t *testing.T) { + t.Parallel() + var container unmarshalablePtrStringContainer + if err := yaml.Unmarshal([]byte(`value: ""`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V == nil || *container.V != "" { + t.Fatalf("expected empty string, but %q is set", *container.V) + } + }) + + t.Run("null", func(t *testing.T) { + t.Parallel() + var container unmarshalablePtrStringContainer + if err := yaml.Unmarshal([]byte(`value: null`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V != (*string)(nil) { + t.Fatalf("expected nil, but %q is set", *container.V) + } + }) +} + +type unmarshalableIntValue int + +func (v *unmarshalableIntValue) UnmarshalYAML(raw []byte) error { + i, err := strconv.Atoi(string(raw)) + if err != nil { + return err + } + *v = unmarshalableIntValue(i) + return nil +} + +type unmarshalableIntContainer struct { + V unmarshalableIntValue `yaml:"value"` +} + +func TestUnmarshalableInt(t *testing.T) { + t.Run("empty int", func(t *testing.T) { + t.Parallel() + var container unmarshalableIntContainer + if err := yaml.Unmarshal([]byte(``), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V != 0 { + t.Fatalf("expected empty int, but %d is set", container.V) + } + }) + t.Run("filled int", func(t *testing.T) { + t.Parallel() + var container unmarshalableIntContainer + if err := yaml.Unmarshal([]byte(`value: 9`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V != 9 { + t.Fatalf("expected 9, but %d is set", container.V) + } + }) + t.Run("filled number", func(t *testing.T) { + t.Parallel() + var container unmarshalableIntContainer + if err := yaml.Unmarshal([]byte(`value: 9`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V != 9 { + t.Fatalf("expected 9, but %d is set", container.V) + } + }) +} + +type unmarshalablePtrIntContainer struct { + V *int `yaml:"value"` +} + +func TestUnmarshalablePtrInt(t *testing.T) { + t.Run("empty int", func(t *testing.T) { + t.Parallel() + var container unmarshalablePtrIntContainer + if err := yaml.Unmarshal([]byte(`value: 0`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V == nil || *container.V != 0 { + t.Fatalf("expected 0, but %q is set", *container.V) + } + }) + + t.Run("null", func(t *testing.T) { + t.Parallel() + var container unmarshalablePtrIntContainer + if err := yaml.Unmarshal([]byte(`value: null`), &container); err != nil { + t.Fatalf("failed to unmarshal %v", err) + } + if container.V != (*int)(nil) { + t.Fatalf("expected nil, but %q is set", *container.V) + } + }) +} + +type literalContainer struct { + v string +} + +func (c *literalContainer) UnmarshalYAML(v []byte) error { + var lit string + if err := yaml.Unmarshal(v, &lit); err != nil { + return err + } + c.v = lit + return nil +} + +func TestDecode_Literal(t *testing.T) { + yml := `--- +value: | + { + "key": "value" + } +` + var v map[string]*literalContainer + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatalf("failed to unmarshal %+v", err) + } + if v["value"] == nil { + t.Fatal("failed to unmarshal literal with bytes unmarshaler") + } + if v["value"].v == "" { + t.Fatal("failed to unmarshal literal with bytes unmarshaler") + } +} + +func TestDecoder_UseOrderedMap(t *testing.T) { + yml := ` +a: b +c: d +e: + f: g + h: i +j: k +` + var v interface{} + if err := yaml.NewDecoder(strings.NewReader(yml), yaml.UseOrderedMap()).Decode(&v); err != nil { + t.Fatalf("%+v", err) + } + if _, ok := v.(yaml.MapSlice); !ok { + t.Fatalf("failed to convert to ordered map: %T", v) + } + bytes, err := yaml.Marshal(v) + if err != nil { + t.Fatalf("%+v", err) + } + if string(yml) != "\n"+string(bytes) { + t.Fatalf("expected:[%s] actual:[%s]", string(yml), "\n"+string(bytes)) + } +} + +func TestDecoder_Stream(t *testing.T) { + yml := ` +--- +a: b +c: d +--- +e: f +g: h +--- +i: j +k: l +` + dec := yaml.NewDecoder(strings.NewReader(yml)) + values := []map[string]string{} + for { + var v map[string]string + if err := dec.Decode(&v); err != nil { + if err == io.EOF { + break + } + t.Fatalf("%+v", err) + } + values = append(values, v) + } + if len(values) != 3 { + t.Fatal("failed to stream decoding") + } + if values[0]["a"] != "b" { + t.Fatal("failed to stream decoding") + } + if values[1]["e"] != "f" { + t.Fatal("failed to stream decoding") + } + if values[2]["i"] != "j" { + t.Fatal("failed to stream decoding") + } +} + +type unmarshalYAMLWithAliasString string + +func (v *unmarshalYAMLWithAliasString) UnmarshalYAML(b []byte) error { + var s string + if err := yaml.Unmarshal(b, &s); err != nil { + return err + } + *v = unmarshalYAMLWithAliasString(s) + return nil +} + +type unmarshalYAMLWithAliasMap map[string]interface{} + +func (v *unmarshalYAMLWithAliasMap) UnmarshalYAML(b []byte) error { + var m map[string]interface{} + if err := yaml.Unmarshal(b, &m); err != nil { + return err + } + *v = unmarshalYAMLWithAliasMap(m) + return nil +} + +func TestDecoder_UnmarshalYAMLWithAlias(t *testing.T) { + type value struct { + String unmarshalYAMLWithAliasString + Map unmarshalYAMLWithAliasMap + } + tests := []struct { + name string + yaml string + expectedValue value + err string + }{ + { + name: "ok", + yaml: ` +anchors: + w: &w "\"hello\" \"world\"" + map: &x + a: b + c: d + d: *w +string: *w +map: + <<: *x + e: f +`, + expectedValue: value{ + String: unmarshalYAMLWithAliasString(`"hello" "world"`), + Map: unmarshalYAMLWithAliasMap(map[string]interface{}{ + "a": "b", + "c": "d", + "d": `"hello" "world"`, + "e": "f", + }), + }, + }, + { + name: "unknown alias", + yaml: ` +anchors: + w: &w "\"hello\" \"world\"" + map: &x + a: b + c: d + d: *w +string: *y +map: + <<: *z + e: f +`, + err: "cannot find anchor by alias name y", + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + var v value + err := yaml.Unmarshal([]byte(test.yaml), &v) + + if test.err != "" { + if err == nil { + t.Fatal("expected to error") + } + if !strings.Contains(err.Error(), test.err) { + t.Fatalf("expected error message: %s to contain: %s", err.Error(), test.err) + } + } else { + if err != nil { + t.Fatalf("%+v", err) + } + if !reflect.DeepEqual(test.expectedValue, v) { + t.Fatalf("non matching values:\nexpected[%s]\ngot [%s]", test.expectedValue, v) + } + } + }) + } +} + +type unmarshalString string + +func (u *unmarshalString) UnmarshalYAML(b []byte) error { + *u = unmarshalString(string(b)) + return nil +} + +type unmarshalList struct { + v []map[string]unmarshalString +} + +func (u *unmarshalList) UnmarshalYAML(b []byte) error { + expected := ` + - b: c + d: | + hello + + hello + f: g + - h: i` + actual := "\n" + string(b) + if expected != actual { + return xerrors.Errorf("unexpected bytes: expected [%q] but got [%q]", expected, actual) + } + var v []map[string]unmarshalString + if err := yaml.Unmarshal(b, &v); err != nil { + return err + } + u.v = v + return nil +} + +func TestDecoder_UnmarshalBytesWithSeparatedList(t *testing.T) { + yml := ` +a: + - b: c + d: | + hello + + hello + f: g + - h: i +` + var v struct { + A unmarshalList + } + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatal(err) + } + if len(v.A.v) != 2 { + t.Fatalf("failed to unmarshal %+v", v) + } + if len(v.A.v[0]) != 3 { + t.Fatalf("failed to unmarshal %+v", v.A.v[0]) + } + if len(v.A.v[1]) != 1 { + t.Fatalf("failed to unmarshal %+v", v.A.v[1]) + } +} + +func TestDecoder_LiteralWithNewLine(t *testing.T) { + type A struct { + Node string `yaml:"b"` + LastNode string `yaml:"last"` + } + tests := []A{ + A{ + Node: "hello\nworld", + }, + A{ + Node: "hello\nworld\n", + }, + A{ + Node: "hello\nworld\n\n", + }, + A{ + LastNode: "hello\nworld", + }, + A{ + LastNode: "hello\nworld\n", + }, + A{ + LastNode: "hello\nworld\n\n", + }, + } + // struct(want) -> Marshal -> Unmarchal -> struct(got) + for _, want := range tests { + bytes, _ := yaml.Marshal(want) + got := A{} + if err := yaml.Unmarshal(bytes, &got); err != nil { + t.Fatal(err) + } + if want.Node != got.Node { + t.Fatalf("expected:%q but got %q", want.Node, got.Node) + } + if want.LastNode != got.LastNode { + t.Fatalf("expected:%q but got %q", want.LastNode, got.LastNode) + } + } +} + +func TestDecoder_TabCharacterAtRight(t *testing.T) { + yml := ` +- a: [2 , 2] + b: [2 , 2] + c: [2 , 2]` + var v []map[string][]int + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatal(err) + } + if len(v) != 1 { + t.Fatalf("failed to unmarshal %+v", v) + } + if len(v[0]) != 3 { + t.Fatalf("failed to unmarshal %+v", v) + } +} + +func TestDecoder_Canonical(t *testing.T) { + yml := ` +!!map { + ? !!str "explicit":!!str "entry", + ? !!str "implicit" : !!str "entry", + ? !!null "" : !!null "", +} +` + var v interface{} + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatalf("%+v", err) + } + m, ok := v.(map[string]interface{}) + if !ok { + t.Fatalf("failed to decode canonical yaml: %+v", v) + } + if m["explicit"] != "entry" { + t.Fatalf("failed to decode canonical yaml: %+v", m) + } + if m["implicit"] != "entry" { + t.Fatalf("failed to decode canonical yaml: %+v", m) + } + if m["null"] != nil { + t.Fatalf("failed to decode canonical yaml: %+v", m) + } +} + +func TestDecoder_DecodeFromFile(t *testing.T) { + yml := ` +a: b +c: d +` + file, err := parser.ParseBytes([]byte(yml), 0) + if err != nil { + t.Fatal(err) + } + var v map[string]string + if err := yaml.NewDecoder(file).Decode(&v); err != nil { + t.Fatal(err) + } + if len(v) != 2 { + t.Fatal("failed to decode from ast.File") + } + if v["a"] != "b" { + t.Fatal("failed to decode from ast.File") + } + if v["c"] != "d" { + t.Fatal("failed to decode from ast.File") + } +} + +func TestDecoder_DecodeWithNode(t *testing.T) { + t.Run("abstract node", func(t *testing.T) { + type T struct { + Text ast.Node `yaml:"text"` + } + var v T + if err := yaml.Unmarshal([]byte(`text: hello`), &v); err != nil { + t.Fatalf("%+v", err) + } + expected := "hello" + got := v.Text.String() + if expected != got { + t.Fatalf("failed to decode to ast.Node: expected %s but got %s", expected, got) + } + }) + t.Run("concrete node", func(t *testing.T) { + type T struct { + Text *ast.StringNode `yaml:"text"` + } + var v T + if err := yaml.Unmarshal([]byte(`text: hello`), &v); err != nil { + t.Fatalf("%+v", err) + } + expected := "hello" + got := v.Text.String() + if expected != got { + t.Fatalf("failed to decode to ast.Node: expected %s but got %s", expected, got) + } + }) +} + +func TestRoundtripAnchorAlias(t *testing.T) { + t.Run("irreversible", func(t *testing.T) { + type foo struct { + K1 string + K2 string + } + + type bar struct { + K1 string + K3 string + } + + type doc struct { + Foo foo + Bar bar + } + yml := ` +foo: + <<: &test-anchor + k1: "One" + k2: "Two" + +bar: + <<: *test-anchor + k3: "Three" +` + var v doc + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatalf("%+v", err) + } + bytes, err := yaml.Marshal(v) + if err != nil { + t.Fatalf("%+v", err) + } + expected := ` +foo: + k1: One + k2: Two +bar: + k1: One + k3: Three +` + got := "\n" + string(bytes) + if expected != got { + t.Fatalf("expected:[%s] but got [%s]", expected, got) + } + }) + t.Run("reversible", func(t *testing.T) { + type TestAnchor struct { + K1 string + } + type foo struct { + *TestAnchor `yaml:",inline,alias"` + K2 string + } + type bar struct { + *TestAnchor `yaml:",inline,alias"` + K3 string + } + type doc struct { + TestAnchor *TestAnchor `yaml:"test-anchor,anchor"` + Foo foo + Bar bar + } + yml := ` +test-anchor: &test-anchor + k1: One +foo: + <<: *test-anchor + k2: Two +bar: + <<: *test-anchor + k3: Three +` + var v doc + if err := yaml.Unmarshal([]byte(yml), &v); err != nil { + t.Fatalf("%+v", err) + } + bytes, err := yaml.Marshal(v) + if err != nil { + t.Fatalf("%+v", err) + } + got := "\n" + string(bytes) + if yml != got { + t.Fatalf("expected:[%s] but got [%s]", yml, got) + } + }) +} |