From beea785ead7b178607c9e52f4210a57e0aa8a2d6 Mon Sep 17 00:00:00 2001 From: Natasha Sarkar Date: Thu, 24 Jun 2021 12:06:12 -0700 Subject: [PATCH] tests for compactSeqIndent --- .../github.com/go-yaml/yaml/encode_test.go | 109 +++++++++++++++++- 1 file changed, 106 insertions(+), 3 deletions(-) diff --git a/kyaml/internal/forked/github.com/go-yaml/yaml/encode_test.go b/kyaml/internal/forked/github.com/go-yaml/yaml/encode_test.go index 313781827..c941e0dee 100644 --- a/kyaml/internal/forked/github.com/go-yaml/yaml/encode_test.go +++ b/kyaml/internal/forked/github.com/go-yaml/yaml/encode_test.go @@ -35,109 +35,142 @@ var marshalIntTest = 123 var marshalTests = []struct { value interface{} data string + compact string }{ { nil, "null\n", + "null\n", }, { (*marshalerType)(nil), "null\n", + "null\n", }, { &struct{}{}, "{}\n", + "{}\n", }, { map[string]string{"v": "hi"}, "v: hi\n", + "v: hi\n", }, { map[string]interface{}{"v": "hi"}, "v: hi\n", + "v: hi\n", }, { map[string]string{"v": "true"}, "v: \"true\"\n", + "v: \"true\"\n", }, { map[string]string{"v": "false"}, "v: \"false\"\n", + "v: \"false\"\n", }, { map[string]interface{}{"v": true}, "v: true\n", + "v: true\n", }, { map[string]interface{}{"v": false}, "v: false\n", + "v: false\n", }, { map[string]interface{}{"v": 10}, "v: 10\n", + "v: 10\n", }, { map[string]interface{}{"v": -10}, "v: -10\n", + "v: -10\n", }, { map[string]uint{"v": 42}, "v: 42\n", + "v: 42\n", }, { map[string]interface{}{"v": int64(4294967296)}, "v: 4294967296\n", + "v: 4294967296\n", }, { map[string]int64{"v": int64(4294967296)}, "v: 4294967296\n", + "v: 4294967296\n", }, { map[string]uint64{"v": 4294967296}, "v: 4294967296\n", + "v: 4294967296\n", }, { map[string]interface{}{"v": "10"}, "v: \"10\"\n", + "v: \"10\"\n", }, { map[string]interface{}{"v": 0.1}, "v: 0.1\n", + "v: 0.1\n", }, { map[string]interface{}{"v": float64(0.1)}, "v: 0.1\n", + "v: 0.1\n", }, { map[string]interface{}{"v": float32(0.99)}, "v: 0.99\n", + "v: 0.99\n", }, { map[string]interface{}{"v": -0.1}, "v: -0.1\n", + "v: -0.1\n", }, { map[string]interface{}{"v": math.Inf(+1)}, "v: .inf\n", + "v: .inf\n", }, { map[string]interface{}{"v": math.Inf(-1)}, "v: -.inf\n", + "v: -.inf\n", }, { map[string]interface{}{"v": math.NaN()}, "v: .nan\n", + "v: .nan\n", }, { map[string]interface{}{"v": nil}, "v: null\n", + "v: null\n", }, { map[string]interface{}{"v": ""}, "v: \"\"\n", + "v: \"\"\n", }, { - map[string][]string{"v": []string{"A", "B"}}, + map[string][]string{"v": {"A", "B"}}, "v:\n - A\n - B\n", + "v:\n - A\n - B\n", }, { - map[string][]string{"v": []string{"A", "B\nC"}}, + map[string][]string{"v": {"A", "B\nC"}}, "v:\n - A\n - |-\n B\n C\n", + "v:\n - A\n - |-\n B\n C\n", }, { - map[string][]interface{}{"v": []interface{}{"A", 1, map[string][]int{"B": []int{2, 3}}}}, + map[string][]interface{}{"v": {"A", 1, map[string][]int{"B": {2, 3}}}}, "v:\n - A\n - 1\n - B:\n - 2\n - 3\n", + "v:\n - A\n - 1\n - B:\n - 2\n - 3\n", }, { map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}}, "a:\n b: c\n", + "a:\n b: c\n", }, { map[string]interface{}{"a": "-"}, "a: '-'\n", + "a: '-'\n", }, // Simple values. { &marshalIntTest, "123\n", + "123\n", }, // Structures { &struct{ Hello string }{"world"}, "hello: world\n", + "hello: world\n", }, { &struct { A struct { @@ -145,6 +178,7 @@ var marshalTests = []struct { } }{struct{ B string }{"c"}}, "a:\n b: c\n", + "a:\n b: c\n", }, { &struct { A *struct { @@ -152,6 +186,7 @@ var marshalTests = []struct { } }{&struct{ B string }{"c"}}, "a:\n b: c\n", + "a:\n b: c\n", }, { &struct { A *struct { @@ -159,29 +194,37 @@ var marshalTests = []struct { } }{}, "a: null\n", + "a: null\n", }, { &struct{ A int }{1}, "a: 1\n", + "a: 1\n", }, { &struct{ A []int }{[]int{1, 2}}, "a:\n - 1\n - 2\n", + "a:\n - 1\n - 2\n", }, { &struct{ A [2]int }{[2]int{1, 2}}, "a:\n - 1\n - 2\n", + "a:\n - 1\n - 2\n", }, { &struct { B int "a" }{1}, "a: 1\n", + "a: 1\n", }, { &struct{ A bool }{true}, "a: true\n", + "a: true\n", }, { &struct{ A string }{"true"}, "a: \"true\"\n", + "a: \"true\"\n", }, { &struct{ A string }{"off"}, "a: \"off\"\n", + "a: \"off\"\n", }, // Conditional flag @@ -191,43 +234,51 @@ var marshalTests = []struct { B int "b,omitempty" }{1, 0}, "a: 1\n", + "a: 1\n", }, { &struct { A int "a,omitempty" B int "b,omitempty" }{0, 0}, "{}\n", + "{}\n", }, { &struct { A *struct{ X, y int } "a,omitempty,flow" }{&struct{ X, y int }{1, 2}}, "a: {x: 1}\n", + "a: {x: 1}\n", }, { &struct { A *struct{ X, y int } "a,omitempty,flow" }{nil}, "{}\n", + "{}\n", }, { &struct { A *struct{ X, y int } "a,omitempty,flow" }{&struct{ X, y int }{}}, "a: {x: 0}\n", + "a: {x: 0}\n", }, { &struct { A struct{ X, y int } "a,omitempty,flow" }{struct{ X, y int }{1, 2}}, "a: {x: 1}\n", + "a: {x: 1}\n", }, { &struct { A struct{ X, y int } "a,omitempty,flow" }{struct{ X, y int }{0, 1}}, "{}\n", + "{}\n", }, { &struct { A float64 "a,omitempty" B float64 "b,omitempty" }{1, 0}, "a: 1\n", + "a: 1\n", }, { &struct { @@ -240,6 +291,7 @@ var marshalTests = []struct { T4: newTime(time.Date(2098, 1, 9, 10, 40, 47, 0, time.UTC)), }, "t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n", + "t2: 2018-01-09T10:40:47Z\nt4: 2098-01-09T10:40:47Z\n", }, // Nil interface that implements Marshaler. { @@ -247,6 +299,7 @@ var marshalTests = []struct { "a": nil, }, "a: null\n", + "a: null\n", }, // Flow flag @@ -255,11 +308,13 @@ var marshalTests = []struct { A []int "a,flow" }{[]int{1, 2}}, "a: [1, 2]\n", + "a: [1, 2]\n", }, { &struct { A map[string]string "a,flow" }{map[string]string{"b": "c", "d": "e"}}, "a: {b: c, d: e}\n", + "a: {b: c, d: e}\n", }, { &struct { A struct { @@ -267,11 +322,13 @@ var marshalTests = []struct { } "a,flow" }{struct{ B, D string }{"c", "e"}}, "a: {b: c, d: e}\n", + "a: {b: c, d: e}\n", }, { &struct { A string "a,flow" }{"b\nc"}, "a: \"b\\nc\"\n", + "a: \"b\\nc\"\n", }, // Unexported field @@ -281,6 +338,7 @@ var marshalTests = []struct { A int }{0, 1}, "a: 1\n", + "a: 1\n", }, // Ignored field @@ -290,6 +348,7 @@ var marshalTests = []struct { B int "-" }{1, 2}, "a: 1\n", + "a: 1\n", }, // Struct inlining @@ -299,6 +358,7 @@ var marshalTests = []struct { C inlineB `yaml:",inline"` }{1, inlineB{2, inlineC{3}}}, "a: 1\nb: 2\nc: 3\n", + "a: 1\nb: 2\nc: 3\n", }, // Struct inlining as a pointer { @@ -307,18 +367,21 @@ var marshalTests = []struct { C *inlineB `yaml:",inline"` }{1, &inlineB{2, inlineC{3}}}, "a: 1\nb: 2\nc: 3\n", + "a: 1\nb: 2\nc: 3\n", }, { &struct { A int C *inlineB `yaml:",inline"` }{1, nil}, "a: 1\n", + "a: 1\n", }, { &struct { A int D *inlineD `yaml:",inline"` }{1, &inlineD{&inlineC{3}, 4}}, "a: 1\nc: 3\nd: 4\n", + "a: 1\nc: 3\nd: 4\n", }, // Map inlining @@ -328,18 +391,21 @@ var marshalTests = []struct { C map[string]int `yaml:",inline"` }{1, map[string]int{"b": 2, "c": 3}}, "a: 1\nb: 2\nc: 3\n", + "a: 1\nb: 2\nc: 3\n", }, // Duration { map[string]time.Duration{"a": 3 * time.Second}, "a: 3s\n", + "a: 3s\n", }, // Issue #24: bug in map merging logic. { map[string]string{"a": ""}, "a: \n", + "a: \n", }, // Issue #34: marshal unsupported base 60 floats quoted for compatibility @@ -347,92 +413,110 @@ var marshalTests = []struct { { map[string]string{"a": "1:1"}, "a: \"1:1\"\n", + "a: \"1:1\"\n", }, // Binary data. { map[string]string{"a": "\x00"}, "a: \"\\0\"\n", + "a: \"\\0\"\n", }, { map[string]string{"a": "\x80\x81\x82"}, "a: !!binary gIGC\n", + "a: !!binary gIGC\n", }, { map[string]string{"a": strings.Repeat("\x90", 54)}, "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n", + "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n", }, // Encode unicode as utf-8 rather than in escaped form. { map[string]string{"a": "你好"}, "a: 你好\n", + "a: 你好\n", }, // Support encoding.TextMarshaler. { map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)}, "a: 1.2.3.4\n", + "a: 1.2.3.4\n", }, // time.Time gets a timestamp tag. { map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)}, "a: 2015-02-24T18:19:39Z\n", + "a: 2015-02-24T18:19:39Z\n", }, { map[string]*time.Time{"a": newTime(time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC))}, "a: 2015-02-24T18:19:39Z\n", + "a: 2015-02-24T18:19:39Z\n", }, { // This is confirmed to be properly decoded in Python (libyaml) without a timestamp tag. map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 123456789, time.FixedZone("FOO", -3*60*60))}, "a: 2015-02-24T18:19:39.123456789-03:00\n", + "a: 2015-02-24T18:19:39.123456789-03:00\n", }, // Ensure timestamp-like strings are quoted. { map[string]string{"a": "2015-02-24T18:19:39Z"}, "a: \"2015-02-24T18:19:39Z\"\n", + "a: \"2015-02-24T18:19:39Z\"\n", }, // Ensure strings containing ": " are quoted (reported as PR #43, but not reproducible). { map[string]string{"a": "b: c"}, "a: 'b: c'\n", + "a: 'b: c'\n", }, // Containing hash mark ('#') in string should be quoted { map[string]string{"a": "Hello #comment"}, "a: 'Hello #comment'\n", + "a: 'Hello #comment'\n", }, { map[string]string{"a": "你好 #comment"}, "a: '你好 #comment'\n", + "a: '你好 #comment'\n", }, // Ensure MarshalYAML also gets called on the result of MarshalYAML itself. { &marshalerType{marshalerType{true}}, "true\n", + "true\n", }, { &marshalerType{&marshalerType{true}}, "true\n", + "true\n", }, // Check indentation of maps inside sequences inside maps. { map[string]interface{}{"a": map[string]interface{}{"b": []map[string]int{{"c": 1, "d": 2}}}}, "a:\n b:\n - c: 1\n d: 2\n", + "a:\n b:\n - c: 1\n d: 2\n", }, // Strings with tabs were disallowed as literals (issue #471). { map[string]string{"a": "\tB\n\tC\n"}, "a: |\n \tB\n \tC\n", + "a: |\n \tB\n \tC\n", }, // Ensure that strings do not wrap { map[string]string{"a": "abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 "}, "a: 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 '\n", + "a: 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 '\n", }, // yaml.Node @@ -448,6 +532,7 @@ var marshalTests = []struct { }, }, "value: 'foo'\n", + "value: 'foo'\n", }, { yaml.Node{ Kind: yaml.ScalarNode, @@ -456,6 +541,7 @@ var marshalTests = []struct { Style: yaml.SingleQuotedStyle, }, "'foo'\n", + "'foo'\n", }, // Enforced tagging with shorthand notation (issue #616). @@ -471,6 +557,7 @@ var marshalTests = []struct { }, }, "value: !!str foo\n", + "value: !!str foo\n", }, { &struct { Value yaml.Node @@ -482,6 +569,7 @@ var marshalTests = []struct { }, }, "value: !!map {}\n", + "value: !!map {}\n", }, { &struct { Value yaml.Node @@ -493,6 +581,7 @@ var marshalTests = []struct { }, }, "value: !!seq []\n", + "value: !!seq []\n", }, } @@ -507,6 +596,20 @@ func (s *S) TestMarshal(c *C) { } } +func (s *S) TestEncoderCompactIndents(c *C) { + for i, item := range marshalTests { + c.Logf("test %d. %q", i, item.data) + var buf bytes.Buffer + enc := yaml.NewEncoder(&buf) + enc.CompactSeqIndent() + err := enc.Encode(item.value) + c.Assert(err, Equals, nil) + err = enc.Close() + c.Assert(err, Equals, nil) + c.Assert(buf.String(), Equals, item.compact) + } +} + func (s *S) TestEncoderSingleDocument(c *C) { for i, item := range marshalTests { c.Logf("test %d. %q", i, item.data)