text_test.go

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package text

import (
	"fmt"
	"math"
	"strings"
	"testing"
	"unicode/utf8"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"google.golang.org/protobuf/internal/detrand"
	"google.golang.org/protobuf/internal/flags"
	"google.golang.org/protobuf/reflect/protoreflect"
)

// Disable detrand to enable direct comparisons on outputs.
func init() { detrand.Disable() }

var S = fmt.Sprintf
var V = ValueOf
var ID = func(n protoreflect.Name) Value { return V(n) }

type Lst = []Value
type Msg = [][2]Value

func Test(t *testing.T) {
	const space = " \n\r\t"

	tests := []struct {
		in             string
		wantVal        Value
		wantOut        string
		wantOutBracket string
		wantOutASCII   string
		wantOutIndent  string
		wantErr        string
	}{{
		in:            "",
		wantVal:       V(Msg{}),
		wantOutIndent: "\n",
	}, {
		in:      S("%s# hello%s", space, space),
		wantVal: V(Msg{}),
	}, {
		in:      S("%s# hello\rfoo:bar", space),
		wantVal: V(Msg{}),
	}, {
		// Comments only extend until the newline.
		in:            S("%s# hello\nfoo:bar", space),
		wantVal:       V(Msg{{ID("foo"), ID("bar")}}),
		wantOut:       "foo:bar",
		wantOutIndent: "foo: bar\n",
	}, {
		// NUL is an invalid whitespace since C++ uses C-strings.
		in:      "\x00",
		wantErr: `invalid "\x00" as identifier`,
	}, {
		in:      "foo:0",
		wantVal: V(Msg{{ID("foo"), V(uint32(0))}}),
		wantOut: "foo:0",
	}, {
		in:      S("%sfoo%s:0", space, space),
		wantVal: V(Msg{{ID("foo"), V(uint32(0))}}),
	}, {
		in:      "foo bar:0",
		wantErr: `expected ':' after message key`,
	}, {
		in:            "[foo]:0",
		wantVal:       V(Msg{{V("foo"), V(uint32(0))}}),
		wantOut:       "[foo]:0",
		wantOutIndent: "[foo]: 0\n",
	}, {
		in:      S("%s[%sfoo%s]%s:0", space, space, space, space),
		wantVal: V(Msg{{V("foo"), V(uint32(0))}}),
	}, {
		in:            "[proto.package.name]:0",
		wantVal:       V(Msg{{V("proto.package.name"), V(uint32(0))}}),
		wantOut:       "[proto.package.name]:0",
		wantOutIndent: "[proto.package.name]: 0\n",
	}, {
		in:      S("%s[%sproto.package.name%s]%s:0", space, space, space, space),
		wantVal: V(Msg{{V("proto.package.name"), V(uint32(0))}}),
	}, {
		in:            "['sub.domain.com\x2fpath\x2fto\x2fproto.package.name']:0",
		wantVal:       V(Msg{{V("sub.domain.com/path/to/proto.package.name"), V(uint32(0))}}),
		wantOut:       "[sub.domain.com/path/to/proto.package.name]:0",
		wantOutIndent: "[sub.domain.com/path/to/proto.package.name]: 0\n",
	}, {
		in:      "[\"sub.domain.com\x2fpath\x2fto\x2fproto.package.name\"]:0",
		wantVal: V(Msg{{V("sub.domain.com/path/to/proto.package.name"), V(uint32(0))}}),
	}, {
		in:      S("%s[%s'sub.domain.com\x2fpath\x2fto\x2fproto.package.name'%s]%s:0", space, space, space, space),
		wantVal: V(Msg{{V("sub.domain.com/path/to/proto.package.name"), V(uint32(0))}}),
	}, {
		in:      S("%s[%s\"sub.domain.com\x2fpath\x2fto\x2fproto.package.name\"%s]%s:0", space, space, space, space),
		wantVal: V(Msg{{V("sub.domain.com/path/to/proto.package.name"), V(uint32(0))}}),
	}, {
		in:            `['http://example.com/path/to/proto.package.name']:0`,
		wantVal:       V(Msg{{V("http://example.com/path/to/proto.package.name"), V(uint32(0))}}),
		wantOut:       `["http://example.com/path/to/proto.package.name"]:0`,
		wantOutIndent: `["http://example.com/path/to/proto.package.name"]: 0` + "\n",
	}, {
		in:      "[proto.package.name:0",
		wantErr: `invalid character ':', expected ']' at end of extension name`,
	}, {
		in:      "[proto.package name]:0",
		wantErr: `invalid character 'n', expected ']' at end of extension name`,
	}, {
		in:      `["proto.package" "name"]:0`,
		wantErr: `invalid character '"', expected ']' at end of extension name`,
	}, {
		in:      `["\z"]`,
		wantErr: `invalid escape code "\\z" in string`,
	}, {
		in:      "[$]",
		wantErr: `invalid "$" as identifier`,
	}, {
		in:      `[proto.package.]:0`,
		wantErr: `invalid "proto.package." as identifier`,
	}, {
		in:      `[/proto.package]:0`,
		wantErr: `invalid "/proto.package" as identifier`,
	}, {
		in:      `[proto.package/]:0`,
		wantErr: `invalid "proto.package/" as identifier`,
	}, {
		// This parses fine, but should result in a error later since no
		// type name in proto will ever be just a number.
		in:      "[20]:0",
		wantVal: V(Msg{{V("20"), V(uint32(0))}}),
		wantOut: "[20]:0",
	}, {
		in:      "20:0",
		wantVal: V(Msg{{V(uint32(20)), V(uint32(0))}}),
		wantOut: "20:0",
	}, {
		in:      "0x20:0",
		wantVal: V(Msg{{V(uint32(0x20)), V(uint32(0))}}),
		wantOut: "32:0",
	}, {
		in:      "020:0",
		wantVal: V(Msg{{V(uint32(020)), V(uint32(0))}}),
		wantOut: "16:0",
	}, {
		in:      "-20:0",
		wantErr: `invalid "-20" as identifier`,
	}, {
		in: `foo:true bar:"s" baz:{} qux:[] wib:id`,
		wantVal: V(Msg{
			{ID("foo"), V(true)},
			{ID("bar"), V("s")},
			{ID("baz"), V(Msg{})},
			{ID("qux"), V(Lst{})},
			{ID("wib"), ID("id")},
		}),
		wantOut:       `foo:true bar:"s" baz:{} qux:[] wib:id`,
		wantOutIndent: "foo: true\nbar: \"s\"\nbaz: {}\nqux: []\nwib: id\n",
	}, {
		in: S(`%sfoo%s:%strue%s %sbar%s:%s"s"%s %sbaz%s:%s<>%s %squx%s:%s[]%s %swib%s:%sid%s`,
			space, space, space, space, space, space, space, space, space, space, space, space, space, space, space, space, space, space, space, space),
		wantVal: V(Msg{
			{ID("foo"), V(true)},
			{ID("bar"), V("s")},
			{ID("baz"), V(Msg{})},
			{ID("qux"), V(Lst{})},
			{ID("wib"), ID("id")},
		}),
	}, {
		in:            `foo:true;`,
		wantVal:       V(Msg{{ID("foo"), V(true)}}),
		wantOut:       "foo:true",
		wantOutIndent: "foo: true\n",
	}, {
		in:      `foo:true,`,
		wantVal: V(Msg{{ID("foo"), V(true)}}),
	}, {
		in:      `foo:bar;,`,
		wantErr: `invalid "," as identifier`,
	}, {
		in:      `foo:bar,;`,
		wantErr: `invalid ";" as identifier`,
	}, {
		in:      `footrue`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `foo true`,
		wantErr: `expected ':' after message key`,
	}, {
		in:      `foo"s"`,
		wantErr: `expected ':' after message key`,
	}, {
		in:      `foo "s"`,
		wantErr: `expected ':' after message key`,
	}, {
		in:             `foo{}`,
		wantVal:        V(Msg{{ID("foo"), V(Msg{})}}),
		wantOut:        "foo:{}",
		wantOutBracket: "foo:<>",
		wantOutIndent:  "foo: {}\n",
	}, {
		in:      `foo {}`,
		wantVal: V(Msg{{ID("foo"), V(Msg{})}}),
	}, {
		in:      `foo<>`,
		wantVal: V(Msg{{ID("foo"), V(Msg{})}}),
	}, {
		in:      `foo <>`,
		wantVal: V(Msg{{ID("foo"), V(Msg{})}}),
	}, {
		in:      `foo[]`,
		wantErr: `expected ':' after message key`,
	}, {
		in:      `foo []`,
		wantErr: `expected ':' after message key`,
	}, {
		in:      `foo:truebar:true`,
		wantErr: `invalid ":" as identifier`,
	}, {
		in:            `foo:"s"bar:true`,
		wantVal:       V(Msg{{ID("foo"), V("s")}, {ID("bar"), V(true)}}),
		wantOut:       `foo:"s" bar:true`,
		wantOutIndent: "foo: \"s\"\nbar: true\n",
	}, {
		in:      `foo:0bar:true`,
		wantErr: `invalid "0bar" as number or bool`,
	}, {
		in:             `foo:{}bar:true`,
		wantVal:        V(Msg{{ID("foo"), V(Msg{})}, {ID("bar"), V(true)}}),
		wantOut:        "foo:{} bar:true",
		wantOutBracket: "foo:<> bar:true",
		wantOutIndent:  "foo: {}\nbar: true\n",
	}, {
		in:      `foo:[]bar:true`,
		wantVal: V(Msg{{ID("foo"), V(Lst{})}, {ID("bar"), V(true)}}),
	}, {
		in:             `foo{bar:true}`,
		wantVal:        V(Msg{{ID("foo"), V(Msg{{ID("bar"), V(true)}})}}),
		wantOut:        "foo:{bar:true}",
		wantOutBracket: "foo:<bar:true>",
		wantOutIndent:  "foo: {\n\tbar: true\n}\n",
	}, {
		in:      `foo<bar:true>`,
		wantVal: V(Msg{{ID("foo"), V(Msg{{ID("bar"), V(true)}})}}),
	}, {
		in:      `foo{bar:true,}`,
		wantVal: V(Msg{{ID("foo"), V(Msg{{ID("bar"), V(true)}})}}),
	}, {
		in:      `foo{bar:true;}`,
		wantVal: V(Msg{{ID("foo"), V(Msg{{ID("bar"), V(true)}})}}),
	}, {
		in:      `foo{`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `foo{ `,
		wantErr: `unexpected EOF`,
	}, {
		in:      `foo{[`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `foo{[ `,
		wantErr: `unexpected EOF`,
	}, {
		in:      `foo{bar:true,;}`,
		wantErr: `invalid ";" as identifier`,
	}, {
		in:      `foo{bar:true;,}`,
		wantErr: `invalid "," as identifier`,
	}, {
		in:             `foo<bar:{}>`,
		wantVal:        V(Msg{{ID("foo"), V(Msg{{ID("bar"), V(Msg{})}})}}),
		wantOut:        "foo:{bar:{}}",
		wantOutBracket: "foo:<bar:<>>",
		wantOutIndent:  "foo: {\n\tbar: {}\n}\n",
	}, {
		in:      `foo<bar:{>`,
		wantErr: `invalid character '>', expected '}' at end of message`,
	}, {
		in:      `foo<bar:{}`,
		wantErr: `unexpected EOF`,
	}, {
		in:             `arr:[]`,
		wantVal:        V(Msg{{ID("arr"), V(Lst{})}}),
		wantOut:        "arr:[]",
		wantOutBracket: "arr:[]",
		wantOutIndent:  "arr: []\n",
	}, {
		in:      `arr:[,]`,
		wantErr: `invalid "," as number or bool`,
	}, {
		in:      `arr:[0 0]`,
		wantErr: `invalid character '0', expected ']' at end of list`,
	}, {
		in:             `arr:["foo" "bar"]`,
		wantVal:        V(Msg{{ID("arr"), V(Lst{V("foobar")})}}),
		wantOut:        `arr:["foobar"]`,
		wantOutBracket: `arr:["foobar"]`,
		wantOutIndent:  "arr: [\n\t\"foobar\"\n]\n",
	}, {
		in:      `arr:[0,]`,
		wantErr: `invalid "]" as number or bool`,
	}, {
		in: `arr:[true,0,"",id,[],{}]`,
		wantVal: V(Msg{{ID("arr"), V(Lst{
			V(true), V(uint32(0)), V(""), ID("id"), V(Lst{}), V(Msg{}),
		})}}),
		wantOut:        `arr:[true,0,"",id,[],{}]`,
		wantOutBracket: `arr:[true,0,"",id,[],<>]`,
		wantOutIndent:  "arr: [\n\ttrue,\n\t0,\n\t\"\",\n\tid,\n\t[],\n\t{}\n]\n",
	}, {
		in: S(`arr:[%strue%s,%s0%s,%s""%s,%sid%s,%s[]%s,%s{}%s]`,
			space, space, space, space, space, space, space, space, space, space, space, space),
		wantVal: V(Msg{{ID("arr"), V(Lst{
			V(true), V(uint32(0)), V(""), ID("id"), V(Lst{}), V(Msg{}),
		})}}),
	}, {
		in:      `arr:[`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `{`,
		wantErr: `invalid "{" as identifier`,
	}, {
		in:      `<`,
		wantErr: `invalid "<" as identifier`,
	}, {
		in:      `[`,
		wantErr: "unexpected EOF",
	}, {
		in:      `}`,
		wantErr: "1 bytes of unconsumed input",
	}, {
		in:      `>`,
		wantErr: "1 bytes of unconsumed input",
	}, {
		in:      `]`,
		wantErr: `invalid "]" as identifier`,
	}, {
		in:      `str: "'"`,
		wantVal: V(Msg{{ID("str"), V(`'`)}}),
		wantOut: `str:"'"`,
	}, {
		in:      `str: '"'`,
		wantVal: V(Msg{{ID("str"), V(`"`)}}),
		wantOut: `str:"\""`,
	}, {
		// String that has as few escaped characters as possible.
		in: `str: ` + func() string {
			var b []byte
			for i := 0; i < utf8.RuneSelf; i++ {
				switch i {
				case 0, '\\', '\n', '\'': // these must be escaped, so ignore them
				default:
					b = append(b, byte(i))
				}
			}
			return "'" + string(b) + "'"
		}(),
		wantVal:      V(Msg{{ID("str"), V("\x01\x02\x03\x04\x05\x06\a\b\t\v\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007f")}}),
		wantOut:      `str:"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`abcdefghijklmnopqrstuvwxyz{|}~\x7f\"",
		wantOutASCII: `str:"\x01\x02\x03\x04\x05\x06\x07\x08\t\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_` + "`abcdefghijklmnopqrstuvwxyz{|}~\x7f\"",
	}, {
		in:      "str: '\xde\xad\xbe\xef'",
		wantErr: "invalid UTF-8 detected",
	}, {
		// Valid UTF-8 wire encoding, but sub-optimal encoding.
		in:      "str: '\xc0\x80'",
		wantErr: "invalid UTF-8 detected",
	}, {
		// Valid UTF-8 wire encoding, but invalid rune (surrogate pair).
		in:      "str: '\xed\xa0\x80'",
		wantErr: "invalid UTF-8 detected",
	}, {
		// Valid UTF-8 wire encoding, but invalid rune (above max rune).
		in:      "str: '\xf7\xbf\xbf\xbf'",
		wantErr: "invalid UTF-8 detected",
	}, {
		// Valid UTF-8 wire encoding of the RuneError rune.
		in:           "str: '\xef\xbf\xbd'",
		wantVal:      V(Msg{{ID("str"), V(string(utf8.RuneError))}}),
		wantOut:      `str:"` + string(utf8.RuneError) + `"`,
		wantOutASCII: `str:"\ufffd"`,
	}, {
		in:           "str: 'hello\u1234world'",
		wantVal:      V(Msg{{ID("str"), V("hello\u1234world")}}),
		wantOut:      "str:\"hello\u1234world\"",
		wantOutASCII: `str:"hello\u1234world"`,
	}, {
		in:           `str: '\"\'\\\?\a\b\n\r\t\v\f\1\12\123\xA\xaB\x12\uAb8f\U0010FFFF'`,
		wantVal:      V(Msg{{ID("str"), V("\"'\\?\a\b\n\r\t\v\f\x01\nS\n\xab\x12\uab8f\U0010ffff")}}),
		wantOut:      `str:"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12` + "\uab8f\U0010ffff" + `"`,
		wantOutASCII: `str:"\"'\\?\x07\x08\n\r\t\x0b\x0c\x01\nS\n\xab\x12\uab8f\U0010ffff"`,
	}, {
		in:      `str: '`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `str: '\`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `str: '\'`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `str: '\8'`,
		wantErr: `invalid escape code "\\8" in string`,
	}, {
		in:           `str: '\1x'`,
		wantVal:      V(Msg{{ID("str"), V("\001x")}}),
		wantOut:      `str:"\x01x"`,
		wantOutASCII: `str:"\x01x"`,
	}, {
		in:           `str: '\12x'`,
		wantVal:      V(Msg{{ID("str"), V("\012x")}}),
		wantOut:      `str:"\nx"`,
		wantOutASCII: `str:"\nx"`,
	}, {
		in:           `str: '\123x'`,
		wantVal:      V(Msg{{ID("str"), V("\123x")}}),
		wantOut:      `str:"Sx"`,
		wantOutASCII: `str:"Sx"`,
	}, {
		in:           `str: '\1234x'`,
		wantVal:      V(Msg{{ID("str"), V("\1234x")}}),
		wantOut:      `str:"S4x"`,
		wantOutASCII: `str:"S4x"`,
	}, {
		in:           `str: '\1'`,
		wantVal:      V(Msg{{ID("str"), V("\001")}}),
		wantOut:      `str:"\x01"`,
		wantOutASCII: `str:"\x01"`,
	}, {
		in:           `str: '\12'`,
		wantVal:      V(Msg{{ID("str"), V("\012")}}),
		wantOut:      `str:"\n"`,
		wantOutASCII: `str:"\n"`,
	}, {
		in:           `str: '\123'`,
		wantVal:      V(Msg{{ID("str"), V("\123")}}),
		wantOut:      `str:"S"`,
		wantOutASCII: `str:"S"`,
	}, {
		in:           `str: '\1234'`,
		wantVal:      V(Msg{{ID("str"), V("\1234")}}),
		wantOut:      `str:"S4"`,
		wantOutASCII: `str:"S4"`,
	}, {
		in:           `str: '\377'`,
		wantVal:      V(Msg{{ID("str"), V("\377")}}),
		wantOut:      `str:"\xff"`,
		wantOutASCII: `str:"\xff"`,
	}, {
		// Overflow octal escape.
		in:      `str: '\400'`,
		wantErr: `invalid octal escape code "\\400" in string`,
	}, {
		in:           `str: '\xfx'`,
		wantVal:      V(Msg{{ID("str"), V("\x0fx")}}),
		wantOut:      `str:"\x0fx"`,
		wantOutASCII: `str:"\x0fx"`,
	}, {
		in:           `str: '\xffx'`,
		wantVal:      V(Msg{{ID("str"), V("\xffx")}}),
		wantOut:      `str:"\xffx"`,
		wantOutASCII: `str:"\xffx"`,
	}, {
		in:           `str: '\xfffx'`,
		wantVal:      V(Msg{{ID("str"), V("\xfffx")}}),
		wantOut:      `str:"\xfffx"`,
		wantOutASCII: `str:"\xfffx"`,
	}, {
		in:           `str: '\xf'`,
		wantVal:      V(Msg{{ID("str"), V("\x0f")}}),
		wantOut:      `str:"\x0f"`,
		wantOutASCII: `str:"\x0f"`,
	}, {
		in:           `str: '\xff'`,
		wantVal:      V(Msg{{ID("str"), V("\xff")}}),
		wantOut:      `str:"\xff"`,
		wantOutASCII: `str:"\xff"`,
	}, {
		in:           `str: '\xfff'`,
		wantVal:      V(Msg{{ID("str"), V("\xfff")}}),
		wantOut:      `str:"\xfff"`,
		wantOutASCII: `str:"\xfff"`,
	}, {
		in:      `str: '\xz'`,
		wantErr: `invalid hex escape code "\\x" in string`,
	}, {
		in:      `str: '\uPo'`,
		wantErr: `unexpected EOF`,
	}, {
		in:      `str: '\uPoo'`,
		wantErr: `invalid Unicode escape code "\\uPoo'" in string`,
	}, {
		in:      `str: '\uPoop'`,
		wantErr: `invalid Unicode escape code "\\uPoop" in string`,
	}, {
		// Unmatched surrogate pair.
		in:      `str: '\uDEAD'`,
		wantErr: `unexpected EOF`, // trying to reader other half
	}, {
		// Surrogate pair with invalid other half.
		in:      `str: '\uDEAD\u0000'`,
		wantErr: `invalid Unicode escape code "\\u0000" in string`,
	}, {
		// Properly matched surrogate pair.
		in:           `str: '\uD800\uDEAD'`,
		wantVal:      V(Msg{{ID("str"), V("𐊭")}}),
		wantOut:      `str:"𐊭"`,
		wantOutASCII: `str:"\U000102ad"`,
	}, {
		// Overflow on Unicode rune.
		in:      `str: '\U00110000'`,
		wantErr: `invalid Unicode escape code "\\U00110000" in string`,
	}, {
		in:      `str: '\z'`,
		wantErr: `invalid escape code "\\z" in string`,
	}, {
		// Strings cannot have NUL literal since C-style strings forbid them.
		in:      "str: '\x00'",
		wantErr: `invalid character '\x00' in string`,
	}, {
		// Strings cannot have newline literal. The C++ permits them if an
		// option is specified to allow them. In Go, we always forbid them.
		in:      "str: '\n'",
		wantErr: `invalid character '\n' in string`,
	}, {
		in:           "name: \"My name is \"\n\"elsewhere\"",
		wantVal:      V(Msg{{ID("name"), V("My name is elsewhere")}}),
		wantOut:      `name:"My name is elsewhere"`,
		wantOutASCII: `name:"My name is elsewhere"`,
	}, {
		in:      "name: 'My name is '\n'elsewhere'",
		wantVal: V(Msg{{ID("name"), V("My name is elsewhere")}}),
	}, {
		in:      "name: 'My name is '\n\"elsewhere\"",
		wantVal: V(Msg{{ID("name"), V("My name is elsewhere")}}),
	}, {
		in:      "name: \"My name is \"\n'elsewhere'",
		wantVal: V(Msg{{ID("name"), V("My name is elsewhere")}}),
	}, {
		in:      "name: \"My \"'name '\"is \"\n'elsewhere'",
		wantVal: V(Msg{{ID("name"), V("My name is elsewhere")}}),
	}, {
		in:      `crazy:"x'"'\""\''"'z"`,
		wantVal: V(Msg{{ID("crazy"), V(`x'""''z`)}}),
	}, {
		in: `nums: [t,T,true,True,TRUE,f,F,false,False,FALSE]`,
		wantVal: V(Msg{{ID("nums"), V(Lst{
			V(true),
			ID("T"),
			V(true),
			V(true),
			ID("TRUE"),
			V(false),
			ID("F"),
			V(false),
			V(false),
			ID("FALSE"),
		})}}),
		wantOut:       "nums:[true,T,true,true,TRUE,false,F,false,false,FALSE]",
		wantOutIndent: "nums: [\n\ttrue,\n\tT,\n\ttrue,\n\ttrue,\n\tTRUE,\n\tfalse,\n\tF,\n\tfalse,\n\tfalse,\n\tFALSE\n]\n",
	}, {
		in: `nums: [nan,inf,-inf,NaN,NAN,Inf,INF]`,
		wantVal: V(Msg{{ID("nums"), V(Lst{
			V(math.NaN()),
			V(math.Inf(+1)),
			V(math.Inf(-1)),
			ID("NaN"),
			ID("NAN"),
			ID("Inf"),
			ID("INF"),
		})}}),
		wantOut:       "nums:[nan,inf,-inf,NaN,NAN,Inf,INF]",
		wantOutIndent: "nums: [\n\tnan,\n\tinf,\n\t-inf,\n\tNaN,\n\tNAN,\n\tInf,\n\tINF\n]\n",
	}, {
		// C++ permits this, but we currently reject this.
		in:      `num: -nan`,
		wantErr: `invalid "-nan" as number or bool`,
	}, {
		in: `nums: [0,-0,-9876543210,9876543210,0x0,0x0123456789abcdef,-0x0123456789abcdef,01234567,-01234567]`,
		wantVal: V(Msg{{ID("nums"), V(Lst{
			V(uint32(0)),
			V(int32(-0)),
			V(int64(-9876543210)),
			V(uint64(9876543210)),
			V(uint32(0x0)),
			V(uint64(0x0123456789abcdef)),
			V(int64(-0x0123456789abcdef)),
			V(uint64(01234567)),
			V(int64(-01234567)),
		})}}),
		wantOut:       "nums:[0,0,-9876543210,9876543210,0,81985529216486895,-81985529216486895,342391,-342391]",
		wantOutIndent: "nums: [\n\t0,\n\t0,\n\t-9876543210,\n\t9876543210,\n\t0,\n\t81985529216486895,\n\t-81985529216486895,\n\t342391,\n\t-342391\n]\n",
	}, {
		in: `nums: [0.,0f,1f,10f,-0f,-1f,-10f,1.0,0.1e-3,1.5e+5,1e10,.0]`,
		wantVal: V(Msg{{ID("nums"), V(Lst{
			V(0.0),
			V(0.0),
			V(1.0),
			V(10.0),
			V(-0.0),
			V(-1.0),
			V(-10.0),
			V(1.0),
			V(0.1e-3),
			V(1.5e+5),
			V(1.0e+10),
			V(0.0),
		})}}),
		wantOut:       "nums:[0,0,1,10,0,-1,-10,1,0.0001,150000,1e+10,0]",
		wantOutIndent: "nums: [\n\t0,\n\t0,\n\t1,\n\t10,\n\t0,\n\t-1,\n\t-10,\n\t1,\n\t0.0001,\n\t150000,\n\t1e+10,\n\t0\n]\n",
	}, {
		in: `nums: [0xbeefbeef,0xbeefbeefbeefbeef]`,
		wantVal: V(Msg{{ID("nums"), func() Value {
			if flags.ProtoLegacy {
				return V(Lst{V(int32(-1091584273)), V(int64(-4688318750159552785))})
			} else {
				return V(Lst{V(uint32(0xbeefbeef)), V(uint64(0xbeefbeefbeefbeef))})
			}
		}()}}),
	}, {
		in:      `num: +0`,
		wantErr: `invalid "+0" as number or bool`,
	}, {
		in:      `num: 01.1234`,
		wantErr: `invalid "01.1234" as number or bool`,
	}, {
		in:      `num: 0x`,
		wantErr: `invalid "0x" as number or bool`,
	}, {
		in:      `num: 0xX`,
		wantErr: `invalid "0xX" as number or bool`,
	}, {
		in:      `num: 0800`,
		wantErr: `invalid "0800" as number or bool`,
	}, {
		in:      `num: true.`,
		wantErr: `invalid "true." as number or bool`,
	}, {
		in:      `num: .`,
		wantErr: `parsing ".": invalid syntax`,
	}, {
		in:      `num: -.`,
		wantErr: `parsing "-.": invalid syntax`,
	}, {
		in:      `num: 1e10000`,
		wantErr: `parsing "1e10000": value out of range`,
	}, {
		in:      `num: 99999999999999999999`,
		wantErr: `parsing "99999999999999999999": value out of range`,
	}, {
		in:      `num: -99999999999999999999`,
		wantErr: `parsing "-99999999999999999999": value out of range`,
	}, {
		in:      "x:  -",
		wantErr: `syntax error (line 1:5)`,
	}, {
		in:      "x:[\"💩\"x",
		wantErr: `syntax error (line 1:7)`,
	}, {
		in:      "x:\n\n[\"🔥🔥🔥\"x",
		wantErr: `syntax error (line 3:7)`,
	}, {
		in:      "x:[\"👍🏻👍🏿\"x",
		wantErr: `syntax error (line 1:10)`, // multi-rune emojis; could be column:8
	}, {
		in: `
			firstName : "John",
			lastName : "Smith" ,
			isAlive : true,
			age : 27,
			address { # missing colon is okay for messages
			    streetAddress : "21 2nd Street" ,
			    city : "New York" ,
			    state : "NY" ,
			    postalCode : "10021-3100" ; # trailing semicolon is okay
			},
			phoneNumbers : [ {
			    type : "home" ,
			    number : "212 555-1234"
			} , {
			    type : "office" ,
			    number : "646 555-4567"
			} , {
			    type : "mobile" ,
			    number : "123 456-7890" , # trailing comma is okay
			} ],
			children : [] ,
			spouse : null`,
		wantVal: V(Msg{
			{ID("firstName"), V("John")},
			{ID("lastName"), V("Smith")},
			{ID("isAlive"), V(true)},
			{ID("age"), V(27.0)},
			{ID("address"), V(Msg{
				{ID("streetAddress"), V("21 2nd Street")},
				{ID("city"), V("New York")},
				{ID("state"), V("NY")},
				{ID("postalCode"), V("10021-3100")},
			})},
			{ID("phoneNumbers"), V([]Value{
				V(Msg{
					{ID("type"), V("home")},
					{ID("number"), V("212 555-1234")},
				}),
				V(Msg{
					{ID("type"), V("office")},
					{ID("number"), V("646 555-4567")},
				}),
				V(Msg{
					{ID("type"), V("mobile")},
					{ID("number"), V("123 456-7890")},
				}),
			})},
			{ID("children"), V([]Value{})},
			{ID("spouse"), V(protoreflect.Name("null"))},
		}),
		wantOut:        `firstName:"John" lastName:"Smith" isAlive:true age:27 address:{streetAddress:"21 2nd Street" city:"New York" state:"NY" postalCode:"10021-3100"} phoneNumbers:[{type:"home" number:"212 555-1234"},{type:"office" number:"646 555-4567"},{type:"mobile" number:"123 456-7890"}] children:[] spouse:null`,
		wantOutBracket: `firstName:"John" lastName:"Smith" isAlive:true age:27 address:<streetAddress:"21 2nd Street" city:"New York" state:"NY" postalCode:"10021-3100"> phoneNumbers:[<type:"home" number:"212 555-1234">,<type:"office" number:"646 555-4567">,<type:"mobile" number:"123 456-7890">] children:[] spouse:null`,
		wantOutIndent: `firstName: "John"
lastName: "Smith"
isAlive: true
age: 27
address: {
	streetAddress: "21 2nd Street"
	city: "New York"
	state: "NY"
	postalCode: "10021-3100"
}
phoneNumbers: [
	{
		type: "home"
		number: "212 555-1234"
	},
	{
		type: "office"
		number: "646 555-4567"
	},
	{
		type: "mobile"
		number: "123 456-7890"
	}
]
children: []
spouse: null
`,
	}}

	opts := cmp.Options{
		cmpopts.EquateEmpty(),

		// Transform composites (List and Message).
		cmp.FilterValues(func(x, y Value) bool {
			return (x.Type() == List && y.Type() == List) || (x.Type() == Message && y.Type() == Message)
		}, cmp.Transformer("", func(v Value) interface{} {
			if v.Type() == List {
				return v.List()
			} else {
				return v.Message()
			}
		})),

		// Compare scalars (Bool, Int, Uint, Float, String, Name).
		cmp.FilterValues(func(x, y Value) bool {
			return !(x.Type() == List && y.Type() == List) && !(x.Type() == Message && y.Type() == Message)
		}, cmp.Comparer(func(x, y Value) bool {
			if x.Type() == List || x.Type() == Message || y.Type() == List || y.Type() == Message {
				return false
			}
			// Ensure golden value is always in x variable.
			if len(x.raw) > 0 {
				x, y = y, x
			}
			switch x.Type() {
			case Bool:
				want, _ := x.Bool()
				got, ok := y.Bool()
				return got == want && ok
			case Int:
				want, _ := x.Int(true)
				got, ok := y.Int(want < math.MinInt32 || math.MaxInt32 < want)
				return got == want && ok
			case Uint:
				want, _ := x.Uint(true)
				got, ok := y.Uint(math.MaxUint32 < want)
				return got == want && ok
			case Float32, Float64:
				want, _ := x.Float(true)
				got, ok := y.Float(math.MaxFloat32 < math.Abs(want))
				if math.IsNaN(got) || math.IsNaN(want) {
					return math.IsNaN(got) == math.IsNaN(want)
				}
				return got == want && ok
			case Name:
				want, _ := x.Name()
				got, ok := y.Name()
				return got == want && ok
			default:
				return x.String() == y.String()
			}
		})),
	}
	for _, tt := range tests {
		t.Run("", func(t *testing.T) {
			if tt.in != "" || tt.wantVal.Type() != 0 || tt.wantErr != "" {
				gotVal, err := Unmarshal([]byte(tt.in))
				if err == nil {
					if tt.wantErr != "" {
						t.Errorf("Unmarshal(): got nil error, want %v", tt.wantErr)
					}
				} else {
					if tt.wantErr == "" {
						t.Errorf("Unmarshal(): got %v, want nil error", err)
					} else if !strings.Contains(err.Error(), tt.wantErr) {
						t.Errorf("Unmarshal(): got %v, want %v", err, tt.wantErr)
					}
				}
				if diff := cmp.Diff(gotVal, tt.wantVal, opts); diff != "" {
					t.Errorf("Unmarshal(): output mismatch (-got +want):\n%s", diff)
				}
			}
			if tt.wantOut != "" {
				gotOut, err := Marshal(tt.wantVal, "", [2]byte{0, 0}, false)
				if err != nil {
					t.Errorf("Marshal(): got %v, want nil error", err)
				}
				if string(gotOut) != tt.wantOut {
					t.Errorf("Marshal():\ngot:  %s\nwant: %s", gotOut, tt.wantOut)
				}
			}
			if tt.wantOutBracket != "" {
				gotOut, err := Marshal(tt.wantVal, "", [2]byte{'<', '>'}, false)
				if err != nil {
					t.Errorf("Marshal(Bracket): got %v, want nil error", err)
				}
				if string(gotOut) != tt.wantOutBracket {
					t.Errorf("Marshal(Bracket):\ngot:  %s\nwant: %s", gotOut, tt.wantOutBracket)
				}
			}
			if tt.wantOutASCII != "" {
				gotOut, err := Marshal(tt.wantVal, "", [2]byte{0, 0}, true)
				if err != nil {
					t.Errorf("Marshal(ASCII): got %v, want nil error", err)
				}
				if string(gotOut) != tt.wantOutASCII {
					t.Errorf("Marshal(ASCII):\ngot:  %s\nwant: %s", gotOut, tt.wantOutASCII)
				}
			}
			if tt.wantOutIndent != "" {
				gotOut, err := Marshal(tt.wantVal, "\t", [2]byte{0, 0}, false)
				if err != nil {
					t.Errorf("Marshal(Indent): got %v, want nil error", err)
				}
				if string(gotOut) != tt.wantOutIndent {
					t.Errorf("Marshal(Indent):\ngot:  %s\nwant: %s", gotOut, tt.wantOutIndent)
				}
			}
		})
	}
}