diff --git a/internal/third_party/yaml/decode_test.go b/internal/third_party/yaml/decode_test.go
index 9269f12..be4d034 100644
--- a/internal/third_party/yaml/decode_test.go
+++ b/internal/third_party/yaml/decode_test.go
@@ -1,94 +1,100 @@
 package yaml_test
 
 import (
+	"bytes"
 	"errors"
+	"flag"
+	"fmt"
 	"io"
-	"math"
-	"reflect"
+	"io/ioutil"
+	"strconv"
 	"strings"
-	"time"
+	"testing"
 
-	. "gopkg.in/check.v1"
-	"gopkg.in/yaml.v2"
+	"cuelang.org/go/cue/ast"
+	"cuelang.org/go/cue/format"
+	"cuelang.org/go/cue/token"
+	"cuelang.org/go/internal/third_party/yaml"
 )
 
+var update = flag.Bool("update", false, "update test data")
+
 var unmarshalIntTest = 123
 
 var unmarshalTests = []struct {
-	data  string
-	value interface{}
+	data string
+	want string
 }{
 	{
 		"",
-		(*struct{})(nil),
+		"",
 	},
 	{
-		"{}", &struct{}{},
+		"{}",
+		"",
 	}, {
 		"v: hi",
-		map[string]string{"v": "hi"},
+		`v: "hi"`,
 	}, {
-		"v: hi", map[string]interface{}{"v": "hi"},
+		"v: hi",
+		`v: "hi"`,
 	}, {
 		"v: true",
-		map[string]string{"v": "true"},
-	}, {
 		"v: true",
-		map[string]interface{}{"v": true},
 	}, {
 		"v: 10",
-		map[string]interface{}{"v": 10},
+		"v: 10",
 	}, {
 		"v: 0b10",
-		map[string]interface{}{"v": 2},
+		"v: 0b10",
 	}, {
 		"v: 0xA",
-		map[string]interface{}{"v": 10},
+		"v: 0xA",
 	}, {
 		"v: 4294967296",
-		map[string]int64{"v": 4294967296},
+		"v: 4294967296",
 	}, {
 		"v: 0.1",
-		map[string]interface{}{"v": 0.1},
+		"v: 0.1",
 	}, {
 		"v: .1",
-		map[string]interface{}{"v": 0.1},
+		"v: .1",
 	}, {
 		"v: .Inf",
-		map[string]interface{}{"v": math.Inf(+1)},
+		"v: +Inf",
 	}, {
 		"v: -.Inf",
-		map[string]interface{}{"v": math.Inf(-1)},
+		"v: -Inf",
 	}, {
 		"v: -10",
-		map[string]interface{}{"v": -10},
+		"v: -10",
 	}, {
 		"v: -.1",
-		map[string]interface{}{"v": -0.1},
+		"v: -.1",
 	},
 
 	// Simple values.
 	{
 		"123",
-		&unmarshalIntTest,
+		"123",
 	},
 
 	// Floats from spec
 	{
 		"canonical: 6.8523e+5",
-		map[string]interface{}{"canonical": 6.8523e+5},
+		"canonical: 6.8523e+5",
 	}, {
 		"expo: 685.230_15e+03",
-		map[string]interface{}{"expo": 685.23015e+03},
+		"expo: 685.230_15e+03",
 	}, {
 		"fixed: 685_230.15",
-		map[string]interface{}{"fixed": 685230.15},
+		"fixed: 685_230.15",
 	}, {
 		"neginf: -.inf",
-		map[string]interface{}{"neginf": math.Inf(-1)},
+		"neginf: -Inf",
 	}, {
 		"fixed: 685_230.15",
-		map[string]float64{"fixed": 685230.15},
+		"fixed: 685_230.15",
 	},
 	//{"sexa: 190:20:30.15", map[string]interface{}{"sexa": 0}}, // Unsupported
 	//{"notanum: .NaN", map[string]interface{}{"notanum": math.NaN()}}, // Equality of NaN fails.
@@ -96,45 +102,42 @@
 	// Bools from spec
 	{
 		"canonical: y",
-		map[string]interface{}{"canonical": true},
+		"canonical: true",
 	}, {
 		"answer: NO",
-		map[string]interface{}{"answer": false},
+		"answer: false",
 	}, {
 		"logical: True",
-		map[string]interface{}{"logical": true},
+		"logical: true",
 	}, {
 		"option: on",
-		map[string]interface{}{"option": true},
-	}, {
-		"option: on",
-		map[string]bool{"option": true},
+		"option: true",
 	},
 	// Ints from spec
 	{
 		"canonical: 685230",
-		map[string]interface{}{"canonical": 685230},
+		"canonical: 685230",
 	}, {
 		"decimal: +685_230",
-		map[string]interface{}{"decimal": 685230},
+		"decimal: +685_230",
 	}, {
 		"octal: 02472256",
-		map[string]interface{}{"octal": 685230},
+		"octal: 02472256",
 	}, {
 		"hexa: 0x_0A_74_AE",
-		map[string]interface{}{"hexa": 685230},
+		"hexa: 0x_0A_74_AE",
 	}, {
 		"bin: 0b1010_0111_0100_1010_1110",
-		map[string]interface{}{"bin": 685230},
+		"bin: 0b1010_0111_0100_1010_1110",
 	}, {
 		"bin: -0b101010",
-		map[string]interface{}{"bin": -42},
+		"bin: -0b101010",
 	}, {
 		"bin: -0b1000000000000000000000000000000000000000000000000000000000000000",
-		map[string]interface{}{"bin": -9223372036854775808},
+		"bin: -0b1000000000000000000000000000000000000000000000000000000000000000",
 	}, {
 		"decimal: +685_230",
-		map[string]int{"decimal": 685230},
+		"decimal: +685_230",
 	},
 
 	//{"sexa: 190:20:30", map[string]interface{}{"sexa": 0}}, // Unsupported
@@ -142,339 +145,276 @@
 	// Nulls from spec
 	{
 		"empty:",
-		map[string]interface{}{"empty": nil},
+		"empty: null",
 	}, {
 		"canonical: ~",
-		map[string]interface{}{"canonical": nil},
+		"canonical: null",
 	}, {
 		"english: null",
-		map[string]interface{}{"english": nil},
+		"english: null",
 	}, {
 		"~: null key",
-		map[interface{}]string{nil: "null key"},
-	}, {
-		"empty:",
-		map[string]*bool{"empty": nil},
+		`"~": "null key"`,
 	},
 
 	// Flow sequence
 	{
 		"seq: [A,B]",
-		map[string]interface{}{"seq": []interface{}{"A", "B"}},
+		`seq: ["A", "B"]`,
 	}, {
 		"seq: [A,B,C,]",
-		map[string][]string{"seq": []string{"A", "B", "C"}},
+		`seq: ["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"}},
+		`seq: ["A", 1, "C"]`,
 	},
 	// Block sequence
 	{
 		"seq:\n - A\n - B",
-		map[string]interface{}{"seq": []interface{}{"A", "B"}},
+		`seq: ["A", "B"]`,
 	}, {
 		"seq:\n - A\n - B\n - C",
-		map[string][]string{"seq": []string{"A", "B", "C"}},
+		`seq: ["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"}},
+		`seq: ["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"},
+		`scalar: """
+
+		literal
+
+		\ttext
+
+		"""`,
 	},
 
 	// 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"},
+		`scalar: """
+
+		folded line
+		next line
+		 * one
+		 * two
+
+		last line
+
+		"""`,
 	},
 
-	// Map inside interface with no type hints.
+	// Structs
 	{
 		"a: {b: c}",
-		map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
+		`a 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"}},
+		`hello: "world"`,
 	}, {
 		"a:",
-		&struct{ A map[string]string }{},
+		"a: null",
 	}, {
 		"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 "a"
-		}{1},
 	}, {
 		"a: y",
-		&struct{ A bool }{true},
+		"a: true",
+	}, {
+		"{ a: 1, b: {c: 1} }",
+		"a: 1\nb c: 1",
 	},
 
 	// Some cross type conversions
 	{
 		"v: 42",
-		map[string]uint{"v": 42},
+		"v: 42",
 	}, {
 		"v: -42",
-		map[string]uint{},
+		"v: -42",
 	}, {
 		"v: 4294967296",
-		map[string]uint64{"v": 4294967296},
+		"v: 4294967296",
 	}, {
 		"v: -4294967296",
-		map[string]uint64{},
+		"v: -4294967296",
 	},
 
 	// int
 	{
 		"int_max: 2147483647",
-		map[string]int{"int_max": math.MaxInt32},
+		"int_max: 2147483647",
 	},
 	{
 		"int_min: -2147483648",
-		map[string]int{"int_min": math.MinInt32},
+		"int_min: -2147483648",
 	},
 	{
 		"int_overflow: 9223372036854775808", // math.MaxInt64 + 1
-		map[string]int{},
+		"int_overflow: 9223372036854775808", // math.MaxInt64 + 1
 	},
 
 	// int64
 	{
 		"int64_max: 9223372036854775807",
-		map[string]int64{"int64_max": math.MaxInt64},
+		"int64_max: 9223372036854775807",
 	},
 	{
 		"int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
-		map[string]int64{"int64_max_base2": math.MaxInt64},
+		"int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
 	},
 	{
 		"int64_min: -9223372036854775808",
-		map[string]int64{"int64_min": math.MinInt64},
+		"int64_min: -9223372036854775808",
 	},
 	{
 		"int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
-		map[string]int64{"int64_neg_base2": -math.MaxInt64},
+		"int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
 	},
 	{
 		"int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
-		map[string]int64{},
+		"int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
 	},
 
 	// uint
 	{
-		"uint_min: 0",
-		map[string]uint{"uint_min": 0},
-	},
-	{
 		"uint_max: 4294967295",
-		map[string]uint{"uint_max": math.MaxUint32},
-	},
-	{
-		"uint_underflow: -1",
-		map[string]uint{},
+		"uint_max: 4294967295",
 	},
 
 	// uint64
 	{
-		"uint64_min: 0",
-		map[string]uint{"uint64_min": 0},
-	},
-	{
 		"uint64_max: 18446744073709551615",
-		map[string]uint64{"uint64_max": math.MaxUint64},
+		"uint64_max: 18446744073709551615",
 	},
 	{
 		"uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
-		map[string]uint64{"uint64_max_base2": math.MaxUint64},
+		"uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
 	},
 	{
 		"uint64_maxint64: 9223372036854775807",
-		map[string]uint64{"uint64_maxint64": math.MaxInt64},
-	},
-	{
-		"uint64_underflow: -1",
-		map[string]uint64{},
+		"uint64_maxint64: 9223372036854775807",
 	},
 
 	// float32
 	{
 		"float32_max: 3.40282346638528859811704183484516925440e+38",
-		map[string]float32{"float32_max": math.MaxFloat32},
+		"float32_max: 3.40282346638528859811704183484516925440e+38",
 	},
 	{
 		"float32_nonzero: 1.401298464324817070923729583289916131280e-45",
-		map[string]float32{"float32_nonzero": math.SmallestNonzeroFloat32},
+		"float32_nonzero: 1.401298464324817070923729583289916131280e-45",
 	},
 	{
 		"float32_maxuint64: 18446744073709551615",
-		map[string]float32{"float32_maxuint64": float32(math.MaxUint64)},
+		"float32_maxuint64: 18446744073709551615",
 	},
 	{
 		"float32_maxuint64+1: 18446744073709551616",
-		map[string]float32{"float32_maxuint64+1": float32(math.MaxUint64 + 1)},
+		`"float32_maxuint64+1": 18446744073709551616`,
 	},
 
 	// float64
 	{
 		"float64_max: 1.797693134862315708145274237317043567981e+308",
-		map[string]float64{"float64_max": math.MaxFloat64},
+		"float64_max: 1.797693134862315708145274237317043567981e+308",
 	},
 	{
 		"float64_nonzero: 4.940656458412465441765687928682213723651e-324",
-		map[string]float64{"float64_nonzero": math.SmallestNonzeroFloat64},
+		"float64_nonzero: 4.940656458412465441765687928682213723651e-324",
 	},
 	{
 		"float64_maxuint64: 18446744073709551615",
-		map[string]float64{"float64_maxuint64": float64(math.MaxUint64)},
+		"float64_maxuint64: 18446744073709551615",
 	},
 	{
 		"float64_maxuint64+1: 18446744073709551616",
-		map[string]float64{"float64_maxuint64+1": float64(math.MaxUint64 + 1)},
+		`"float64_maxuint64+1": 18446744073709551616`,
 	},
 
 	// Overflow cases.
 	{
 		"v: 4294967297",
-		map[string]int32{},
+		"v: 4294967297",
 	}, {
 		"v: 128",
-		map[string]int8{},
+		"v: 128",
 	},
 
 	// Quoted values.
 	{
 		"'1': '\"2\"'",
-		map[interface{}]interface{}{"1": "\"2\""},
+		`"1": "\"2\""`,
 	}, {
 		"v:\n- A\n- 'B\n\n  C'\n",
-		map[string][]string{"v": []string{"A", "B\nC"}},
+		`v: ["A", """
+		B
+		C
+		"""]`,
 	},
 
 	// Explicit tags.
 	{
 		"v: !!float '1.1'",
-		map[string]interface{}{"v": 1.1},
+		"v: 1.1",
 	}, {
 		"v: !!float 0",
-		map[string]interface{}{"v": float64(0)},
+		"v: float & 0", // Should this be 0.0?
 	}, {
 		"v: !!float -1",
-		map[string]interface{}{"v": float64(-1)},
+		"v: float & -1", // Should this be -1.0?
 	}, {
 		"v: !!null ''",
-		map[string]interface{}{"v": nil},
+		"v: null",
 	}, {
 		"%TAG !y! tag:yaml.org,2002:\n---\nv: !y!int '1'",
-		map[string]interface{}{"v": 1},
+		"v: 1",
 	},
 
 	// Non-specific tag (Issue #75)
 	{
 		"v: ! test",
-		map[string]interface{}{"v": "test"},
+		// TODO: map[string]interface{}{"v": "test"},
+		"",
 	},
 
 	// 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: 1
