diff --git a/cue/builtin_test.go b/cue/builtin_test.go
index 97a1dc8..c8698cd 100644
--- a/cue/builtin_test.go
+++ b/cue/builtin_test.go
@@ -16,9 +16,6 @@
 
 import (
 	"fmt"
-	"math/big"
-	"strconv"
-	"strings"
 	"testing"
 
 	"cuelang.org/go/cue"
@@ -39,11 +36,6 @@
 			[]string{fmt.Sprintf("(%s)", expr)},
 		}}
 	}
-	hexToDec := func(s string) string {
-		var x big.Int
-		x.SetString(s, 16)
-		return x.String()
-	}
 	testCases := []struct {
 		instances []*bimport
 		emit      string
@@ -69,57 +61,6 @@
 		test("crypto/md5", `len(md5.Sum("hash me"))`),
 		`16`,
 	}, {
-		test("crypto/sha1", `len(sha1.Sum("hash me"))`),
-		`20`,
-	}, {
-		test("crypto/sha256", `len(sha256.Sum256("hash me"))`),
-		`32`,
-	}, {
-		test("crypto/sha256", `len(sha256.Sum224("hash me"))`),
-		`28`,
-	}, {
-		test("crypto/sha512", `len(sha512.Sum512("hash me"))`),
-		`64`,
-	}, {
-		test("crypto/sha512", `len(sha512.Sum384("hash me"))`),
-		`48`,
-	}, {
-		test("crypto/sha512", `len(sha512.Sum512_224("hash me"))`),
-		`28`,
-	}, {
-		test("crypto/sha512", `len(sha512.Sum512_256("hash me"))`),
-		`32`,
-	}, {
-		test("encoding/base64", `base64.Encode(null, "foo")`),
-		`"Zm9v"`,
-	}, {
-		test("encoding/base64", `base64.Decode(null, base64.Encode(null, "foo"))`),
-		`'foo'`,
-	}, {
-		test("encoding/base64", `base64.Decode(null, "foo")`),
-		`_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0 (and 1 more errors))`,
-	}, {
-		test("encoding/base64", `base64.Decode({}, "foo")`),
-		`_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null (and 1 more errors))`,
-	}, {
-		test("encoding/hex", `hex.Encode("foo")`),
-		`"666f6f"`,
-	}, {
-		test("encoding/hex", `hex.Decode(hex.Encode("foo"))`),
-		`'foo'`,
-	}, {
-		test("encoding/hex", `hex.Decode("foo")`),
-		`_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o' (and 1 more errors))`,
-	}, {
-		test("encoding/hex", `hex.Dump('foo')`),
-		`"00000000  66 6f 6f                                          |foo|\n"`,
-	}, {
-		test("encoding/json", `json.Validate("{\"a\":10}", {b:string})`),
-		`true`,
-	}, {
-		test("encoding/json", `json.Validate("{\"a\":10}", {a:<3})`),
-		`_|_(error in call to encoding/json.Validate: a: invalid value 10 (out of bound <3) (and 1 more errors))`,
-	}, {
 		test("encoding/yaml", `yaml.Validate("a: 2\n---\na: 4", {a:<3})`),
 		`_|_(error in call to encoding/yaml.Validate: a: invalid value 4 (out of bound <3) (and 1 more errors))`,
 	}, {
@@ -129,336 +70,21 @@
 		test("encoding/yaml", `yaml.Validate("a: 2\n", {a:<5, b:int})`),
 		`_|_(error in call to encoding/yaml.Validate: b: incomplete value int (and 1 more errors))`,
 	}, {
-		test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<3})`),
-		`_|_(error in call to encoding/yaml.ValidatePartial: a: invalid value 4 (out of bound <3) (and 1 more errors))`,
-	}, {
-		test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<5})`),
-		`true`,
-	}, {
-		test("encoding/yaml", `yaml.ValidatePartial("a: 2\n", {a:<5, b:int})`),
-		`true`,
-	}, {
 		test("strconv", `strconv.FormatUint(64, 16)`),
 		`"40"`,
 	}, {
-		// Find a better alternative, as this call should go.
-		test("strconv", `strconv.FormatFloat(3.02, 300, 4, 64)`),
-		`_|_(int 300 overflows byte in argument 1 in call to strconv.FormatFloat (and 1 more errors))`,
-	}, {
-		// Find a better alternative, as this call should go.
-		test("strconv", `strconv.FormatFloat(3.02, -1, 4, 64)`),
-		`_|_(cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat (and 1 more errors))`,
-	}, {
-		// Find a better alternative, as this call should go.
-		test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
-		`_|_(cannot use 1.0 (type float) as int in argument 2 to strconv.FormatFloat)`,
-	}, {
-		test("list", `list.Avg([1, 2, 3, 4])`),
-		`2.5`,
-	}, {
-		test("list", `list.Avg([])`),
-		`_|_(error in call to list.Avg: empty list (and 1 more errors))`,
-	}, {
-		test("list", `list.Avg("foo")`),
-		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Avg)`,
-	}, {
-		test("list", `list.Drop([1, 2, 3, 4], 0)`),
-		`[1,2,3,4]`,
-	}, {
-		test("list", `list.Drop([1, 2, 3, 4], 2)`),
-		`[3,4]`,
-	}, {
-		test("list", `list.Drop([1, 2, 3, 4], 10)`),
-		`[]`,
-	}, {
-		test("list", `list.Drop([1, 2, 3, 4], -1)`),
-		`_|_(error in call to list.Drop: negative index (and 1 more errors))`,
-	}, {
-		test("list", `list.FlattenN([1, [[2, 3], []], [4]], -1)`),
-		`[1,2,3,4]`,
-	}, {
-		test("list", `list.FlattenN([1, [[2, 3], []], [4]], 0)`),
-		`[1,[[2,3],[]],[4]]`,
-	}, {
-		test("list", `list.FlattenN([1, [[2, 3], []], [4]], 1)`),
-		`[1,[2,3],[],4]`,
-	}, {
-		test("list", `list.FlattenN([1, [[2, 3], []], [4]], 2)`),
-		`[1,2,3,4]`,
-	}, {
-		test("list", `list.FlattenN([[1, 2] | *[]], -1)`),
-		`[]`,
-	}, {
-		test("list", `list.FlattenN("foo", 1)`),
-		`_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list (and 1 more errors))`,
-	}, {
-		test("list", `list.FlattenN([], "foo")`),
-		`_|_(cannot use "foo" (type string) as int in argument 2 to list.FlattenN)`,
-	}, {
-		test("list", `list.Max([1, 2, 3, 4])`),
-		`4`,
-	}, {
-		test("list", `list.Max([])`),
-		`_|_(error in call to list.Max: empty list (and 1 more errors))`,
-	}, {
-		test("list", `list.Max("foo")`),
-		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Max)`,
-	}, {
-		test("list", `list.Min([1, 2, 3, 4])`),
-		`1`,
-	}, {
-		test("list", `list.Min([])`),
-		`_|_(error in call to list.Min: empty list (and 1 more errors))`,
-	}, {
-		test("list", `list.Min("foo")`),
-		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Min)`,
-	}, {
-		test("list", `list.Product([1, 2, 3, 4])`),
-		`24`,
-	}, {
-		test("list", `list.Product([])`),
-		`1`,
-	}, {
-		test("list", `list.Product("foo")`),
-		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Product)`,
-	}, {
-		test("list", `list.Range(0, 5, 0)`),
-		`_|_(error in call to list.Range: step must be non zero (and 1 more errors))`,
-	}, {
-		test("list", `list.Range(5, 0, 1)`),
-		`_|_(error in call to list.Range: end must be greater than start when step is positive (and 1 more errors))`,
-	}, {
-		test("list", `list.Range(0, 5, -1)`),
-		`_|_(error in call to list.Range: end must be less than start when step is negative (and 1 more errors))`,
-	}, {
-		test("list", `list.Range(0, 5, 1)`),
-		`[0,1,2,3,4]`,
-	}, {
-		test("list", `list.Range(0, 1, 1)`),
-		`[0]`,
-	}, {
-		test("list", `list.Range(0, 5, 2)`),
-		`[0,2,4]`,
-	}, {
-		test("list", `list.Range(5, 0, -1)`),
-		`[5,4,3,2,1]`,
-	}, {
-		test("list", `list.Range(0, 5, 0.5)`),
-		`[0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5]`,
-	}, {
-		test("list", `list.Slice([1, 2, 3, 4], 1, 3)`),
-		`[2,3]`,
-	}, {
-		test("list", `list.Slice([1, 2, 3, 4], -1, 3)`),
-		`_|_(error in call to list.Slice: negative index (and 1 more errors))`,
-	}, {
-		test("list", `list.Slice([1, 2, 3, 4], 3, 1)`),
-		`_|_(error in call to list.Slice: invalid index: 3 > 1 (and 1 more errors))`,
-	}, {
-		test("list", `list.Slice([1, 2, 3, 4], 5, 5)`),
-		`_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
-	}, {
-		test("list", `list.Slice([1, 2, 3, 4], 1, 5)`),
-		`_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
-	}, {
-		test("list", `list.Sort([], list.Ascending)`),
-		`[]`,
-	}, {
-		test("list", `list.Sort([2, 3, 1, 4], {x:_, y:_, less: x<y})`),
-		`[1,2,3,4]`,
-	}, {
-		test("list", `list.SortStable([{a:2,v:1}, {a:1,v:2}, {a:1,v:3}], {
-			x:_,
-			y:_,
-			less: (x.a < y.a)
-		})`),
-		`[{a:1,v:2},{a:1,v:3},{a:2,v:1}]`,
-	}, {
-		test("list", `list.Sort([{a:1}, {b:2}], list.Ascending)`),
-		`_|_(error in call to list.Sort: x: conflicting values string and {b:2} (mismatched types string and struct) (and 1 more errors) (and 1 more errors))`,
-	}, {
-		test("list", `list.SortStrings(["b", "a"])`),
-		`["a","b"]`,
-	}, {
-		// TODO: path error. This should be done as part of builtin refactoring.
-		test("list", `list.SortStrings([1, 2])`),
-		`_|_(error in call to list.SortStrings: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
-	}, {
-		test("list", `list.Sum([1, 2, 3, 4])`),
-		`10`,
-	}, {
-		test("list", `list.Sum([])`),
-		`0`,
-	}, {
-		test("list", `list.Sum("foo")`),
-		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Sum)`,
-	}, {
-		test("list", `list.Take([1, 2, 3, 4], 0)`),
-		`[]`,
-	}, {
-		test("list", `list.Take([1, 2, 3, 4], 2)`),
-		`[1,2]`,
-	}, {
-		test("list", `list.Take([1, 2, 3, 4], 10)`),
-		`[1,2,3,4]`,
-	}, {
-		test("list", `list.Take([1, 2, 3, 4], -1)`),
-		`_|_(error in call to list.Take: negative index (and 1 more errors))`,
-	}, {
-		test("list", `list.MinItems([1, 2, 3, 4], 2)`),
-		`true`,
-	}, {
-		test("list", `list.MinItems([1, 2, 3, 4], 5)`),
-		`false`,
-	}, {
-		test("list", `list.MaxItems([1, 2, 3, 4], 5)`),
-		`true`,
-	}, {
-		test("list", `list.MaxItems([1, 2, 3, 4], 2)`),
-		`false`,
-	}, {
-		// Panics
-		test("math", `math.Jacobi(1000, 2000)`),
-		`_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000 (and 1 more errors))`,
-	}, {
-		test("math", `math.Jacobi(1000, 201)`),
-		`1`,
-	}, {
-		test("math", `math.Asin(2.0e400)`),
-		`_|_(cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up (and 1 more errors))`,
-	}, {
-		test("math", `math.MultipleOf(4, 2)`), `true`,
-	}, {
-		test("math", `math.MultipleOf(5, 2)`), `false`,
-	}, {
-		test("math", `math.MultipleOf(5, 0)`),
-		`_|_(error in call to math.MultipleOf: division by zero (and 1 more errors))`,
-	}, {
-		test("math", `math.MultipleOf(100, 1.00001)`), `false`,
-	}, {
-		test("math", `math.MultipleOf(1, 1)`), `true`,
-	}, {
-		test("math", `math.MultipleOf(5, 2.5)`), `true`,
-	}, {
-		test("math", `math.MultipleOf(100e100, 10)`), `true`,
-	}, {
-		test("encoding/csv", `csv.Decode("1,2,3\n4,5,6")`),
-		`[["1","2","3"],["4","5","6"]]`,
-	}, {
 		test("regexp", `regexp.Find(#"f\w\w"#, "afoot")`),
 		`"foo"`,
 	}, {
 		test("regexp", `regexp.Find(#"f\w\w"#, "bar")`),
 		`_|_(error in call to regexp.Find: no match (and 1 more errors))`,
 	}, {
-		test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
-		`["foo","flo"]`,
-	}, {
-		test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
-		`["foo","flo"]`,
-	}, {
-		test("regexp", `regexp.FindAll(#"f\w\w"#, "bla bla", -1)`),
-		`_|_(error in call to regexp.FindAll: no match (and 1 more errors))`,
-	}, {
-		test("regexp", `regexp.FindSubmatch(#"f(\w)(\w)"#, "afloat afoot from")`),
-		`["flo","l","o"]`,
-	}, {
-		test("regexp", `regexp.FindAllSubmatch(#"f(\w)(\w)"#, "afloat afoot from", -1)`),
-		`[["flo","l","o"],["foo","o","o"],["fro","r","o"]]`,
-	}, {
-		test("regexp", `regexp.FindAllSubmatch(#"f(\w)(\w)"#, "aglom", -1)`),
-		`_|_(error in call to regexp.FindAllSubmatch: no match (and 1 more errors))`,
-	}, {
-		test("regexp", `regexp.FindNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from")`),
-		`{A:"l",B:"o"}`,
-	}, {
-		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from", -1)`),
-		`[{A:"l",B:"o"},{A:"o",B:"o"},{A:"r",B:"o"}]`,
-	}, {
-		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>optional)?"#, "fbla", -1)`),
-		`[{A:""}]`,
-	}, {
-		test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "aglom", -1)`),
-		`_|_(error in call to regexp.FindAllNamedSubmatch: no match (and 1 more errors))`,
-	}, {
-		test("regexp", `regexp.Valid & "valid"`),
-		`"valid"`,
-	}, {
-		test("regexp", `regexp.Valid & "invalid)"`),
-		"_|_(error in call to regexp.Valid: error parsing regexp: unexpected ): `invalid)`)",
-	}, {
-		test("strconv", `strconv.FormatBool(true)`),
-		`"true"`,
-	}, {
-		test("strings", `strings.Join(["Hello", "World!"], " ")`),
-		`"Hello World!"`,
-	}, {
-		test("strings", `strings.Join([1, 2], " ")`),
-		`_|_(error in call to strings.Join: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
-	}, {
-		test("strings", `strings.ByteAt("a", 0)`),
-		strconv.Itoa('a'),
-	}, {
-		test("strings", `strings.ByteSlice("Hello", 2, 5)`),
-		`'llo'`,
-	}, {
-		test("strings", `strings.SliceRunes("✓ Hello", 0, 3)`),
-		`"✓ H"`,
-	}, {
-		test("strings", `strings.Runes("Café")`),
-		strings.Replace(fmt.Sprint([]rune{'C', 'a', 'f', 'é'}), " ", ",", -1),
-	}, {
-		test("math/bits", `bits.Or(0x8, 0x1)`),
-		`9`,
-	}, {
-		testExpr(`len({})`),
-		`0`,
-	}, {
-		testExpr(`len({a: 1, b: 2, {[foo=_]: int}, _c: 3})`),
-		`2`,
-	}, {
 		testExpr(`len([1, 2, 3])`),
 		`3`,
 	}, {
 		testExpr(`len("foo")`),
 		`3`,
 	}, {
-		testExpr(`len('f\x20\x20')`),
-		`3`,
-	}, {
-		testExpr(`and([string, "foo"])`),
-		`"foo"`,
-	}, {
-		testExpr(`and([string, =~"fo"]) & "foo"`),
-		`"foo"`,
-	}, {
-		testExpr(`and([])`),
-		`{}`, // _ & top scope
-	}, {
-		testExpr(`or([1, 2, 3]) & 2`),
-		`2`,
-	}, {
-		testExpr(`or([])`),
-		`_|_(empty list in call to or (and 1 more errors))`,
-	}, {
-		test("encoding/csv", `csv.Encode([[1,2,3],[4,5],[7,8,9]])`),
-		`"1,2,3\n4,5\n7,8,9\n"`,
-	}, {
-		test("encoding/csv", `csv.Encode([["a", "b"], ["c"]])`),
-		`"a,b\nc\n"`,
-	}, {
-		test("encoding/json", `json.Valid("1")`),
-		`true`,
-	}, {
-		test("encoding/json", `json.Compact("[1, 2]")`),
-		`"[1,2]"`,
-	}, {
-		test("encoding/json", `json.Indent(#"{"a": 1, "b": 2}"#, "", "  ")`),
-		`"{\n  \"a\": 1,\n  \"b\": 2\n}"`,
-	}, {
-		test("encoding/json", `json.Unmarshal("1")`),
-		`1`,
-	}, {
 		test("encoding/json", `json.MarshalStream([{a: 1}, {b: 2}])`),
 		`"{\"a\":1}\n{\"b\":2}\n"`,
 	}, {
@@ -471,91 +97,6 @@
 		test("encoding/yaml", `yaml.MarshalStream([{a: 1}, {b: 2}])`),
 		`"a: 1\n---\nb: 2\n"`,
 	}, {
-		test("net", `net.FQDN & "foo.bar."`),
-		`"foo.bar."`,
-	}, {
-		test("net", `net.FQDN("foo.bararararararararararararararararararararararararararararararararara")`),
-		`false`,
-	}, {
-		test("net", `net.SplitHostPort("[::%lo0]:80")`),
-		`["::%lo0","80"]`,
-	}, {
-		test("net", `net.JoinHostPort("example.com", "80")`),
-		`"example.com:80"`,
-	}, {
-		test("net", `net.JoinHostPort("2001:db8::1", 80)`),
-		`"[2001:db8::1]:80"`,
-	}, {
-		test("net", `net.JoinHostPort([192,30,4,2], 80)`),
-		`"192.30.4.2:80"`,
-	}, {
-		// TODO: why is this not printing compactly?
-		test("net", `net.JoinHostPort([192, 30, 4], 80)`),
-		`_|_(error in call to net.JoinHostPort: invalid host [192, 30, 4] (and 1 more errors))`,
-	}, {
-		test("net", `net.IP("23.23.23.23")`),
-		`true`,
-	}, {
-		test("net", `net.IPv4 & "23.23.23.2333"`),
-		`_|_(invalid value "23.23.23.2333" (does not satisfy net.IPv4))`,
-	}, {
-		test("net", `net.IP("23.23.23.23")`),
-		`true`,
-	}, {
-		test("net", `net.IP("2001:db8::1")`),
-		`true`,
-	}, {
-		test("net", `net.IPv4("2001:db8::1")`),
-		`false`,
-	}, {
-		test("net", `net.IPv4() & "ff02::1:3"`),
-		`_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4))`,
-	}, {
-		test("net", `net.LoopbackIP([127, 0, 0, 1])`),
-		`true`,
-	}, {
-		test("net", `net.LoopbackIP("127.0.0.1")`),
-		`true`,
-	}, {
-		test("net", `net.ToIP4("127.0.0.1")`),
-		`[127,0,0,1]`,
-	}, {
-		test("net", `net.ToIP16("127.0.0.1")`),
-		`[0,0,0,0,0,0,0,0,0,0,255,255,127,0,0,1]`,
-	}, {
-		test("strings", `strings.ToCamel("AlphaBeta")`),
-		`"alphaBeta"`,
-	}, {
-		test("strings", `strings.ToTitle("alpha")`),
-		`"Alpha"`,
-	}, {
-		test("strings", `strings.MaxRunes(3) & "foo"`),
-		`"foo"`,
-	}, {
-		test("strings", `strings.MaxRunes(3) & "quux"`),
-		`_|_(invalid value "quux" (does not satisfy strings.MaxRunes(3)))`,
-	}, {
-		test("strings", `strings.MinRunes(1) & "e"`),
-		`"e"`,
-	}, {
-		test("strings", `strings.MaxRunes(0) & "e"`),
-		`_|_(invalid value "e" (does not satisfy strings.MaxRunes(0)))`,
-	}, {
-		test("strings", `strings.MaxRunes(0) & ""`),
-		`""`,
-	}, {
-		test("strings", `strings.MinRunes(3) & "hello"`),
-		`"hello"`,
-	}, {
-		test("strings", `strings.MaxRunes(10) & "hello"`),
-		`"hello"`,
-	}, {
-		test("strings", `strings.MaxRunes(3) & "hello"`),
-		`_|_(invalid value "hello" (does not satisfy strings.MaxRunes(3)))`,
-	}, {
-		test("strings", `strings.MinRunes(10) & "hello"`),
-		`_|_(invalid value "hello" (does not satisfy strings.MinRunes(10)))`,
-	}, {
 		test("struct", `struct.MinFields(0) & ""`),
 		`_|_(conflicting values struct.MinFields(0) and "" (mismatched types struct and string))`,
 	}, {
@@ -565,103 +106,6 @@
 		test("struct", `struct.MinFields(2) & {a: 1}`),
 		`_|_(invalid value {a:1} (does not satisfy struct.MinFields(2)))`,
 	}, {
-		test("struct", `struct.MaxFields(0) & {a: 1}`),
-		`_|_(invalid value {a:1} (does not satisfy struct.MaxFields(0)))`,
-	}, {
-		test("struct", `struct.MaxFields(2) & {a: 1}`),
-		`{a:1}`,
-	}, {
-		test("math", `math.Pow(8, 4)`), `4096`,
-	}, {
-		test("math", `math.Pow10(4)`), `1E+4`,
-	}, {
-		test("math", `math.Signbit(-4)`), `true`,
-	}, {
-		test("math", `math.Round(2.5)`), `3`,
-	}, {
-		test("math", `math.Round(-2.5)`), `-3`,
-	}, {
-		test("math", `math.RoundToEven(2.5)`), `2`,
-	}, {
-		test("math", `math.RoundToEven(-2.5)`), `-2`,
-	}, {
-		test("math", `math.Abs(2.5)`), `2.5`,
-	}, {
-		test("math", `math.Abs(-2.2)`), `2.2`,
-	}, {
-		test("math", `math.Cbrt(2)`), `1.25992104989487316476721`,
-	}, {
-		test("math", `math.Copysign(5, -2.2)`), `-5`,
-	}, {
-		test("math", `math.Exp(3)`), `20.0855369231876677409285`,
-	}, {
-		test("math", `math.Exp2(3.5)`), `11.3137084989847603904135`,
-	}, {
-		test("math", `math.Log(4)`), `1.38629436111989061883446`,
-	}, {
-		test("math", `math.Log10(4)`), `0.602059991327962390427478`,
-	}, {
-		test("math", `math.Log2(5)`),
-		`2.32192809488736234787032`,
-	}, {
-		test("math", `math.Dim(3, 2.5)`), `0.5`,
-	}, {
-		test("math", `math.Dim(5, 7.2)`), `0`,
-	}, {
-		test("math", `math.Ceil(2.5)`), `3`,
-	}, {
-		test("math", `math.Ceil(-2.2)`), `-2`,
-	}, {
-		test("math", `math.Floor(2.9)`), `2`,
-	}, {
-		test("math", `math.Floor(-2.2)`), `-3`,
-	}, {
-		test("math", `math.Trunc(2.5)`), `2`,
-	}, {
-		test("math", `math.Trunc(-2.9)`), `-2`,
-	}, {
-		test("math/bits", `bits.Lsh(0x8, 4)`), `128`,
-	}, {
-		test("math/bits", `bits.Rsh(0x100, 4)`), `16`,
-	}, {
-		test("math/bits", `bits.At(0x100, 8)`), `1`,
-	}, {
-		test("math/bits", `bits.At(0x100, 9)`), `0`,
-	}, {
-		test("math/bits", `bits.Set(0x100, 7, 1)`), `384`,
-	}, {
-		test("math/bits", `bits.Set(0x100, 8, 0)`), `0`,
-	}, {
-		test("math/bits", `bits.And(0x10000000000000F0E, 0xF0F7)`), `6`,
-	}, {
-		test("math/bits", `bits.Or(0x100000000000000F0, 0x0F)`),
-		hexToDec("100000000000000FF"),
-	}, {
-		test("math/bits", `bits.Xor(0x10000000000000F0F, 0xFF0)`),
-		hexToDec("100000000000000FF"),
-	}, {
-		test("math/bits", `bits.Xor(0xFF0, 0x10000000000000F0F)`),
-		hexToDec("100000000000000FF"),
-	}, {
-		test("math/bits", `bits.Clear(0xF, 0x100000000000008)`), `7`,
-	}, {
-		test("math/bits", `bits.Clear(0x1000000000000000008, 0xF)`),
-		hexToDec("1000000000000000000"),
-	}, {
-		test("text/tabwriter", `tabwriter.Write("""
-			a\tb\tc
-			aaa\tbb\tvv
-			""")`),
-		`"a   b  c\naaa bb vv"`,
-	}, {
-		test("text/tabwriter", `tabwriter.Write([
-				"a\tb\tc",
-				"aaa\tbb\tvv"])`),
-		`"a   b  c\naaa bb vv\n"`,
-	}, {
-		test("text/template", `template.Execute("{{.}}-{{.}}", "foo")`),
-		`"foo-foo"`,
-	}, {
 		test("time", `time.Time & "1937-01-01T12:00:27.87+00:20"`),
 		`"1937-01-01T12:00:27.87+00:20"`,
 	}, {
diff --git a/genpkgtests.go b/genpkgtests.go
new file mode 100644
index 0000000..676bc32
--- /dev/null
+++ b/genpkgtests.go
@@ -0,0 +1,82 @@
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io/ioutil"
+	"os"
+
+	"strconv"
+
+	"github.com/rogpeppe/go-internal/txtar"
+)
+
+func main() {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "./cue/builtin_test.go", nil, 0)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	m := map[string]*txtar.Archive{}
+	count := map[string]int{}
+
+	ast.Inspect(f, func(n ast.Node) bool {
+		call, ok := n.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		ident, ok := call.Fun.(*ast.Ident)
+		if !ok || ident.Name != "test" {
+			return true
+		}
+
+		str := call.Args[0].(*ast.BasicLit)
+		pkg, _ := strconv.Unquote(str.Value)
+		a := &txtar.Archive{
+			Comment: []byte(
+				"# generated from the original tests.\n# Henceforth it may be nicer to group tests into separate files."),
+			Files: []txtar.File{{Name: "in.cue"}},
+		}
+		m[pkg] = a
+		return false
+	})
+
+	ast.Inspect(f, func(n ast.Node) bool {
+		call, ok := n.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		ident, ok := call.Fun.(*ast.Ident)
+		if !ok || ident.Name != "test" {
+			return true
+		}
+
+		str := call.Args[0].(*ast.BasicLit)
+		pkg, _ := strconv.Unquote(str.Value)
+		str = call.Args[1].(*ast.BasicLit)
+		expr, err := strconv.Unquote(str.Value)
+		if err != nil {
+			panic(err)
+		}
+
+		a := m[pkg]
+		count[pkg]++
+
+		a.Files[0].Data = append(a.Files[0].Data,
+			fmt.Sprintf("t%d: %s\n", count[pkg], expr)...)
+
+		return false
+	})
+
+	for key, a := range m {
+		os.Mkdir(fmt.Sprintf("pkg/%s/testdata", key), 0755)
+		p := fmt.Sprintf("pkg/%s/testdata/gen.txtar", key)
+		ioutil.WriteFile(p, txtar.Format(a), 0644)
+	}
+}
diff --git a/pkg/crypto/md5/md5_test.go b/pkg/crypto/md5/md5_test.go
new file mode 100644
index 0000000..bba9bf7
--- /dev/null
+++ b/pkg/crypto/md5/md5_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package md5_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("md5", t)
+}
diff --git a/pkg/crypto/md5/testdata/gen.txtar b/pkg/crypto/md5/testdata/gen.txtar
new file mode 100644
index 0000000..b3879f7
--- /dev/null
+++ b/pkg/crypto/md5/testdata/gen.txtar
@@ -0,0 +1,10 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "crypto/md5"
+
+t1: len(md5.Sum("hash me"))
+-- out/md5 --
+(struct){
+  t1: (int){ 16 }
+}
diff --git a/pkg/crypto/sha1/sha1_test.go b/pkg/crypto/sha1/sha1_test.go
new file mode 100644
index 0000000..b923c13
--- /dev/null
+++ b/pkg/crypto/sha1/sha1_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sha1_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("sha1", t)
+}
diff --git a/pkg/crypto/sha1/testdata/gen.txtar b/pkg/crypto/sha1/testdata/gen.txtar
new file mode 100644
index 0000000..2eedefa
--- /dev/null
+++ b/pkg/crypto/sha1/testdata/gen.txtar
@@ -0,0 +1,10 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "crypto/sha1"
+
+t1: len(sha1.Sum("hash me"))
+-- out/sha1 --
+(struct){
+  t1: (int){ 20 }
+}
diff --git a/pkg/crypto/sha256/sha256_test.go b/pkg/crypto/sha256/sha256_test.go
new file mode 100644
index 0000000..ac0599a
--- /dev/null
+++ b/pkg/crypto/sha256/sha256_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sha256_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("sha256", t)
+}
diff --git a/pkg/crypto/sha256/testdata/gen.txtar b/pkg/crypto/sha256/testdata/gen.txtar
new file mode 100644
index 0000000..e615110
--- /dev/null
+++ b/pkg/crypto/sha256/testdata/gen.txtar
@@ -0,0 +1,14 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "crypto/sha256"
+
+t1: sha256.Sum256("hash me")
+t2: len(sha256.Sum256("hash me"))
+t3: len(sha256.Sum224("hash me"))
+-- out/sha256 --
+(struct){
+  t1: (bytes){ '\xeb \x1a\xf5\xaa\xf0\xd6\x06)\xd3Ҧ\x1eFl\xfc\x0f\xed\xb5\x17\xad\xd81\xec\xacR5\xe1کc\xd6' }
+  t2: (int){ 32 }
+  t3: (int){ 28 }
+}
diff --git a/pkg/crypto/sha512/sha512_test.go b/pkg/crypto/sha512/sha512_test.go
new file mode 100644
index 0000000..31839ad
--- /dev/null
+++ b/pkg/crypto/sha512/sha512_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sha512_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("sha512", t)
+}
diff --git a/pkg/crypto/sha512/testdata/gen.txtar b/pkg/crypto/sha512/testdata/gen.txtar
new file mode 100644
index 0000000..a97e3da
--- /dev/null
+++ b/pkg/crypto/sha512/testdata/gen.txtar
@@ -0,0 +1,16 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "crypto/sha512"
+
+t1: len(sha512.Sum512("hash me"))
+t2: len(sha512.Sum384("hash me"))
+t3: len(sha512.Sum512_224("hash me"))
+t4: len(sha512.Sum512_256("hash me"))
+-- out/sha512 --
+(struct){
+  t1: (int){ 64 }
+  t2: (int){ 48 }
+  t3: (int){ 28 }
+  t4: (int){ 32 }
+}
diff --git a/pkg/encoding/base64/base64_test.go b/pkg/encoding/base64/base64_test.go
new file mode 100644
index 0000000..53e356f
--- /dev/null
+++ b/pkg/encoding/base64/base64_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package base64_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("base64", t)
+}
diff --git a/pkg/encoding/base64/testdata/gen.txtar b/pkg/encoding/base64/testdata/gen.txtar
new file mode 100644
index 0000000..f3fca2e
--- /dev/null
+++ b/pkg/encoding/base64/testdata/gen.txtar
@@ -0,0 +1,26 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "encoding/base64"
+
+t1: base64.Encode(null, "foo")
+t2: base64.Decode(null, base64.Encode(null, "foo"))
+t3: base64.Decode(null, "foo")
+t4: base64.Decode({}, "foo")
+-- out/base64 --
+Errors:
+error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null
+error in call to encoding/base64.Decode: illegal base64 data at input byte 0
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "Zm9v" }
+  t2: (bytes){ 'foo' }
+  t3: (_|_){
+    // [eval] error in call to encoding/base64.Decode: illegal base64 data at input byte 0
+  }
+  t4: (_|_){
+    // [eval] error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null
+  }
+}
diff --git a/pkg/encoding/csv/csv_test.go b/pkg/encoding/csv/csv_test.go
new file mode 100644
index 0000000..f85b736
--- /dev/null
+++ b/pkg/encoding/csv/csv_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package csv_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("csv", t)
+}
diff --git a/pkg/encoding/csv/testdata/gen.txtar b/pkg/encoding/csv/testdata/gen.txtar
new file mode 100644
index 0000000..99b1fee
--- /dev/null
+++ b/pkg/encoding/csv/testdata/gen.txtar
@@ -0,0 +1,25 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "encoding/csv"
+
+t1: csv.Decode("1,2,3\n4,5,6")
+t2: csv.Encode([[1,2,3],[4,5],[7,8,9]])
+t3: csv.Encode([["a", "b"], ["c"]])
+-- out/csv --
+(struct){
+  t1: (#list){
+    0: (#list){
+      0: (string){ "1" }
+      1: (string){ "2" }
+      2: (string){ "3" }
+    }
+    1: (#list){
+      0: (string){ "4" }
+      1: (string){ "5" }
+      2: (string){ "6" }
+    }
+  }
+  t2: (string){ "1,2,3\n4,5\n7,8,9\n" }
+  t3: (string){ "a,b\nc\n" }
+}
diff --git a/pkg/encoding/hex/hex_test.go b/pkg/encoding/hex/hex_test.go
new file mode 100644
index 0000000..4127126
--- /dev/null
+++ b/pkg/encoding/hex/hex_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hex_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("hex", t)
+}
diff --git a/pkg/encoding/hex/testdata/gen.txtar b/pkg/encoding/hex/testdata/gen.txtar
new file mode 100644
index 0000000..9dfba7a
--- /dev/null
+++ b/pkg/encoding/hex/testdata/gen.txtar
@@ -0,0 +1,23 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "encoding/hex"
+
+t1: hex.Encode("foo")
+t2: hex.Decode(hex.Encode("foo"))
+t3: hex.Decode("foo")
+t4: hex.Dump('foo')
+-- out/hex --
+Errors:
+error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o'
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "666f6f" }
+  t2: (bytes){ 'foo' }
+  t3: (_|_){
+    // [eval] error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o'
+  }
+  t4: (string){ "00000000  66 6f 6f                                          |foo|\n" }
+}
diff --git a/pkg/encoding/json/json_test.go b/pkg/encoding/json/json_test.go
new file mode 100644
index 0000000..9ab3f41
--- /dev/null
+++ b/pkg/encoding/json/json_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package json_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("json", t)
+}
diff --git a/pkg/encoding/json/testdata/gen.txtar b/pkg/encoding/json/testdata/gen.txtar
new file mode 100644
index 0000000..f07dbf7
--- /dev/null
+++ b/pkg/encoding/json/testdata/gen.txtar
@@ -0,0 +1,39 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "encoding/json"
+
+t1: json.Validate("{\"a\":10}", {b:string})
+t2: json.Validate("{\"a\":10}", {a:<3})
+t3: json.Valid("1")
+t4: json.Compact("[1, 2]")
+t5: json.Indent(#"{"a": 1, "b": 2}"#, "", "  ")
+t6: json.Unmarshal("1")
+t7: json.MarshalStream([{a: 1}, {b: 2}])
+t8: {
+	x: int
+	y: json.Marshal({a: x})
+}
+-- out/json --
+Errors:
+a: error in call to encoding/json.Validate: invalid value 10 (out of bound <3)
+
+Result:
+(_|_){
+  // [eval]
+  t1: (bool){ true }
+  t2: (_|_){
+    // [eval] a: error in call to encoding/json.Validate: invalid value 10 (out of bound <3)
+  }
+  t3: (bool){ true }
+  t4: (string){ "[1,2]" }
+  t5: (string){ "{\n  \"a\": 1,\n  \"b\": 2\n}" }
+  t6: (int){ 1 }
+  t7: (string){ "{\"a\":1}\n{\"b\":2}\n" }
+  t8: (struct){
+    x: (int){ int }
+    y: (_|_){
+      // [incomplete] cannot convert incomplete value "int" to JSON
+    }
+  }
+}
diff --git a/pkg/encoding/yaml/testdata/gen.txtar b/pkg/encoding/yaml/testdata/gen.txtar
new file mode 100644
index 0000000..269680b
--- /dev/null
+++ b/pkg/encoding/yaml/testdata/gen.txtar
@@ -0,0 +1,35 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "encoding/yaml"
+
+t1: yaml.Validate("a: 2\n---\na: 4", {a:<3})
+t2: yaml.Validate("a: 2\n---\na: 4", {a:<5})
+t3: yaml.Validate("a: 2\n", {a:<5, b:int})
+t4: yaml.ValidatePartial("a: 2\n---\na: 4", {a:<3})
+t5: yaml.ValidatePartial("a: 2\n---\na: 4", {a:<5})
+t6: yaml.ValidatePartial("a: 2\n", {a:<5, b:int})
+t7: yaml.MarshalStream([{a: 1}, {b: 2}])
+-- out/yaml --
+Errors:
+a: error in call to encoding/yaml.Validate: invalid value 4 (out of bound <3)
+a: error in call to encoding/yaml.ValidatePartial: invalid value 4 (out of bound <3)
+b: error in call to encoding/yaml.Validate: incomplete value int
+
+Result:
+(_|_){
+  // [eval]
+  t1: (_|_){
+    // [eval] a: error in call to encoding/yaml.Validate: invalid value 4 (out of bound <3)
+  }
+  t2: (bool){ true }
+  t3: (_|_){
+    // [eval] b: error in call to encoding/yaml.Validate: incomplete value int
+  }
+  t4: (_|_){
+    // [eval] a: error in call to encoding/yaml.ValidatePartial: invalid value 4 (out of bound <3)
+  }
+  t5: (bool){ true }
+  t6: (bool){ true }
+  t7: (string){ "a: 1\n---\nb: 2\n" }
+}
diff --git a/pkg/encoding/yaml/yaml_test.go b/pkg/encoding/yaml/yaml_test.go
new file mode 100644
index 0000000..1121a53
--- /dev/null
+++ b/pkg/encoding/yaml/yaml_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package yaml_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("yaml", t)
+}
diff --git a/pkg/internal/builtintest/testing.go b/pkg/internal/builtintest/testing.go
new file mode 100644
index 0000000..d61494e
--- /dev/null
+++ b/pkg/internal/builtintest/testing.go
@@ -0,0 +1,60 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package builtintest
+
+import (
+	"fmt"
+	"testing"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/internal/core/debug"
+	"cuelang.org/go/internal/core/eval"
+	"cuelang.org/go/internal/core/validate"
+	"cuelang.org/go/internal/cuetxtar"
+)
+
+func Run(name string, t *testing.T) {
+	test := cuetxtar.TxTarTest{
+		Root: "./testdata",
+		Name: name,
+	}
+
+	r := cue.NewRuntime()
+
+	test.Run(t, func(t *cuetxtar.Test) {
+		a := t.ValidInstances()
+
+		v, err := r.Build(a[0])
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		e := eval.New(r)
+		ctx := e.NewContext(v)
+		v.Finalize(ctx)
+
+		if b := validate.Validate(ctx, v, &validate.Config{
+			AllErrors: true,
+		}); b != nil {
+			fmt.Fprintln(t, "Errors:")
+			t.WriteErrors(b.Err)
+			fmt.Fprintln(t, "")
+			fmt.Fprintln(t, "Result:")
+		}
+
+		debug.WriteNode(t, r, v, &debug.Config{Cwd: t.Dir})
+		fmt.Fprintln(t)
+	})
+}
diff --git a/pkg/list/list_test.go b/pkg/list/list_test.go
new file mode 100644
index 0000000..ba7f4d4
--- /dev/null
+++ b/pkg/list/list_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package list_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("list", t)
+}
diff --git a/pkg/list/testdata/gen.txtar b/pkg/list/testdata/gen.txtar
new file mode 100644
index 0000000..2061db7
--- /dev/null
+++ b/pkg/list/testdata/gen.txtar
@@ -0,0 +1,305 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "list"
+
+t1: list.Avg([1, 2, 3, 4])
+t2: list.Avg([])
+t3: list.Avg("foo")
+t4: list.Drop([1, 2, 3, 4], 0)
+t5: list.Drop([1, 2, 3, 4], 2)
+t6: list.Drop([1, 2, 3, 4], 10)
+t7: list.Drop([1, 2, 3, 4], -1)
+t8: list.FlattenN([1, [[2, 3], []], [4]], -1)
+t9: list.FlattenN([1, [[2, 3], []], [4]], 0)
+t10: list.FlattenN([1, [[2, 3], []], [4]], 1)
+t11: list.FlattenN([1, [[2, 3], []], [4]], 2)
+t12: list.FlattenN([[1, 2] | *[]], -1)
+t13: list.FlattenN("foo", 1)
+t14: list.FlattenN([], "foo")
+t15: list.Max([1, 2, 3, 4])
+t16: list.Max([])
+t17: list.Max("foo")
+t18: list.Min([1, 2, 3, 4])
+t19: list.Min([])
+t20: list.Min("foo")
+t21: list.Product([1, 2, 3, 4])
+t22: list.Product([])
+t23: list.Product("foo")
+t24: list.Range(0, 5, 0)
+t25: list.Range(5, 0, 1)
+t26: list.Range(0, 5, -1)
+t27: list.Range(0, 5, 1)
+t28: list.Range(0, 1, 1)
+t29: list.Range(0, 5, 2)
+t30: list.Range(5, 0, -1)
+t31: list.Range(0, 5, 0.5)
+t32: list.Slice([1, 2, 3, 4], 1, 3)
+t33: list.Slice([1, 2, 3, 4], -1, 3)
+t34: list.Slice([1, 2, 3, 4], 3, 1)
+t35: list.Slice([1, 2, 3, 4], 5, 5)
+t36: list.Slice([1, 2, 3, 4], 1, 5)
+t37: list.Sort([], list.Ascending)
+t38: list.Sort([2, 3, 1, 4], {x:_, y:_, less: x<y})
+t39: list.SortStable([{a:2,v:1}, {a:1,v:2}, {a:1,v:3}], {
+			x:_,
+			y:_,
+			less: (x.a < y.a)
+		})
+t40: list.Sort([{a:1}, {b:2}], list.Ascending)
+t41: list.SortStrings(["b", "a"])
+t42: list.SortStrings([1, 2])
+t43: list.Sum([1, 2, 3, 4])
+t44: list.Sum([])
+t45: list.Sum("foo")
+t46: list.Take([1, 2, 3, 4], 0)
+t47: list.Take([1, 2, 3, 4], 2)
+t48: list.Take([1, 2, 3, 4], 10)
+t49: list.Take([1, 2, 3, 4], -1)
+t50: list.MinItems([1, 2, 3, 4], 2)
+t51: list.MinItems([1, 2, 3, 4], 5)
+t52: list.MaxItems([1, 2, 3, 4], 5)
+t53: list.MaxItems([1, 2, 3, 4], 2)
+t54: list.Sort([{a:1}, {b:2}], list.Ascending)
+-- out/list --
+Errors:
+error in call to list.Avg: empty list
+error in call to list.Drop: negative index
+error in call to list.FlattenN: cannot use value "foo" (type string) as list
+error in call to list.Max: empty list
+error in call to list.Min: empty list
+error in call to list.Range: end must be greater than start when step is positive
+error in call to list.Range: end must be less than start when step is negative
+error in call to list.Range: step must be non zero
+error in call to list.Slice: invalid index: 3 > 1
+error in call to list.Slice: negative index
+error in call to list.Slice: slice bounds out of range
+error in call to list.Take: negative index
+0: error in call to list.SortStrings: element 0 of list argument 0: cannot use value 1 (type int) as string
+x: error in call to list.Sort: x: conflicting values string and {b:2} (mismatched types string and struct) (and 1 more errors)
+t3: cannot use "foo" (type string) as list in argument 1 to list.Avg:
+    ./in.cue:5:14
+t14: cannot use "foo" (type string) as int in argument 2 to list.FlattenN:
+    ./in.cue:16:24
+t17: cannot use "foo" (type string) as list in argument 1 to list.Max:
+    ./in.cue:19:15
+t20: cannot use "foo" (type string) as list in argument 1 to list.Min:
+    ./in.cue:22:15
+t23: cannot use "foo" (type string) as list in argument 1 to list.Product:
+    ./in.cue:25:19
+t45: cannot use "foo" (type string) as list in argument 1 to list.Sum:
+    ./in.cue:51:15
+
+Result:
+(_|_){
+  // [eval]
+  t1: (number){ 2.5 }
+  t2: (_|_){
+    // [eval] error in call to list.Avg: empty list
+  }
+  t3: (_|_){
+    // [eval] t3: cannot use "foo" (type string) as list in argument 1 to list.Avg:
+    //     ./in.cue:5:14
+  }
+  t4: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 3 }
+    3: (int){ 4 }
+  }
+  t5: (#list){
+    0: (int){ 3 }
+    1: (int){ 4 }
+  }
+  t6: (#list){
+  }
+  t7: (_|_){
+    // [eval] error in call to list.Drop: negative index
+  }
+  t8: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 3 }
+    3: (int){ 4 }
+  }
+  t9: (#list){
+    0: (int){ 1 }
+    1: (#list){
+      0: (#list){
+        0: (int){ 2 }
+        1: (int){ 3 }
+      }
+      1: (#list){
+      }
+    }
+    2: (#list){
+      0: (int){ 4 }
+    }
+  }
+  t10: (#list){
+    0: (int){ 1 }
+    1: (#list){
+      0: (int){ 2 }
+      1: (int){ 3 }
+    }
+    2: (#list){
+    }
+    3: (int){ 4 }
+  }
+  t11: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 3 }
+    3: (int){ 4 }
+  }
+  t12: (#list){
+  }
+  t13: (_|_){
+    // [eval] error in call to list.FlattenN: cannot use value "foo" (type string) as list
+  }
+  t14: (_|_){
+    // [eval] t14: cannot use "foo" (type string) as int in argument 2 to list.FlattenN:
+    //     ./in.cue:16:24
+  }
+  t15: (number){ 4 }
+  t16: (_|_){
+    // [eval] error in call to list.Max: empty list
+  }
+  t17: (_|_){
+    // [eval] t17: cannot use "foo" (type string) as list in argument 1 to list.Max:
+    //     ./in.cue:19:15
+  }
+  t18: (number){ 1 }
+  t19: (_|_){
+    // [eval] error in call to list.Min: empty list
+  }
+  t20: (_|_){
+    // [eval] t20: cannot use "foo" (type string) as list in argument 1 to list.Min:
+    //     ./in.cue:22:15
+  }
+  t21: (number){ 24 }
+  t22: (number){ 1 }
+  t23: (_|_){
+    // [eval] t23: cannot use "foo" (type string) as list in argument 1 to list.Product:
+    //     ./in.cue:25:19
+  }
+  t24: (_|_){
+    // [eval] error in call to list.Range: step must be non zero
+  }
+  t25: (_|_){
+    // [eval] error in call to list.Range: end must be greater than start when step is positive
+  }
+  t26: (_|_){
+    // [eval] error in call to list.Range: end must be less than start when step is negative
+  }
+  t27: (#list){
+    0: (number){ 0 }
+    1: (number){ 1 }
+    2: (number){ 2 }
+    3: (number){ 3 }
+    4: (number){ 4 }
+  }
+  t28: (#list){
+    0: (number){ 0 }
+  }
+  t29: (#list){
+    0: (number){ 0 }
+    1: (number){ 2 }
+    2: (number){ 4 }
+  }
+  t30: (#list){
+    0: (number){ 5 }
+    1: (number){ 4 }
+    2: (number){ 3 }
+    3: (number){ 2 }
+    4: (number){ 1 }
+  }
+  t31: (#list){
+    0: (number){ 0 }
+    1: (number){ 0.5 }
+    2: (number){ 1.0 }
+    3: (number){ 1.5 }
+    4: (number){ 2.0 }
+    5: (number){ 2.5 }
+    6: (number){ 3.0 }
+    7: (number){ 3.5 }
+    8: (number){ 4.0 }
+    9: (number){ 4.5 }
+  }
+  t32: (#list){
+    0: (int){ 2 }
+    1: (int){ 3 }
+  }
+  t33: (_|_){
+    // [eval] error in call to list.Slice: negative index
+  }
+  t34: (_|_){
+    // [eval] error in call to list.Slice: invalid index: 3 > 1
+  }
+  t35: (_|_){
+    // [eval] error in call to list.Slice: slice bounds out of range
+  }
+  t36: (_|_){
+    // [eval] error in call to list.Slice: slice bounds out of range
+  }
+  t37: (#list){
+  }
+  t38: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 3 }
+    3: (int){ 4 }
+  }
+  t39: (#list){
+    0: (struct){
+      a: (int){ 1 }
+      v: (int){ 2 }
+    }
+    1: (struct){
+      a: (int){ 1 }
+      v: (int){ 3 }
+    }
+    2: (struct){
+      a: (int){ 2 }
+      v: (int){ 1 }
+    }
+  }
+  t40: (_|_){
+    // [eval] x: error in call to list.Sort: x: conflicting values string and {b:2} (mismatched types string and struct) (and 1 more errors)
+  }
+  t41: (#list){
+    0: (string){ "a" }
+    1: (string){ "b" }
+  }
+  t42: (_|_){
+    // [eval] 0: error in call to list.SortStrings: element 0 of list argument 0: cannot use value 1 (type int) as string
+  }
+  t43: (number){ 10 }
+  t44: (number){ 0 }
+  t45: (_|_){
+    // [eval] t45: cannot use "foo" (type string) as list in argument 1 to list.Sum:
+    //     ./in.cue:51:15
+  }
+  t46: (#list){
+  }
+  t47: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+  }
+  t48: (#list){
+    0: (int){ 1 }
+    1: (int){ 2 }
+    2: (int){ 3 }
+    3: (int){ 4 }
+  }
+  t49: (_|_){
+    // [eval] error in call to list.Take: negative index
+  }
+  t50: (bool){ true }
+  t51: (bool){ false }
+  t52: (bool){ true }
+  t53: (bool){ false }
+  t54: (_|_){
+    // [eval] x: error in call to list.Sort: x: conflicting values string and {b:2} (mismatched types string and struct) (and 1 more errors)
+  }
+}
diff --git a/pkg/math/bits/bits_test.go b/pkg/math/bits/bits_test.go
new file mode 100644
index 0000000..46973bd
--- /dev/null
+++ b/pkg/math/bits/bits_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bits_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("bits", t)
+}
diff --git a/pkg/math/bits/testdata/gen.txtar b/pkg/math/bits/testdata/gen.txtar
new file mode 100644
index 0000000..af483ac
--- /dev/null
+++ b/pkg/math/bits/testdata/gen.txtar
@@ -0,0 +1,34 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "math/bits"
+
+t1: bits.Or(0x8, 0x1)
+t2: bits.Lsh(0x8, 4)
+t3: bits.Rsh(0x100, 4)
+t4: bits.At(0x100, 8)
+t5: bits.At(0x100, 9)
+t6: bits.Set(0x100, 7, 1)
+t7: bits.Set(0x100, 8, 0)
+t8: bits.And(0x10000000000000F0E, 0xF0F7)
+t9: bits.Or(0x100000000000000F0, 0x0F)
+t10: bits.Xor(0x10000000000000F0F, 0xFF0)
+t11: bits.Xor(0xFF0, 0x10000000000000F0F)
+t12: bits.Clear(0xF, 0x100000000000008)
+t13: bits.Clear(0x1000000000000000008, 0xF)
+-- out/bits --
+(struct){
+  t1: (int){ 9 }
+  t2: (int){ 128 }
+  t3: (int){ 16 }
+  t4: (int){ 1 }
+  t5: (int){ 0 }
+  t6: (int){ 384 }
+  t7: (int){ 0 }
+  t8: (int){ 6 }
+  t9: (int){ 18446744073709551871 }
+  t10: (int){ 18446744073709551871 }
+  t11: (int){ 18446744073709551871 }
+  t12: (int){ 7 }
+  t13: (int){ 4722366482869645213696 }
+}
diff --git a/pkg/math/math_test.go b/pkg/math/math_test.go
new file mode 100644
index 0000000..f764ad8
--- /dev/null
+++ b/pkg/math/math_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package math_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("math", t)
+}
diff --git a/pkg/math/testdata/gen.txtar b/pkg/math/testdata/gen.txtar
new file mode 100644
index 0000000..aa29913
--- /dev/null
+++ b/pkg/math/testdata/gen.txtar
@@ -0,0 +1,116 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "math"
+
+t1: math.Pi
+t2: math.Floor(math.Pi)
+t3: math.Pi(3)
+t4: math.Floor(3, 5)
+t5: math.Floor("foo")
+t6: math.Jacobi(1000, 2000)
+t7: math.Jacobi(1000, 201)
+t8: math.Asin(2.0e400)
+t9: math.MultipleOf(4, 2)
+t10: math.MultipleOf(5, 2)
+t11: math.MultipleOf(5, 0)
+t12: math.MultipleOf(100, 1.00001)
+t13: math.MultipleOf(1, 1)
+t14: math.MultipleOf(5, 2.5)
+t15: math.MultipleOf(100e100, 10)
+t16: math.Pow(8, 4)
+t17: math.Pow10(4)
+t18: math.Signbit(-4)
+t19: math.Round(2.5)
+t20: math.Round(-2.5)
+t21: math.RoundToEven(2.5)
+t22: math.RoundToEven(-2.5)
+t23: math.Abs(2.5)
+t24: math.Abs(-2.2)
+t25: math.Cbrt(2)
+t26: math.Copysign(5, -2.2)
+t27: math.Exp(3)
+t28: math.Exp2(3.5)
+t29: math.Log(4)
+t30: math.Log10(4)
+t31: math.Log2(5)
+t32: math.Dim(3, 2.5)
+t33: math.Dim(5, 7.2)
+t34: math.Ceil(2.5)
+t35: math.Ceil(-2.2)
+t36: math.Floor(2.9)
+t37: math.Floor(-2.2)
+t38: math.Trunc(2.5)
+t39: math.Trunc(-2.9)
+-- out/math --
+Errors:
+error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000
+error in call to math.MultipleOf: division by zero
+t3: cannot call non-function math.Pi (type float):
+    ./in.cue:5:5
+t4: too many arguments in call to math.Floor (have 2, want 1):
+    ./in.cue:6:20
+t5: cannot use "foo" (type string) as number in argument 1 to math.Floor:
+    ./in.cue:7:16
+cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up:
+    ./in.cue:10:5
+
+Result:
+(_|_){
+  // [eval]
+  t1: (float){ 3.14159265358979323846264338327950288419716939937510582097494459 }
+  t2: (number){ 3 }
+  t3: (_|_){
+    // [eval] t3: cannot call non-function math.Pi (type float):
+    //     ./in.cue:5:5
+  }
+  t4: (_|_){
+    // [eval] t4: too many arguments in call to math.Floor (have 2, want 1):
+    //     ./in.cue:6:20
+  }
+  t5: (_|_){
+    // [eval] t5: cannot use "foo" (type string) as number in argument 1 to math.Floor:
+    //     ./in.cue:7:16
+  }
+  t6: (_|_){
+    // [eval] error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000
+  }
+  t7: (int){ 1 }
+  t8: (_|_){
+    // [eval] cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up:
+    //     ./in.cue:10:5
+  }
+  t9: (bool){ true }
+  t10: (bool){ false }
+  t11: (_|_){
+    // [eval] error in call to math.MultipleOf: division by zero
+  }
+  t12: (bool){ false }
+  t13: (bool){ true }
+  t14: (bool){ true }
+  t15: (bool){ true }
+  t16: (number){ 4096 }
+  t17: (number){ 1E+4 }
+  t18: (bool){ true }
+  t19: (number){ 3 }
+  t20: (number){ -3 }
+  t21: (number){ 2 }
+  t22: (number){ -2 }
+  t23: (number){ 2.5 }
+  t24: (number){ 2.2 }
+  t25: (number){ 1.25992104989487316476721 }
+  t26: (number){ -5 }
+  t27: (number){ 20.0855369231876677409285 }
+  t28: (number){ 11.3137084989847603904135 }
+  t29: (number){ 1.38629436111989061883446 }
+  t30: (number){ 0.602059991327962390427478 }
+  t31: (number){ 2.32192809488736234787032 }
+  t32: (number){ 0.5 }
+  t33: (number){ 0 }
+  t34: (number){ 3 }
+  t35: (number){ -2 }
+  t36: (number){ 2 }
+  t37: (number){ -3 }
+  t38: (number){ 2 }
+  t39: (number){ -2 }
+}
diff --git a/pkg/net/net_test.go b/pkg/net/net_test.go
new file mode 100644
index 0000000..2ec22a2
--- /dev/null
+++ b/pkg/net/net_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package net_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("net", t)
+}
diff --git a/pkg/net/testdata/gen.txtar b/pkg/net/testdata/gen.txtar
new file mode 100644
index 0000000..7d76d17
--- /dev/null
+++ b/pkg/net/testdata/gen.txtar
@@ -0,0 +1,82 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "net"
+
+t1: net.FQDN & "foo.bar."
+t2: net.FQDN("foo.bararararararararararararararararararararararararararararararararara")
+t3: net.SplitHostPort("[::%lo0]:80")
+t4: net.JoinHostPort("example.com", "80")
+t5: net.JoinHostPort("2001:db8::1", 80)
+t6: net.JoinHostPort([192,30,4,2], 80)
+t7: net.JoinHostPort([192, 30, 4], 80)
+t8: net.IP("23.23.23.23")
+t9: net.IPv4 & "23.23.23.2333"
+t10: net.IP("23.23.23.23")
+t11: net.IP("2001:db8::1")
+t12: net.IPv4("2001:db8::1")
+t13: net.IPv4() & "ff02::1:3"
+t14: net.LoopbackIP([127, 0, 0, 1])
+t15: net.LoopbackIP("127.0.0.1")
+t16: net.ToIP4("127.0.0.1")
+t17: net.ToIP16("127.0.0.1")
+-- out/net --
+Errors:
+error in call to net.JoinHostPort: invalid host [192, 30, 4]
+t9: invalid value "23.23.23.2333" (does not satisfy net.IPv4)
+t13: invalid value "ff02::1:3" (does not satisfy net.IPv4):
+    ./in.cue:15:6
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "foo.bar." }
+  t2: (bool){ false }
+  t3: (#list){
+    0: (string){ "::%lo0" }
+    1: (string){ "80" }
+  }
+  t4: (string){ "example.com:80" }
+  t5: (string){ "[2001:db8::1]:80" }
+  t6: (string){ "192.30.4.2:80" }
+  t7: (_|_){
+    // [eval] error in call to net.JoinHostPort: invalid host [192, 30, 4]
+  }
+  t8: (bool){ true }
+  t9: (_|_){
+    // [eval] t9: invalid value "23.23.23.2333" (does not satisfy net.IPv4)
+  }
+  t10: (bool){ true }
+  t11: (bool){ true }
+  t12: (bool){ false }
+  t13: (_|_){
+    // [eval] t13: invalid value "ff02::1:3" (does not satisfy net.IPv4):
+    //     ./in.cue:15:6
+  }
+  t14: (bool){ true }
+  t15: (bool){ true }
+  t16: (#list){
+    0: (int){ 127 }
+    1: (int){ 0 }
+    2: (int){ 0 }
+    3: (int){ 1 }
+  }
+  t17: (#list){
+    0: (int){ 0 }
+    1: (int){ 0 }
+    2: (int){ 0 }
+    3: (int){ 0 }
+    4: (int){ 0 }
+    5: (int){ 0 }
+    6: (int){ 0 }
+    7: (int){ 0 }
+    8: (int){ 0 }
+    9: (int){ 0 }
+    10: (int){ 255 }
+    11: (int){ 255 }
+    12: (int){ 127 }
+    13: (int){ 0 }
+    14: (int){ 0 }
+    15: (int){ 1 }
+  }
+}
diff --git a/pkg/regexp/regexp_test.go b/pkg/regexp/regexp_test.go
new file mode 100644
index 0000000..f3bd0fd
--- /dev/null
+++ b/pkg/regexp/regexp_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package regexp_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("regexp", t)
+}
diff --git a/pkg/regexp/testdata/gen.txtar b/pkg/regexp/testdata/gen.txtar
new file mode 100644
index 0000000..5400e86
--- /dev/null
+++ b/pkg/regexp/testdata/gen.txtar
@@ -0,0 +1,101 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "regexp"
+
+t1: regexp.Find(#"f\w\w"#, "afoot")
+t2: regexp.Find(#"f\w\w"#, "bar")
+t3: regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)
+t4: regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)
+t5: regexp.FindAll(#"f\w\w"#, "bla bla", -1)
+t6: regexp.FindSubmatch(#"f(\w)(\w)"#, "afloat afoot from")
+t7: regexp.FindAllSubmatch(#"f(\w)(\w)"#, "afloat afoot from", -1)
+t8: regexp.FindAllSubmatch(#"f(\w)(\w)"#, "aglom", -1)
+t9: regexp.FindNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from")
+t10: regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from", -1)
+t11: regexp.FindAllNamedSubmatch(#"f(?P<A>optional)?"#, "fbla", -1)
+t12: regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "aglom", -1)
+t13: regexp.Valid & "valid"
+t14: regexp.Valid & "invalid)"
+-- out/regexp --
+Errors:
+error in call to regexp.Find: no match
+error in call to regexp.FindAll: no match
+error in call to regexp.FindAllNamedSubmatch: no match
+error in call to regexp.FindAllSubmatch: no match
+error in call to regexp.Valid: error parsing regexp: unexpected ): `invalid)`
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "foo" }
+  t2: (_|_){
+    // [eval] error in call to regexp.Find: no match
+  }
+  t3: (#list){
+    0: (string){ "foo" }
+    1: (string){ "flo" }
+  }
+  t4: (#list){
+    0: (string){ "foo" }
+    1: (string){ "flo" }
+  }
+  t5: (_|_){
+    // [eval] error in call to regexp.FindAll: no match
+  }
+  t6: (#list){
+    0: (string){ "flo" }
+    1: (string){ "l" }
+    2: (string){ "o" }
+  }
+  t7: (#list){
+    0: (#list){
+      0: (string){ "flo" }
+      1: (string){ "l" }
+      2: (string){ "o" }
+    }
+    1: (#list){
+      0: (string){ "foo" }
+      1: (string){ "o" }
+      2: (string){ "o" }
+    }
+    2: (#list){
+      0: (string){ "fro" }
+      1: (string){ "r" }
+      2: (string){ "o" }
+    }
+  }
+  t8: (_|_){
+    // [eval] error in call to regexp.FindAllSubmatch: no match
+  }
+  t9: (struct){
+    A: (string){ "l" }
+    B: (string){ "o" }
+  }
+  t10: (#list){
+    0: (struct){
+      A: (string){ "l" }
+      B: (string){ "o" }
+    }
+    1: (struct){
+      A: (string){ "o" }
+      B: (string){ "o" }
+    }
+    2: (struct){
+      A: (string){ "r" }
+      B: (string){ "o" }
+    }
+  }
+  t11: (#list){
+    0: (struct){
+      A: (string){ "" }
+    }
+  }
+  t12: (_|_){
+    // [eval] error in call to regexp.FindAllNamedSubmatch: no match
+  }
+  t13: (string){ "valid" }
+  t14: (_|_){
+    // [eval] error in call to regexp.Valid: error parsing regexp: unexpected ): `invalid)`
+  }
+}
diff --git a/pkg/strconv/strconv_test.go b/pkg/strconv/strconv_test.go
new file mode 100644
index 0000000..eb6268d
--- /dev/null
+++ b/pkg/strconv/strconv_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package strconv_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("strconv", t)
+}
diff --git a/pkg/strconv/testdata/gen.txtar b/pkg/strconv/testdata/gen.txtar
new file mode 100644
index 0000000..479d204
--- /dev/null
+++ b/pkg/strconv/testdata/gen.txtar
@@ -0,0 +1,37 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "strconv"
+
+t1: strconv.FormatUint(64, 16)
+t2: strconv.FormatFloat(3.02, 300, 4, 64)
+t3: strconv.FormatFloat(3.02, -1, 4, 64)
+t4: strconv.FormatFloat(3.02, 1.0, 4, 64)
+t5: strconv.FormatBool(true)
+-- out/strconv --
+Errors:
+int 300 overflows byte in argument 1 in call to strconv.FormatFloat:
+    ./in.cue:4:5
+cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat:
+    ./in.cue:5:5
+t4: cannot use 1.0 (type float) as int in argument 2 to strconv.FormatFloat:
+    ./in.cue:6:31
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "40" }
+  t2: (_|_){
+    // [eval] int 300 overflows byte in argument 1 in call to strconv.FormatFloat:
+    //     ./in.cue:4:5
+  }
+  t3: (_|_){
+    // [eval] cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat:
+    //     ./in.cue:5:5
+  }
+  t4: (_|_){
+    // [eval] t4: cannot use 1.0 (type float) as int in argument 2 to strconv.FormatFloat:
+    //     ./in.cue:6:31
+  }
+  t5: (string){ "true" }
+}
diff --git a/pkg/strings/strings_test.go b/pkg/strings/strings_test.go
new file mode 100644
index 0000000..60ca236
--- /dev/null
+++ b/pkg/strings/strings_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package strings_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("strings", t)
+}
diff --git a/pkg/strings/testdata/gen.txtar b/pkg/strings/testdata/gen.txtar
new file mode 100644
index 0000000..c06cf77
--- /dev/null
+++ b/pkg/strings/testdata/gen.txtar
@@ -0,0 +1,74 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "strings"
+
+t1: strings.Join(["Hello", "World!"], " ")
+t2: strings.Join([1, 2], " ")
+t3: strings.ByteAt("a", 0)
+t4: strings.ByteSlice("Hello", 2, 5)
+t5: strings.SliceRunes("✓ Hello", 0, 3)
+t6: strings.Runes("Café")
+t7: strings.ToCamel("AlphaBeta")
+t8: strings.ToTitle("alpha")
+t9: strings.MaxRunes(3) & "foo"
+t10: strings.MaxRunes(3) & "quux"
+t11: strings.MinRunes(1) & "e"
+t12: strings.MaxRunes(0) & "e"
+t13: strings.MaxRunes(0) & ""
+t14: strings.MinRunes(3) & "hello"
+t15: strings.MaxRunes(10) & "hello"
+t16: strings.MaxRunes(3) & "hello"
+t17: strings.MinRunes(10) & "hello"
+-- out/strings --
+Errors:
+0: error in call to strings.Join: element 0 of list argument 0: cannot use value 1 (type int) as string
+t10: invalid value "quux" (does not satisfy strings.MaxRunes(3)):
+    ./in.cue:12:6
+t12: invalid value "e" (does not satisfy strings.MaxRunes(0)):
+    ./in.cue:14:6
+t16: invalid value "hello" (does not satisfy strings.MaxRunes(3)):
+    ./in.cue:18:6
+t17: invalid value "hello" (does not satisfy strings.MinRunes(10)):
+    ./in.cue:19:6
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "Hello World!" }
+  t2: (_|_){
+    // [eval] 0: error in call to strings.Join: element 0 of list argument 0: cannot use value 1 (type int) as string
+  }
+  t3: (int){ 97 }
+  t4: (bytes){ 'llo' }
+  t5: (string){ "✓ H" }
+  t6: (#list){
+    0: (int){ 67 }
+    1: (int){ 97 }
+    2: (int){ 102 }
+    3: (int){ 233 }
+  }
+  t7: (string){ "alphaBeta" }
+  t8: (string){ "Alpha" }
+  t9: (string){ "foo" }
+  t10: (_|_){
+    // [eval] t10: invalid value "quux" (does not satisfy strings.MaxRunes(3)):
+    //     ./in.cue:12:6
+  }
+  t11: (string){ "e" }
+  t12: (_|_){
+    // [eval] t12: invalid value "e" (does not satisfy strings.MaxRunes(0)):
+    //     ./in.cue:14:6
+  }
+  t13: (string){ "" }
+  t14: (string){ "hello" }
+  t15: (string){ "hello" }
+  t16: (_|_){
+    // [eval] t16: invalid value "hello" (does not satisfy strings.MaxRunes(3)):
+    //     ./in.cue:18:6
+  }
+  t17: (_|_){
+    // [eval] t17: invalid value "hello" (does not satisfy strings.MinRunes(10)):
+    //     ./in.cue:19:6
+  }
+}
diff --git a/pkg/struct/structs_test.go b/pkg/struct/structs_test.go
new file mode 100644
index 0000000..f42e540
--- /dev/null
+++ b/pkg/struct/structs_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package structs_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("structs", t)
+}
diff --git a/pkg/struct/testdata/gen.txtar b/pkg/struct/testdata/gen.txtar
new file mode 100644
index 0000000..2b5e7b5
--- /dev/null
+++ b/pkg/struct/testdata/gen.txtar
@@ -0,0 +1,41 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "struct"
+
+t1: struct.MinFields(0) & ""
+t2: struct.MinFields(0) & {a: 1}
+t3: struct.MinFields(2) & {a: 1}
+t4: struct.MaxFields(0) & {a: 1}
+t5: struct.MaxFields(2) & {a: 1}
+-- out/structs --
+Errors:
+t1: conflicting values struct.MinFields(0) and "" (mismatched types struct and string)
+t3: invalid value {a:1} (does not satisfy struct.MinFields(2)):
+    ./in.cue:5:5
+t4: invalid value {a:1} (does not satisfy struct.MaxFields(0)):
+    ./in.cue:6:5
+
+Result:
+(_|_){
+  // [eval]
+  t1: (_|_){
+    // [eval] t1: conflicting values struct.MinFields(0) and "" (mismatched types struct and string)
+  }
+  t2: (struct){
+    a: (int){ 1 }
+  }
+  t3: (_|_){
+    // [eval] t3: invalid value {a:1} (does not satisfy struct.MinFields(2)):
+    //     ./in.cue:5:5
+    a: (int){ 1 }
+  }
+  t4: (_|_){
+    // [eval] t4: invalid value {a:1} (does not satisfy struct.MaxFields(0)):
+    //     ./in.cue:6:5
+    a: (int){ 1 }
+  }
+  t5: (struct){
+    a: (int){ 1 }
+  }
+}
diff --git a/pkg/text/tabwriter/tabwriter_test.go b/pkg/text/tabwriter/tabwriter_test.go
new file mode 100644
index 0000000..2815d30
--- /dev/null
+++ b/pkg/text/tabwriter/tabwriter_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tabwriter_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("tabwriter", t)
+}
diff --git a/pkg/text/tabwriter/testdata/gen.txtar b/pkg/text/tabwriter/testdata/gen.txtar
new file mode 100644
index 0000000..41c88eb
--- /dev/null
+++ b/pkg/text/tabwriter/testdata/gen.txtar
@@ -0,0 +1,17 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "text/tabwriter"
+
+t1: tabwriter.Write("""
+			a\tb\tc
+			aaa\tbb\tvv
+			""")
+t2: tabwriter.Write([
+				"a\tb\tc",
+				"aaa\tbb\tvv"])
+-- out/tabwriter --
+(struct){
+  t1: (string){ "a   b  c\naaa bb vv" }
+  t2: (string){ "a   b  c\naaa bb vv\n" }
+}
diff --git a/pkg/text/template/template_test.go b/pkg/text/template/template_test.go
new file mode 100644
index 0000000..28179f4
--- /dev/null
+++ b/pkg/text/template/template_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package template_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("template", t)
+}
diff --git a/pkg/text/template/testdata/gen.txtar b/pkg/text/template/testdata/gen.txtar
new file mode 100644
index 0000000..faebc85
--- /dev/null
+++ b/pkg/text/template/testdata/gen.txtar
@@ -0,0 +1,10 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "text/template"
+
+t1: template.Execute("{{.}}-{{.}}", "foo")
+-- out/template --
+(struct){
+  t1: (string){ "foo-foo" }
+}
diff --git a/pkg/time/builtin_test.go b/pkg/time/builtin_test.go
new file mode 100644
index 0000000..0c89699
--- /dev/null
+++ b/pkg/time/builtin_test.go
@@ -0,0 +1,25 @@
+// Copyright 2020 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package time_test
+
+import (
+	"testing"
+
+	"cuelang.org/go/pkg/internal/builtintest"
+)
+
+func TestBuiltin(t *testing.T) {
+	builtintest.Run("time", t)
+}
diff --git a/pkg/time/testdata/gen.txtar b/pkg/time/testdata/gen.txtar
new file mode 100644
index 0000000..9ed2159
--- /dev/null
+++ b/pkg/time/testdata/gen.txtar
@@ -0,0 +1,21 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "time"
+
+t1: time.Time & "1937-01-01T12:00:27.87+00:20"
+t2: time.Time & "no time"
+t3: time.Unix(1500000000, 123456)
+-- out/time --
+Errors:
+error in call to time.Time: invalid time "no time"
+
+Result:
+(_|_){
+  // [eval]
+  t1: (string){ "1937-01-01T12:00:27.87+00:20" }
+  t2: (_|_){
+    // [eval] error in call to time.Time: invalid time "no time"
+  }
+  t3: (string){ "2017-07-14T02:40:00.000123456Z" }
+}