Internal copy of go-yaml at f6f7691b1fdeb513f56608cd2c32c51f8194bf51

kyaml/internal/forked/github.com/go-yaml/yaml/decode_test.go

@@ -26,7 +26,7 @@ import (
 	"time"
 
 	. "gopkg.in/check.v1"
-	"sigs.k8s.io/kustomize/kyaml/internal/forked/github.com/go-yaml/yaml"
+	"gopkg.in/yaml.v3"
 )
 
 var unmarshalIntTest = 123
@@ -767,7 +767,7 @@ var unmarshalTests = []struct {
 		M{"a": 123456e1},
 	}, {
 		"a: 123456E1\n",
-		M{"a": 123456E1},
+		M{"a": 123456e1},
 	},
 	// yaml-test-suite 3GZX: Spec Example 7.1. Alias Nodes
 	{
@@ -802,7 +802,6 @@ var unmarshalTests = []struct {
 			"c": []interface{}{"d", "e"},
 		},
 	},
-
 }
 
 type M map[string]interface{}
@@ -948,16 +947,18 @@ var unmarshalErrorTests = []struct {
 	{"%TAG !%79! tag:yaml.org,2002:\n---\nv: !%79!int '1'", "yaml: did not find expected whitespace"},
 	{"a:\n  1:\nb\n  2:", ".*could not find expected ':'"},
 	{"a: 1\nb: 2\nc 2\nd: 3\n", "^yaml: line 3: could not find expected ':'$"},
+	{"#\n-\n{", "yaml: line 3: could not find expected ':'"}, // Issue #665
+	{"0: [:!00 \xef", "yaml: incomplete UTF-8 octet sequence"}, // Issue #666
 	{
 		"a: &a [00,00,00,00,00,00,00,00,00]\n" +
-		"b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]\n" +
-		"c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]\n" +
-		"d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]\n" +
-		"e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]\n" +
-		"f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]\n" +
-		"g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]\n" +
-		"h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]\n" +
-		"i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]\n",
+			"b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]\n" +
+			"c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]\n" +
+			"d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]\n" +
+			"e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]\n" +
+			"f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]\n" +
+			"g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]\n" +
+			"h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]\n" +
+			"i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]\n",
 		"yaml: document contains excessive aliasing",
 	},
 }
@@ -1391,7 +1392,7 @@ inlineSequenceMap:
 `
 
 func (s *S) TestMerge(c *C) {
-	var want = map[interface{}]interface{}{
+	var want = map[string]interface{}{
 		"x":     1,
 		"y":     2,
 		"r":     10,
@@ -1436,7 +1437,103 @@ func (s *S) TestMergeStruct(c *C) {
 	}
 }
 
-var unmarshalNullTests = []struct{ input string; pristine, expected func() interface{} }{{
+var mergeTestsNested = `
+mergeouter1: &mergeouter1
+    d: 40
+    e: 50
+
+mergeouter2: &mergeouter2
+    e: 5
+    f: 6
+    g: 70
+
+mergeinner1: &mergeinner1
+    <<: *mergeouter1
+    inner:
+        a: 1
+        b: 2
+
+mergeinner2: &mergeinner2
+    <<: *mergeouter2
+    inner:
+        a: -1
+        b: -2
+
+outer:
+    <<: [*mergeinner1, *mergeinner2]
+    f: 60
+    inner:
+        a: 10
+`
+
+func (s *S) TestMergeNestedStruct(c *C) {
+	// Issue #818: Merging used to just unmarshal twice on the target
+	// value, which worked for maps as these were replaced by the new map,
+	// but not on struct values as these are preserved. This resulted in
+	// the nested data from the merged map to be mixed up with the data
+	// from the map being merged into.
+	//
+	// This test also prevents two potential bugs from showing up:
+	//
+	// 1) A simple implementation might just zero out the nested value
+	//    before unmarshaling the second time, but this would clobber previous
+	//    data that is usually respected ({C: 30} below).
+	//
+	// 2) A simple implementation might attempt to handle the key skipping
+	//    directly by iterating over the merging map without recursion, but
+	//    there are more complex cases that require recursion.
+	// 
+	// Quick summary of the fields:
+	//
+	// - A must come from outer and not overriden
+	// - B must not be set as its in the ignored merge
+	// - C should still be set as it's preset in the value
+	// - D should be set from the recursive merge
+	// - E should be set from the first recursive merge, ignored on the second
+	// - F should be set in the inlined map from outer, ignored later
+	// - G should be set in the inlined map from the second recursive merge
+	//
+
+	type Inner struct {
+		A, B, C int
+	}
+	type Outer struct {
+		D, E      int
+		Inner  Inner
+		Inline map[string]int `yaml:",inline"`
+	}
+	type Data struct {
+		Outer Outer
+	}
+
+	test := Data{Outer{0, 0, Inner{C: 30}, nil}}
+	want := Data{Outer{40, 50, Inner{A: 10, C: 30}, map[string]int{"f": 60, "g": 70}}}
+
+	err := yaml.Unmarshal([]byte(mergeTestsNested), &test)
+	c.Assert(err, IsNil)
+	c.Assert(test, DeepEquals, want)
+
+	// Repeat test with a map.
+
+	var testm map[string]interface{}
+	var wantm = map[string]interface {} {
+		"f":     60,
+		"inner": map[string]interface{}{
+		    "a": 10,
+		},
+		"d": 40,
+		"e": 50,
+		"g": 70,
+	}
+	err = yaml.Unmarshal([]byte(mergeTestsNested), &testm)
+	c.Assert(err, IsNil)
+	c.Assert(testm["outer"], DeepEquals, wantm)
+}
+
+var unmarshalNullTests = []struct {
+	input              string
+	pristine, expected func() interface{}
+}{{
 	"null",
 	func() interface{} { var v interface{}; v = "v"; return &v },
 	func() interface{} { var v interface{}; v = nil; return &v },
@@ -1487,7 +1584,7 @@ func (s *S) TestUnmarshalNull(c *C) {
 func (s *S) TestUnmarshalPreservesData(c *C) {
 	var v struct {
 		A, B int
-		C int `yaml:"-"`
+		C    int `yaml:"-"`
 	}
 	v.A = 42
 	v.C = 88