+b: 2
+c: 1
+d: 2`,
 	}, {
 		"a: &a {c: 1}\nb: *a",
-		&struct {
-			A, B struct {
-				C int
-			}
-		}{struct{ C int }{1}, struct{ C int }{1}},
+		"a c: 1\nb c: 1",
 	}, {
 		"a: &a [1, 2]\nb: *a",
-		&struct{ B []int }{[]int{1, 2}},
+		"a: [1, 2]\nb: [1, 2]", // TODO: a: [1, 2], b: a
 	},
 
-	// Bug #1133337
 	{
 		"foo: ''",
-		map[string]*string{"foo": new(string)},
+		`foo: ""`,
 	}, {
 		"foo: null",
-		map[string]*string{"foo": nil},
-	}, {
 		"foo: null",
-		map[string]string{"foo": ""},
-	}, {
-		"foo: null",
-		map[string]interface{}{"foo": nil},
 	},
 
 	// Support for ~
 	{
 		"foo: ~",
-		map[string]*string{"foo": nil},
-	}, {
-		"foo: ~",
-		map[string]string{"foo": ""},
-	}, {
-		"foo: ~",
-		map[string]interface{}{"foo": nil},
-	},
-
-	// Ignored field
-	{
-		"a: 1\nb: 2\n",
-		&struct {
-			A int
-			B int "-"
-		}{1, 0},
+		"foo: null",
 	},
 
 	// Bug #1191981
@@ -486,139 +426,108 @@
 			` 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}}},
-	},
-
-	// Map inlining
-	{
-		"a: 1\nb: 2\nc: 3\n",
-		&struct {
-			A int
-			C map[string]int `yaml:",inline"`
-		}{1, map[string]int{"b": 2, "c": 3}},
+		`"""
+		Generic line break (no glyph)
+		Generic line break (glyphed)
+		Line separator\u2028Paragraph separator\u2029
+		"""`,
 	},
 
 	// bug 1243827
 	{
 		"a: -b_c",
-		map[string]interface{}{"a": "-b_c"},
+		`a: "-b_c"`,
 	},
 	{
 		"a: +b_c",
-		map[string]interface{}{"a": "+b_c"},
+		`a: "+b_c"`,
 	},
 	{
 		"a: 50cent_of_dollar",
-		map[string]interface{}{"a": "50cent_of_dollar"},
+		`a: "50cent_of_dollar"`,
 	},
 
 	// issue #295 (allow scalars with colons in flow mappings and sequences)
 	{
 		"a: {b: https://github.com/go-yaml/yaml}",
-		map[string]interface{}{"a": map[interface{}]interface{}{
-			"b": "https://github.com/go-yaml/yaml",
-		}},
+		`a b: "https://github.com/go-yaml/yaml"`,
 	},
 	{
 		"a: [https://github.com/go-yaml/yaml]",
-		map[string]interface{}{"a": []interface{}{"https://github.com/go-yaml/yaml"}},
+		`a: ["https://github.com/go-yaml/yaml"]`,
 	},
 
 	// Duration
 	{
 		"a: 3s",
-		map[string]time.Duration{"a": 3 * time.Second},
+		`a: "3s"`, // for now
 	},
 
 	// Issue #24.
 	{
 		"a: <foo>",
-		map[string]string{"a": "<foo>"},
+		`a: "<foo>"`,
 	},
 
 	// Base 60 floats are obsolete and unsupported.
 	{
 		"a: 1:1\n",
-		map[string]string{"a": "1:1"},
+		`a: "1:1"`,
 	},
 
 	// Binary data.
 	{
 		"a: !!binary gIGC\n",
-		map[string]string{"a": "\x80\x81\x82"},
+		`a: '\x80\x81\x82'`,
 	}, {
 		"a: !!binary |\n  " + strings.Repeat("kJCQ", 17) + "kJ\n  CQ\n",
-		map[string]string{"a": strings.Repeat("\x90", 54)},
+		"a: '" + strings.Repeat(`\x90`, 54) + "'",
 	}, {
 		"a: !!binary |\n  " + strings.Repeat("A", 70) + "\n  ==\n",
-		map[string]string{"a": strings.Repeat("\x00", 52)},
+		"a: '" + strings.Repeat(`\x00`, 52) + "'",
 	},
 
 	// Ordered maps.
 	{
 		"{b: 2, a: 1, d: 4, c: 3, sub: {e: 5}}",
-		&yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
+		`b: 2
+a: 1
+d: 4
+c: 3
+sub e: 5`,
 	},
 
 	// Issue #39.
 	{
 		"a:\n b:\n  c: d\n",
-		map[string]struct{ B interface{} }{"a": {map[interface{}]interface{}{"c": "d"}}},
-	},
-
-	// Custom map type.
-	{
-		"a: {b: c}",
-		M{"a": M{"b": "c"}},
-	},
-
-	// Support encoding.TextUnmarshaler.
-	{
-		"a: 1.2.3.4\n",
-		map[string]textUnmarshaler{"a": textUnmarshaler{S: "1.2.3.4"}},
-	},
-	{
-		"a: 2015-02-24T18:19:39Z\n",
-		map[string]textUnmarshaler{"a": textUnmarshaler{"2015-02-24T18:19:39Z"}},
+		`a b c: "d"`,
 	},
 
 	// Timestamps
 	{
 		// Date only.
 		"a: 2015-01-01\n",
-		map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
+		`a: "2015-01-01"`,
 	},
 	{
 		// RFC3339
 		"a: 2015-02-24T18:19:39.12Z\n",
-		map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, .12e9, time.UTC)},
+		`a: "2015-02-24T18:19:39.12Z"`,
 	},
 	{
 		// RFC3339 with short dates.
 		"a: 2015-2-3T3:4:5Z",
-		map[string]time.Time{"a": time.Date(2015, 2, 3, 3, 4, 5, 0, time.UTC)},
+		`a: "2015-2-3T3:4:5Z"`,
 	},
 	{
 		// ISO8601 lower case t
 		"a: 2015-02-24t18:19:39Z\n",
-		map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
+		`a: "2015-02-24t18:19:39Z"`,
 	},
 	{
 		// space separate, no time zone
 		"a: 2015-02-24 18:19:39\n",
-		map[string]time.Time{"a": time.Date(2015, 2, 24, 18, 19, 39, 0, time.UTC)},
+		`a: "2015-02-24 18:19:39"`,
 	},
 	// Some cases not currently handled. Uncomment these when
 	// the code is fixed.
@@ -635,84 +544,72 @@
 	{
 		// explicit string tag
 		"a: !!str 2015-01-01",
-		map[string]interface{}{"a": "2015-01-01"},
+		`a: "2015-01-01"`,
 	},
 	{
 		// explicit timestamp tag on quoted string
 		"a: !!timestamp \"2015-01-01\"",
-		map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
+		`a: "2015-01-01"`,
 	},
 	{
 		// explicit timestamp tag on unquoted string
 		"a: !!timestamp 2015-01-01",
-		map[string]time.Time{"a": time.Date(2015, 1, 1, 0, 0, 0, 0, time.UTC)},
+		`a: "2015-01-01"`,
 	},
 	{
 		// quoted string that's a valid timestamp
 		"a: \"2015-01-01\"",
-		map[string]interface{}{"a": "2015-01-01"},
-	},
-	{
-		// explicit timestamp tag into interface.
-		"a: !!timestamp \"2015-01-01\"",
-		map[string]interface{}{"a": "2015-01-01"},
-	},
-	{
-		// implicit timestamp tag into interface.
-		"a: 2015-01-01",
-		map[string]interface{}{"a": "2015-01-01"},
+		"a: \"2015-01-01\"",
 	},
 
-	// Encode empty lists as zero-length slices.
+	// Empty list
 	{
 		"a: []",
-		&struct{ A []int }{[]int{}},
+		"a: []",
 	},
 
 	// UTF-16-LE
 	{
 		"\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n\x00",
-		M{"ñoño": "very yes"},
+		`ñoño: "very yes"`,
 	},
 	// UTF-16-LE with surrogate.
 	{
 		"\xff\xfe\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \x00=\xd8\xd4\xdf\n\x00",
-		M{"ñoño": "very yes 🟔"},
+		`ñoño: "very yes 🟔"`,
 	},
 
 	// UTF-16-BE
 	{
 		"\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00\n",
-		M{"ñoño": "very yes"},
+		`ñoño: "very yes"`,
 	},
 	// UTF-16-BE with surrogate.
 	{
 		"\xfe\xff\x00\xf1\x00o\x00\xf1\x00o\x00:\x00 \x00v\x00e\x00r\x00y\x00 \x00y\x00e\x00s\x00 \xd8=\xdf\xd4\x00\n",
-		M{"ñoño": "very yes 🟔"},
+		`ñoño: "very yes 🟔"`,
 	},
 
 	// YAML Float regex shouldn't match this
 	{
 		"a: 123456e1\n",
-		M{"a": "123456e1"},
+		`a: "123456e1"`,
 	}, {
 		"a: 123456E1\n",
-		M{"a": "123456E1"},
+		`a: "123456E1"`,
 	},
 	// yaml-test-suite 3GZX: Spec Example 7.1. Alias Nodes
 	{
 		"First occurrence: &anchor Foo\nSecond occurrence: *anchor\nOverride anchor: &anchor Bar\nReuse anchor: *anchor\n",
-		map[interface{}]interface{}{
-			"Reuse anchor":      "Bar",
-			"First occurrence":  "Foo",
-			"Second occurrence": "Foo",
-			"Override anchor":   "Bar",
-		},
+		`"First occurrence":  "Foo"
+"Second occurrence": "Foo"
+"Override anchor":   "Bar"
+"Reuse anchor":      "Bar"`,
 	},
 	// Single document with garbage following it.
 	{
 		"---\nhello\n...\n}not yaml",
-		"hello",
+		`"hello"`,
 	},
 }
 
@@ -727,89 +624,114 @@
 	C int
 }
 
-func (s *S) TestUnmarshal(c *C) {
-	for i, item := range unmarshalTests {
-		c.Logf("test %d: %q", i, item.data)
-		t := reflect.ValueOf(item.value).Type()
-		value := reflect.New(t)
-		err := yaml.Unmarshal([]byte(item.data), value.Interface())
-		if _, ok := err.(*yaml.TypeError); !ok {
-			c.Assert(err, IsNil)
+var fset = token.NewFileSet()
+
+func cueStr(node ast.Node) string {
+	if s, ok := node.(*ast.StructLit); ok {
+		node = &ast.File{
+			Decls: s.Elts,
 		}
-		c.Assert(value.Elem().Interface(), DeepEquals, item.value, Commentf("error: %v", err))
+	}
+	buf := bytes.Buffer{}
+	format.Node(&buf, node)
+	return strings.TrimSpace(buf.String())
+}
+
+func newDecoder(t *testing.T, data string) *yaml.Decoder {
+	dec, err := yaml.NewDecoder(fset, "test.yaml", strings.NewReader(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return dec
+}
+
+func callUnmarshal(t *testing.T, data string) (ast.Expr, error) {
+	return yaml.Unmarshal(fset, "test.yaml", []byte(data))
+}
+
+func TestUnmarshal(t *testing.T) {
+	for i, item := range unmarshalTests {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			t.Logf("test %d: %q", i, item.data)
+			expr, err := callUnmarshal(t, item.data)
+			if _, ok := err.(*yaml.TypeError); !ok && err != nil {
+				t.Fatal("expected error to be nil")
+			}
+			if got := cueStr(expr); got != item.want {
+				t.Errorf("\n got: %v;\nwant: %v", got, item.want)
+			}
+		})
 	}
 }
 
-// TODO(v3): This test should also work when unmarshaling onto an interface{}.
-func (s *S) TestUnmarshalFullTimestamp(c *C) {
-	// Full timestamp in same format as encoded. This is confirmed to be
-	// properly decoded by Python as a timestamp as well.
-	var str = "2015-02-24T18:19:39.123456789-03:00"
-	var t time.Time
-	err := yaml.Unmarshal([]byte(str), &t)
-	c.Assert(err, IsNil)
-	c.Assert(t, Equals, time.Date(2015, 2, 24, 18, 19, 39, 123456789, t.Location()))
-	c.Assert(t.In(time.UTC), Equals, time.Date(2015, 2, 24, 21, 19, 39, 123456789, time.UTC))
-}
+// // TODO(v3): This test should also work when unmarshaling onto an interface{}.
+// func (s *S) TestUnmarshalFullTimestamp(c *C) {
+// 	// Full timestamp in same format as encoded. This is confirmed to be
+// 	// properly decoded by Python as a timestamp as well.
+// 	var str = "2015-02-24T18:19:39.123456789-03:00"
+// 	expr, err := yaml.Unmarshal([]byte(str))
+// 	c.Assert(err, IsNil)
+// 	c.Assert(t, Equals, time.Date(2015, 2, 24, 18, 19, 39, 123456789, t.Location()))
+// 	c.Assert(t.In(time.UTC), Equals, time.Date(2015, 2, 24, 21, 19, 39, 123456789, time.UTC))
+// }
 
-func (s *S) TestDecoderSingleDocument(c *C) {
+func TestDecoderSingleDocument(t *testing.T) {
 	// Test that Decoder.Decode works as expected on
 	// all the unmarshal tests.
 	for i, item := range unmarshalTests {
-		c.Logf("test %d: %q", i, item.data)
-		if item.data == "" {
-			// Behaviour differs when there's no YAML.
-			continue
-		}
-		t := reflect.ValueOf(item.value).Type()
-		value := reflect.New(t)
-		err := yaml.NewDecoder(strings.NewReader(item.data)).Decode(value.Interface())
-		if _, ok := err.(*yaml.TypeError); !ok {
-			c.Assert(err, IsNil)
-		}
-		c.Assert(value.Elem().Interface(), DeepEquals, item.value)
+		t.Run(fmt.Sprintf("test %d: %q", i, item.data), func(t *testing.T) {
+			if item.data == "" {
+				// Behaviour differs when there's no YAML.
+				return
+			}
+			expr, err := newDecoder(t, item.data).Decode()
+			if _, ok := err.(*yaml.TypeError); !ok && err != nil {
+				t.Errorf("err should be nil, was %v", err)
+			}
+			if got := cueStr(expr); got != item.want {
+				t.Errorf("\n got: %v;\nwant: %v", got, item.want)
+			}
+		})
 	}
 }
 
 var decoderTests = []struct {
-	data   string
-	values []interface{}
+	data string
+	want string
 }{{
 	"",
-	nil,
+	"",
 }, {
 	"a: b",
-	[]interface{}{
-		map[interface{}]interface{}{"a": "b"},
-	},
+	`a: "b"`,
 }, {
 	"---\na: b\n...\n",
-	[]interface{}{
-		map[interface{}]interface{}{"a": "b"},
-	},
+	`a: "b"`,
 }, {
 	"---\n'hello'\n...\n---\ngoodbye\n...\n",
-	[]interface{}{
-		"hello",
-		"goodbye",
-	},
+	`"hello"` + "\n" + `"goodbye"`,
 }}
 
-func (s *S) TestDecoder(c *C) {
+func TestDecoder(t *testing.T) {
 	for i, item := range decoderTests {
-		c.Logf("test %d: %q", i, item.data)
-		var values []interface{}
-		dec := yaml.NewDecoder(strings.NewReader(item.data))
-		for {
-			var value interface{}
-			err := dec.Decode(&value)
-			if err == io.EOF {
-				break
+		t.Run(fmt.Sprintf("test %d: %q", i, item.data), func(t *testing.T) {
+			var values []string
+			dec := newDecoder(t, item.data)
+			for {
+				expr, err := dec.Decode()
+				if err == io.EOF {
+					break
+				}
+				if err != nil {
+					t.Errorf("err should be nil, was %v", err)
+				}
+				values = append(values, cueStr(expr))
 			}
-			c.Assert(err, IsNil)
-			values = append(values, value)
-		}
-		c.Assert(values, DeepEquals, item.values)
+			got := strings.Join(values, "\n")
+			if got != item.want {
+				t.Errorf("\n got: %v;\nwant: %v", got, item.want)
+			}
+		})
 	}
 }
 
@@ -819,455 +741,92 @@
 	return 0, errors.New("some read error")
 }
 
-func (s *S) TestDecoderReadError(c *C) {
-	err := yaml.NewDecoder(errReader{}).Decode(&struct{}{})
-	c.Assert(err, ErrorMatches, `yaml: input error: some read error`)
-}
-
-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)
+func TestUnmarshalNaN(t *testing.T) {
+	expr, err := callUnmarshal(t, "notanum: .NaN")
+	if err != nil {
+		t.Fatal("unexpected error", err)
+	}
+	got := cueStr(expr)
+	want := "notanum: NaN"
+	if got != want {
+		t.Errorf("got %v; want %v", got, want)
+	}
 }
 
 var unmarshalErrorTests = []struct {
 	data, error string
 }{
-	{"v: !!float 'error'", "yaml: cannot decode !!str `error` as a !!float"},
-	{"v: [A,", "yaml: line 1: did not find expected node content"},
-	{"v:\n- [A,", "yaml: line 2: did not find expected node content"},
-	{"a:\n- b: *,", "yaml: line 2: did not find expected alphabetic or numeric character"},
-	{"a: *b\n", "yaml: unknown anchor 'b' referenced"},
-	{"a: &a\n  b: *a\n", "yaml: anchor 'a' value contains itself"},
-	{"value: -", "yaml: block sequence entries are not allowed in this context"},
-	{"a: !!binary ==", "yaml: !!binary value contains invalid base64 data"},
-	{"{[.]}", `yaml: invalid map key: \[\]interface \{\}\{"\."\}`},
-	{"{{.}}", `yaml: invalid map key: map\[interface\ \{\}\]interface \{\}\{".":interface \{\}\(nil\)\}`},
-	{"b: *a\na: &a {c: 1}", `yaml: unknown anchor 'a' referenced`},
-	{"%TAG !%79! tag:yaml.org,2002:\n---\nv: !%79!int '1'", "yaml: did not find expected whitespace"},
+	{"\nv: !!float 'error'", "test.yaml:2: cannot decode !!str `error` as a !!float"},
+	{"v: [A,", "test.yaml:1: did not find expected node content"},
+	{"v:\n- [A,", "test.yaml:2: did not find expected node content"},
+	{"a:\n- b: *,", "test.yaml:2: did not find expected alphabetic or numeric character"},
+	{"a: *b\n", "test.yaml:1: unknown anchor 'b' referenced"},
+	{"a: &a\n  b: *a\n", "test.yaml:2: anchor 'a' value contains itself"},
+	{"value: -", "test.yaml:1: block sequence entries are not allowed in this context"},
+	{"a: !!binary ==", "test.yaml:1: !!binary value contains invalid base64 data"},
+	{"{[.]}", `test.yaml:1: invalid map key: sequence`},
+	{"{{.}}", `test.yaml:1: invalid map key: map`},
+	{"b: *a\na: &a {c: 1}", `test.yaml:1: unknown anchor 'a' referenced`},
+	{"%TAG !%79! tag:yaml.org,2002:\n---\nv: !%79!int '1'", "test.yaml:1: did not find expected whitespace"},
 }
 
-func (s *S) TestUnmarshalErrors(c *C) {
+func TestUnmarshalErrors(t *testing.T) {
 	for i, item := range unmarshalErrorTests {
-		c.Logf("test %d: %q", i, item.data)
-		var value interface{}
-		err := yaml.Unmarshal([]byte(item.data), &value)
-		c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value))
+		t.Run(fmt.Sprintf("test %d: %q", i, item.data), func(t *testing.T) {
+			expr, err := callUnmarshal(t, item.data)
+			val := ""
+			if expr != nil {
+				val = cueStr(expr)
+			}
+			if err == nil || err.Error() != item.error {
+				t.Errorf("got %v; want %v; (value %v)", err, item.error, val)
+			}
+		})
 	}
 }
 
-func (s *S) TestDecoderErrors(c *C) {
-	for _, item := range unmarshalErrorTests {
-		var value interface{}
-		err := yaml.NewDecoder(strings.NewReader(item.data)).Decode(&value)
-		c.Assert(err, ErrorMatches, item.error, Commentf("Partial unmarshal: %#v", value))
+func TestDecoderErrors(t *testing.T) {
+	for i, item := range unmarshalErrorTests {
+		t.Run(fmt.Sprintf("test %d: %q", i, item.data), func(t *testing.T) {
+			_, err := newDecoder(t, item.data).Decode()
+			if err == nil || err.Error() != item.error {
+				t.Errorf("got %v; want %v", err, item.error)
+			}
+		})
 	}
 }
 
-var unmarshalerTests = []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!"},
-	{`_: ""`, "!!str", ""},
-}
-
-var unmarshalerResult = map[int]error{}
-
-type unmarshalerType struct {
-	value interface{}
-}
-
-func (o *unmarshalerType) UnmarshalYAML(unmarshal func(v interface{}) error) error {
-	if err := unmarshal(&o.value); err != nil {
-		return err
-	}
-	if i, ok := o.value.(int); ok {
-		if result, ok := unmarshalerResult[i]; ok {
-			return result
-		}
-	}
-	return nil
-}
-
-type unmarshalerPointer struct {
-	Field *unmarshalerType "_"
-}
-
-type unmarshalerValue struct {
-	Field unmarshalerType "_"
-}
-
-func (s *S) TestUnmarshalerPointerField(c *C) {
-	for _, item := range unmarshalerTests {
-		obj := &unmarshalerPointer{}
-		err := yaml.Unmarshal([]byte(item.data), obj)
-		c.Assert(err, IsNil)
-		if item.value == nil {
-			c.Assert(obj.Field, IsNil)
-		} else {
-			c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
-			c.Assert(obj.Field.value, DeepEquals, item.value)
-		}
+func TestFiles(t *testing.T) {
+	files := []string{"merge"}
+	for _, test := range files {
+		t.Run(test, func(t *testing.T) {
+			testname := fmt.Sprintf("testdata/%s.test", test)
+			filename := fmt.Sprintf("testdata/%s.out", test)
+			mergeTests, err := ioutil.ReadFile(testname)
+			if err != nil {
+				t.Fatal(err)
+			}
+			expr, err := yaml.Unmarshal(fset, "test.yaml", mergeTests)
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := cueStr(expr)
+			if *update {
+				ioutil.WriteFile(filename, []byte(got), 0644)
+				return
+			}
+			b, err := ioutil.ReadFile(filename)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want := string(b); got != want {
+				t.Errorf("\n got: %v;\nwant: %v", got, want)
+			}
+		})
 	}
 }
 
-func (s *S) TestUnmarshalerValueField(c *C) {
-	for _, item := range unmarshalerTests {
-		obj := &unmarshalerValue{}
-		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.value, DeepEquals, item.value)
-	}
-}
-
-func (s *S) TestUnmarshalerWholeDocument(c *C) {
-	obj := &unmarshalerType{}
-	err := yaml.Unmarshal([]byte(unmarshalerTests[0].data), obj)
-	c.Assert(err, IsNil)
-	value, ok := obj.value.(map[interface{}]interface{})
-	c.Assert(ok, Equals, true, Commentf("value: %#v", obj.value))
-	c.Assert(value["_"], DeepEquals, unmarshalerTests[0].value)
-}
-
-func (s *S) TestUnmarshalerTypeError(c *C) {
-	unmarshalerResult[2] = &yaml.TypeError{[]string{"foo"}}
-	unmarshalerResult[4] = &yaml.TypeError{[]string{"bar"}}
-	defer func() {
-		delete(unmarshalerResult, 2)
-		delete(unmarshalerResult, 4)
-	}()
-
-	type T struct {
-		Before int
-		After  int
-		M      map[string]*unmarshalerType
-	}
-	var v T
-	data := `{before: A, m: {abc: 1, def: 2, ghi: 3, jkl: 4}, after: B}`
-	err := yaml.Unmarshal([]byte(data), &v)
-	c.Assert(err, ErrorMatches, ""+
-		"yaml: unmarshal errors:\n"+
-		"  line 1: cannot unmarshal !!str `A` into int\n"+
-		"  foo\n"+
-		"  bar\n"+
-		"  line 1: cannot unmarshal !!str `B` into int")
-	c.Assert(v.M["abc"], NotNil)
-	c.Assert(v.M["def"], IsNil)
-	c.Assert(v.M["ghi"], NotNil)
-	c.Assert(v.M["jkl"], IsNil)
-
-	c.Assert(v.M["abc"].value, Equals, 1)
-	c.Assert(v.M["ghi"].value, Equals, 3)
-}
-
-type proxyTypeError struct{}
-
-func (v *proxyTypeError) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var s string
-	var a int32
-	var b int64
-	if err := unmarshal(&s); err != nil {
-		panic(err)
-	}
-	if s == "a" {
-		if err := unmarshal(&b); err == nil {
-			panic("should have failed")
-		}
-		return unmarshal(&a)
-	}
-	if err := unmarshal(&a); err == nil {
-		panic("should have failed")
-	}
-	return unmarshal(&b)
-}
-
-func (s *S) TestUnmarshalerTypeErrorProxying(c *C) {
-	type T struct {
-		Before int
-		After  int
-		M      map[string]*proxyTypeError
-	}
-	var v T
-	data := `{before: A, m: {abc: a, def: b}, after: B}`
-	err := yaml.Unmarshal([]byte(data), &v)
-	c.Assert(err, ErrorMatches, ""+
-		"yaml: unmarshal errors:\n"+
-		"  line 1: cannot unmarshal !!str `A` into int\n"+
-		"  line 1: cannot unmarshal !!str `a` into int32\n"+
-		"  line 1: cannot unmarshal !!str `b` into int64\n"+
-		"  line 1: cannot unmarshal !!str `B` into int")
-}
-
-type failingUnmarshaler struct{}
-
-var failingErr = errors.New("failingErr")
-
-func (ft *failingUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	return failingErr
-}
-
-func (s *S) TestUnmarshalerError(c *C) {
-	err := yaml.Unmarshal([]byte("a: b"), &failingUnmarshaler{})
-	c.Assert(err, Equals, failingErr)
-}
-
-type sliceUnmarshaler []int
-
-func (su *sliceUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var slice []int
-	err := unmarshal(&slice)
-	if err == nil {
-		*su = slice
-		return nil
-	}
-
-	var intVal int
-	err = unmarshal(&intVal)
-	if err == nil {
-		*su = []int{intVal}
-		return nil
-	}
-
-	return err
-}
-
-func (s *S) TestUnmarshalerRetry(c *C) {
-	var su sliceUnmarshaler
-	err := yaml.Unmarshal([]byte("[1, 2, 3]"), &su)
-	c.Assert(err, IsNil)
-	c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1, 2, 3}))
-
-	err = yaml.Unmarshal([]byte("1"), &su)
-	c.Assert(err, IsNil)
-	c.Assert(su, DeepEquals, sliceUnmarshaler([]int{1}))
-}
-
-// From http://yaml.org/type/merge.html
-var mergeTests = `
-anchors:
-  list:
-    - &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[interface{}]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)
-		}
-	}
-}
-
-func (s *S) TestUnmarshalSliceOnPreset(c *C) {
-	// Issue #48.
-	v := struct{ A []int }{[]int{1}}
-	yaml.Unmarshal([]byte("a: [2]"), &v)
-	c.Assert(v.A, DeepEquals, []int{2})
-}
-
-var unmarshalStrictTests = []struct {
-	data  string
-	value interface{}
-	error string
-}{{
-	data:  "a: 1\nc: 2\n",
-	value: struct{ A, B int }{A: 1},
-	error: `yaml: unmarshal errors:\n  line 2: field c not found in type struct { A int; B int }`,
-}, {
-	data:  "a: 1\nb: 2\na: 3\n",
-	value: struct{ A, B int }{A: 3, B: 2},
-	error: `yaml: unmarshal errors:\n  line 3: field a already set in type struct { A int; B int }`,
-}, {
-	data: "c: 3\na: 1\nb: 2\nc: 4\n",
-	value: struct {
-		A       int
-		inlineB `yaml:",inline"`
-	}{
-		A: 1,
-		inlineB: inlineB{
-			B: 2,
-			inlineC: inlineC{
-				C: 4,
-			},
-		},
-	},
-	error: `yaml: unmarshal errors:\n  line 4: field c already set in type struct { A int; yaml_test.inlineB "yaml:\\",inline\\"" }`,
-}, {
-	data: "c: 0\na: 1\nb: 2\nc: 1\n",
-	value: struct {
-		A       int
-		inlineB `yaml:",inline"`
-	}{
-		A: 1,
-		inlineB: inlineB{
-			B: 2,
-			inlineC: inlineC{
-				C: 1,
-			},
-		},
-	},
-	error: `yaml: unmarshal errors:\n  line 4: field c already set in type struct { A int; yaml_test.inlineB "yaml:\\",inline\\"" }`,
-}, {
-	data: "c: 1\na: 1\nb: 2\nc: 3\n",
-	value: struct {
-		A int
-		M map[string]interface{} `yaml:",inline"`
-	}{
-		A: 1,
-		M: map[string]interface{}{
-			"b": 2,
-			"c": 3,
-		},
-	},
-	error: `yaml: unmarshal errors:\n  line 4: key "c" already set in map`,
-}, {
-	data: "a: 1\n9: 2\nnull: 3\n9: 4",
-	value: map[interface{}]interface{}{
-		"a": 1,
-		nil: 3,
-		9:   4,
-	},
-	error: `yaml: unmarshal errors:\n  line 4: key 9 already set in map`,
-}}
-
-func (s *S) TestUnmarshalStrict(c *C) {
-	for i, item := range unmarshalStrictTests {
-		c.Logf("test %d: %q", i, item.data)
-		// First test that normal Unmarshal unmarshals to the expected value.
-		t := reflect.ValueOf(item.value).Type()
-		value := reflect.New(t)
-		err := yaml.Unmarshal([]byte(item.data), value.Interface())
-		c.Assert(err, Equals, nil)
-		c.Assert(value.Elem().Interface(), DeepEquals, item.value)
-
-		// Then test that UnmarshalStrict fails on the same thing.
-		t = reflect.ValueOf(item.value).Type()
-		value = reflect.New(t)
-		err = yaml.UnmarshalStrict([]byte(item.data), value.Interface())
-		c.Assert(err, ErrorMatches, item.error)
-	}
-}
-
-type textUnmarshaler struct {
-	S string
-}
-
-func (t *textUnmarshaler) UnmarshalText(s []byte) error {
-	t.S = string(s)
-	return nil
-}
-
-func (s *S) TestFuzzCrashers(c *C) {
+func TestFuzzCrashers(t *testing.T) {
 	cases := []string{
 		// runtime error: index out of range
 		"\"\\0\\\r\n",
@@ -1291,8 +850,7 @@
 		"? \ufeff: \ufeff\n",
 	}
 	for _, data := range cases {
-		var v interface{}
-		_ = yaml.Unmarshal([]byte(data), &v)
+		_, _ = callUnmarshal(t, data)
 	}
 }