// Copyright 2015 The Vanadium 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 vdl

import (
	"bytes"
	"fmt"
	"sort"
	"strings"
	"testing"
)

var (
	keyType = StructType([]Field{{"I", Int64Type}, {"S", StringType}}...)

	strA, strB, strC = StringValue("A"), StringValue("B"), StringValue("C")
	int1, int2       = Int64Value(1), Int64Value(2)
	key1, key2, key3 = makeKey(1, "A"), makeKey(2, "B"), makeKey(3, "C")
)

func makeKey(a int64, b string) *Value {
	key := ZeroValue(keyType)
	key.StructField(0).AssignInt(a)
	key.StructField(1).AssignString(b)
	return key
}

func TestValueInvalid(t *testing.T) {
	tests := []*Value{nil, new(Value)}
	for ix, test := range tests {
		if test.IsValid() {
			t.Errorf(`%d IsValid()`, ix)
		}
		if got, want := test.String(), "INVALID"; got != want {
			t.Errorf(`%d String() got %v, want %v`, ix, got, want)
		}
	}
}

func TestValue(t *testing.T) {
	tests := []struct {
		k Kind
		t *Type
		s string
	}{
		{Bool, BoolType, "false"},
		{Byte, ByteType, "byte(0)"},
		{Uint16, Uint16Type, "uint16(0)"},
		{Uint32, Uint32Type, "uint32(0)"},
		{Uint64, Uint64Type, "uint64(0)"},
		{Int8, Int8Type, "int8(0)"},
		{Int16, Int16Type, "int16(0)"},
		{Int32, Int32Type, "int32(0)"},
		{Int64, Int64Type, "int64(0)"},
		{Float32, Float32Type, "float32(0)"},
		{Float64, Float64Type, "float64(0)"},
		{Complex64, Complex64Type, "complex64(0+0i)"},
		{Complex128, Complex128Type, "complex128(0+0i)"},
		{String, StringType, `""`},
		{List, ListType(ByteType), `[]byte("")`},
		{Array, ArrayType(3, ByteType), `[3]byte("\x00\x00\x00")`},
		{Enum, EnumType("A", "B", "C"), "enum{A;B;C}(A)"},
		{TypeObject, TypeObjectType, "typeobject(any)"},
		{Array, ArrayType(2, StringType), `[2]string{"", ""}`},
		{List, ListType(StringType), "[]string{}"},
		{Set, SetType(StringType), "set[string]{}"},
		{Set, SetType(keyType), "set[struct{I int64;S string}]{}"},
		{Map, MapType(StringType, Int64Type), "map[string]int64{}"},
		{Map, MapType(keyType, Int64Type), "map[struct{I int64;S string}]int64{}"},
		{Struct, StructType([]Field{{"A", Int64Type}, {"B", StringType}, {"C", BoolType}}...), `struct{A int64;B string;C bool}{A: 0, B: "", C: false}`},
		{Union, UnionType([]Field{{"A", Int64Type}, {"B", StringType}, {"C", BoolType}}...), `union{A int64;B string;C bool}{A: 0}`},
		{Any, AnyType, "any(nil)"},
	}
	for _, test := range tests {
		x := ZeroValue(test.t)
		if !x.IsValid() {
			t.Errorf(`!ZeroValue(%s).IsValid`, test.k)
		}
		if !x.IsZero() {
			t.Errorf(`ZeroValue(%s) isn't zero`, test.k)
		}
		if test.k == Any && !x.IsNil() {
			t.Errorf(`ZeroValue(Any) isn't nil`)
		}
		if got, want := x.Kind(), test.k; got != want {
			t.Errorf(`ZeroValue(%s) got kind %v, want %v`, test.k, got, want)
		}
		if got, want := x.Type(), test.t; got != want {
			t.Errorf(`ZeroValue(%s) got type %v, want %v`, test.k, got, want)
		}
		if got, want := x.String(), test.s; got != want {
			t.Errorf(`ZeroValue(%s) got string %q, want %q`, test.k, got, want)
		}
		y := CopyValue(x)
		if !y.IsValid() {
			t.Errorf(`!CopyValue(ZeroValue(%s)).IsValid`, test.k)
		}
		if !y.IsZero() {
			t.Errorf(`ZeroValue(%s) of copy isn't zero, y: %v`, test.k, y)
		}
		if test.k == Any && !y.IsNil() {
			t.Errorf(`ZeroValue(Any) of copy isn't nil`)
		}
		if !EqualValue(x, y) {
			t.Errorf(`ZeroValue(%s) !Equal after copy, x: %v, y: %v`, test.k, x, y)
		}

		// Invariant here: x == y == 0
		// The assign[KIND] functions assign a nonzero value.
		assignBool(t, x)
		assignUint(t, x)
		assignInt(t, x)
		assignFloat(t, x)
		assignComplex(t, x)
		assignString(t, x)
		assignEnum(t, x)
		assignTypeObject(t, x)
		assignArray(t, x)
		assignList(t, x)
		assignSet(t, x)
		assignMap(t, x)
		assignStruct(t, x)
		assignUnion(t, x)
		assignAny(t, x)

		// Invariant here: x != 0 && y == 0
		if EqualValue(x, y) {
			t.Errorf(`ZeroValue(%s) Equal after assign, x: %v, y: %v`, test.k, x, y)
		}
		z := CopyValue(x) // x == z && x != 0 && y == 0
		if !EqualValue(x, z) {
			t.Errorf(`ZeroValue(%s) !Equal after copy, x: %v, z: %v`, test.k, x, z)
		}
		if EqualValue(y, z) {
			t.Errorf(`ZeroValue(%s) Equal after copy, y: %v, z: %v`, test.k, y, z)
		}

		z.Assign(nil) // x != 0 && y == z == 0
		if !z.IsValid() {
			t.Errorf(`%s z after Assign(nil) isn't valid`, test.k)
		}
		if !z.IsZero() {
			t.Errorf(`%s z after Assign(nil) isn't zero`, test.k)
		}
		if test.k == Any && !z.IsNil() {
			t.Errorf(`Any z after Assign(nil) isn't nil`)
		}
		if EqualValue(x, z) {
			t.Errorf(`%s Equal after Assign(nil), x: %v, z: %v`, test.k, x, z)
		}
		if !EqualValue(y, z) {
			t.Errorf(`%s !Equal after Assign(nil), y: %v, z: %v`, test.k, y, z)
		}

		y.Assign(x) // x == y && x != 0 && z == 0
		if !y.IsValid() {
			t.Errorf(`%s y after Assign(x) isn't valid`, test.k)
		}
		if y.IsZero() {
			t.Errorf(`%s y after Assign(x) is zero, y: %v`, test.k, y)
		}
		if y.IsNil() {
			t.Errorf(`%s y after Assign(x) is nil, y: %v`, test.k, y)
		}
		if !EqualValue(x, y) {
			t.Errorf(`%s Equal after Assign(x), x: %v, y: %v`, test.k, x, y)
		}
		if EqualValue(y, z) {
			t.Errorf(`%s Equal after Assign(x), y: %v, z: %v`, test.k, y, z)
		}

		// Test optional types
		if !test.t.CanBeOptional() {
			continue
		}
		ntype := OptionalType(test.t)

		// nx == nil
		nx := ZeroValue(ntype)
		if !nx.IsValid() {
			t.Errorf(`!ZeroValue(?%s).IsValid`, test.k)
		}
		if !nx.IsZero() {
			t.Errorf(`ZeroValue(?%s) isn't zero`, test.k)
		}
		if !nx.IsNil() {
			t.Errorf(`ZeroValue(?%s) isn't nil`, test.k)
		}
		if got, want := nx.Kind(), Optional; got != want {
			t.Errorf(`ZeroValue(?%s) got kind %v, want %v`, test.k, got, want)
		}
		if got, want := nx.Type(), ntype; got != want {
			t.Errorf(`ZeroValue(?%s) got type %v, want %v`, test.k, got, want)
		}
		if got, want := nx.String(), ntype.String()+"(nil)"; got != want {
			t.Errorf(`ZeroValue(?%s) got string %q, want %q`, test.k, got, want)
		}
		// ny != nil
		ny := NonNilZeroValue(ntype)
		if !ny.IsValid() {
			t.Errorf(`!NonNilZeroValue(?%s).IsValid`, test.k)
		}
		if ny.IsZero() {
			t.Errorf(`NonNilZeroValue(?%s) is zero`, test.k)
		}
		if ny.IsNil() {
			t.Errorf(`NonNilZeroValue(?%s) is nil`, test.k)
		}
		if got, want := ny.Kind(), Optional; got != want {
			t.Errorf(`NonNilZeroValue(?%s) got kind %v, want %v`, test.k, got, want)
		}
		if got, want := ny.Type(), ntype; got != want {
			t.Errorf(`NonNilZeroValue(?%s) got type %v, want %v`, test.k, got, want)
		}
	}
}

// Each of the below assign{KIND} functions assigns a nonzero value to x for
// matching kinds, otherwise it expects a mismatched-kind panic when trying the
// kind-specific methods.  The point is to ensure we've tried all combinations
// of kinds and methods.

func assignBool(t *testing.T, x *Value) {
	newval, newstr := true, "true"
	if x.Kind() == Bool {
		if got, want := x.Bool(), false; got != want {
			t.Errorf(`Bool zero value got %v, want %v`, got, want)
		}
		x.AssignBool(newval)
		if got, want := x.Bool(), newval; got != want {
			t.Errorf(`Bool assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), newstr; got != want {
			t.Errorf(`Bool string got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.Bool() })
		ExpectMismatchedKind(t, func() { x.AssignBool(newval) })
	}
}

func assignUint(t *testing.T, x *Value) {
	newval := uint64(123)
	switch x.Kind() {
	case Byte, Uint16, Uint32, Uint64:
		if got, want := x.Uint(), uint64(0); got != want {
			t.Errorf(`Uint zero value got %v, want %v`, got, want)
		}
		x.AssignUint(newval)
		if got, want := x.Uint(), newval; got != want {
			t.Errorf(`Uint assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), x.Kind().String()+"(123)"; got != want {
			t.Errorf(`Uint string got %v, want %v`, got, want)
		}
	default:
		ExpectMismatchedKind(t, func() { x.Uint() })
		ExpectMismatchedKind(t, func() { x.AssignUint(newval) })
	}
}

func assignInt(t *testing.T, x *Value) {
	newval := int64(123)
	switch x.Kind() {
	case Int8, Int16, Int32, Int64:
		if got, want := x.Int(), int64(0); got != want {
			t.Errorf(`Int zero value got %v, want %v`, got, want)
		}
		x.AssignInt(newval)
		if got, want := x.Int(), newval; got != want {
			t.Errorf(`Int assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), x.Kind().String()+"(123)"; got != want {
			t.Errorf(`Int string got %v, want %v`, got, want)
		}
	default:
		ExpectMismatchedKind(t, func() { x.Int() })
		ExpectMismatchedKind(t, func() { x.AssignInt(newval) })
	}
}

func assignFloat(t *testing.T, x *Value) {
	newval := float64(1.23)
	switch x.Kind() {
	case Float32, Float64:
		if got, want := x.Float(), float64(0); got != want {
			t.Errorf(`Float zero value got %v, want %v`, got, want)
		}
		x.AssignFloat(newval)
		if got, want := x.Float(), newval; got != want {
			t.Errorf(`Float assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), x.Kind().String()+"(1.23)"; got != want {
			t.Errorf(`Float string got %v, want %v`, got, want)
		}
	default:
		ExpectMismatchedKind(t, func() { x.Float() })
		ExpectMismatchedKind(t, func() { x.AssignFloat(newval) })
	}
}

func assignComplex(t *testing.T, x *Value) {
	newval := complex128(1 + 2i)
	switch x.Kind() {
	case Complex64, Complex128:
		if got, want := x.Complex(), complex128(0); got != want {
			t.Errorf(`Complex zero value got %v, want %v`, got, want)
		}
		x.AssignComplex(newval)
		if got, want := x.Complex(), newval; got != want {
			t.Errorf(`Complex assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), x.Kind().String()+"(1+2i)"; got != want {
			t.Errorf(`Complex string got %v, want %v`, got, want)
		}
	default:
		ExpectMismatchedKind(t, func() { x.Complex() })
		ExpectMismatchedKind(t, func() { x.AssignComplex(newval) })
	}
}

func assignString(t *testing.T, x *Value) {
	zerostr, newval, newstr := `""`, "abc", `"abc"`
	if x.Kind() == String {
		if got, want := x.String(), zerostr; got != want {
			t.Errorf(`String zero value got %v, want %v`, got, want)
		}
		x.AssignString(newval)
		if got, want := x.RawString(), newval; got != want {
			t.Errorf(`String assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), newstr; got != want {
			t.Errorf(`String assign string rep got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.RawString() })
		ExpectMismatchedKind(t, func() { x.AssignString(newval) })
	}
}

func assignEnum(t *testing.T, x *Value) {
	if x.Kind() == Enum {
		if gi, gl, wi, wl := x.EnumIndex(), x.EnumLabel(), 0, "A"; gi != wi || gl != wl {
			t.Errorf(`Enum zero value got [%d]%v, want [%d]%v`, gi, gl, wi, wl)
		}
		x.AssignEnumIndex(1)
		if gi, gl, wi, wl := x.EnumIndex(), x.EnumLabel(), 1, "B"; gi != wi || gl != wl {
			t.Errorf(`Enum assign index value got [%d]%v, want [%d]%v`, gi, gl, wi, wl)
		}
		if got, want := x.String(), "enum{A;B;C}(B)"; got != want {
			t.Errorf(`Enum string got %v, want %v`, got, want)
		}
		x.AssignEnumIndex(2)
		if gi, gl, wi, wl := x.EnumIndex(), x.EnumLabel(), 2, "C"; gi != wi || gl != wl {
			t.Errorf(`Enum assign label value got [%d]%v, want [%d]%v`, gi, gl, wi, wl)
		}
		if got, want := x.String(), "enum{A;B;C}(C)"; got != want {
			t.Errorf(`Enum string got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.EnumIndex() })
		ExpectMismatchedKind(t, func() { x.EnumLabel() })
		ExpectMismatchedKind(t, func() { x.AssignEnumIndex(0) })
		ExpectMismatchedKind(t, func() { x.AssignEnumLabel("A") })
	}
}

func assignTypeObject(t *testing.T, x *Value) {
	newval, newstr := BoolType, "typeobject(bool)"
	if x.Kind() == TypeObject {
		if got, want := x.TypeObject(), zeroTypeObject; got != want {
			t.Errorf(`TypeObject zero value got %v, want %v`, got, want)
		}
		x.AssignTypeObject(newval)
		if got, want := x.TypeObject(), newval; got != want {
			t.Errorf(`TypeObject assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), newstr; got != want {
			t.Errorf(`TypeObject string got %v, want %v`, got, want)
		}
		x.AssignTypeObject(nil) // assigning nil sets the zero typeobject
		if got, want := x.TypeObject(), zeroTypeObject; got != want {
			t.Errorf(`TypeObject assign value got %v, want %v`, got, want)
		}
		x.AssignTypeObject(newval)
	} else {
		ExpectMismatchedKind(t, func() { x.TypeObject() })
		ExpectMismatchedKind(t, func() { x.AssignTypeObject(newval) })
	}
}

func assignArray(t *testing.T, x *Value) {
	if x.Kind() == Array {
		if x.Type().IsBytes() {
			assignBytes(t, x)
			return
		}
		if got, want := x.Len(), 2; got != want {
			t.Errorf(`Array zero len got %v, want %v`, got, want)
		}
		if g0, g1, w0, w1 := x.Index(0).String(), x.Index(1).String(), `""`, `""`; g0 != w0 || g1 != w1 {
			t.Errorf(`Array assign values got %v %v, want %v %v`, g0, g1, w0, w1)
		}
		x.Index(0).AssignString("A")
		x.Index(1).AssignString("B")
		if g0, g1, w0, w1 := x.Index(0).String(), x.Index(1).String(), `"A"`, `"B"`; g0 != w0 || g1 != w1 {
			t.Errorf(`Array assign values got %v %v, want %v %v`, g0, g1, w0, w1)
		}
		if got, want := x.String(), `[2]string{"A", "B"}`; got != want {
			t.Errorf(`Array string got %v, want %v`, got, want)
		}
	} else {
		if x.Kind() != List {
			// Index is allowed for Array and List
			ExpectMismatchedKind(t, func() { x.Index(0) })
		}
		if x.Kind() != List && x.Kind() != Set && x.Kind() != Map {
			// Len is allowed for Array, List, Set and Map
			ExpectMismatchedKind(t, func() { x.Len() })
		}
	}
}

func assignList(t *testing.T, x *Value) {
	if x.Kind() == List {
		if x.Type().IsBytes() {
			assignBytes(t, x)
			return
		}
		if got, want := x.Len(), 0; got != want {
			t.Errorf(`List zero len got %v, want %v`, got, want)
		}
		x.AssignLen(2)
		if got, want := x.Len(), 2; got != want {
			t.Errorf(`List assign len got %v, want %v`, got, want)
		}
		if g0, g1, w0, w1 := x.Index(0).String(), x.Index(1).String(), `""`, `""`; g0 != w0 || g1 != w1 {
			t.Errorf(`List assign values got %v %v, want %v %v`, g0, g1, w0, w1)
		}
		if got, want := x.String(), `[]string{"", ""}`; got != want {
			t.Errorf(`List string got %v, want %v`, got, want)
		}
		x.Index(0).AssignString("A")
		x.Index(1).AssignString("B")
		if g0, g1, w0, w1 := x.Index(0).String(), x.Index(1).String(), `"A"`, `"B"`; g0 != w0 || g1 != w1 {
			t.Errorf(`List assign values got %v %v, want %v %v`, g0, g1, w0, w1)
		}
		if got, want := x.String(), `[]string{"A", "B"}`; got != want {
			t.Errorf(`List string got %v, want %v`, got, want)
		}
		x.AssignLen(1)
		if got, want := x.Len(), 1; got != want {
			t.Errorf(`List assign len got %v, want %v`, got, want)
		}
		if g0, w0 := x.Index(0).String(), `"A"`; g0 != w0 {
			t.Errorf(`List assign values got %v, want %v`, g0, w0)
		}
		if got, want := x.String(), `[]string{"A"}`; got != want {
			t.Errorf(`List string got %v, want %v`, got, want)
		}
		x.AssignLen(3)
		if got, want := x.Len(), 3; got != want {
			t.Errorf(`List assign len got %v, want %v`, got, want)
		}
		if g0, g1, g2, w0, w1, w2 := x.Index(0).String(), x.Index(1).String(), x.Index(2).String(), `"A"`, `""`, `""`; g0 != w0 || g1 != w1 || g2 != w2 {
			t.Errorf(`List assign values got %v %v %v, want %v %v %v`, g0, g1, g2, w0, w1, w2)
		}
		if got, want := x.String(), `[]string{"A", "", ""}`; got != want {
			t.Errorf(`List string got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.AssignLen(0) })
		if x.Kind() != Array {
			// Index is allowed for Array and List
			ExpectMismatchedKind(t, func() { x.Index(0) })
		}
		if x.Kind() != Array && x.Kind() != Set && x.Kind() != Map {
			// Len is allowed for Array, List, Set and Map
			ExpectMismatchedKind(t, func() { x.Len() })
		}
	}
}

func assignBytes(t *testing.T, x *Value) {
	abval, abcval, abcdval := []byte("ab"), []byte("abc"), []byte("abcd")
	efgval, efghval := []byte("efg"), []byte("efgh")
	zeroval, typestr := []byte{}, "[]byte"
	if x.Kind() == Array {
		zeroval, typestr = []byte{0, 0, 0}, "[3]byte"
	}

	if got, want := x.Bytes(), zeroval; !bytes.Equal(got, want) {
		t.Errorf(`Bytes zero value got %v, want %v`, got, want)
	}
	// AssignBytes fills all bytes of the array if the array len is equal to the
	// bytes len, and automatically assigns the len for lists.
	x.AssignBytes(abcval)
	if got, want := x.Bytes(), abcval; !bytes.Equal(got, want) {
		t.Errorf(`Bytes CopyBytes got %v, want %v`, got, want)
	}
	if got, want := x.String(), typestr+`("abc")`; got != want {
		t.Errorf(`Bytes string got %v, want %v`, got, want)
	}
	abcval[1] = 'Z' // doesn't affect x
	if got, want := x.Bytes(), []byte("abc"); !bytes.Equal(got, want) {
		t.Errorf(`Bytes got %v, want %v`, got, want)
	}
	if got, want := x.String(), typestr+`("abc")`; got != want {
		t.Errorf(`Bytes string got %v, want %v`, got, want)
	}
	// AssignBytes panics for arrays if the array len is not equal to the bytes
	// len, and automatically assigns the len for lists.
	if x.Kind() == Array {
		ExpectPanic(t, func() { x.AssignBytes(abval) }, "AssignBytes", "[3]byte AssignBytes(%v)", abval)
		ExpectPanic(t, func() { x.AssignBytes(abcdval) }, "AssignBytes", "[3]byte AssignBytes(%v)", abcdval)
	} else {
		x.AssignBytes(abval)
		if got, want := x.Bytes(), abval; !bytes.Equal(got, want) {
			t.Errorf(`Bytes CopyBytes got %v, want %v`, got, want)
		}
		if got, want := x.String(), typestr+`("ab")`; got != want {
			t.Errorf(`Bytes string got %v, want %v`, got, want)
		}
		x.AssignBytes(abcdval)
		if got, want := x.Bytes(), abcdval; !bytes.Equal(got, want) {
			t.Errorf(`Bytes CopyBytes got %v, want %v`, got, want)
		}
		if got, want := x.String(), typestr+`("abcd")`; got != want {
			t.Errorf(`Bytes string got %v, want %v`, got, want)
		}
		x.AssignLen(3)
		if got, want := x.Bytes(), []byte("abc"); !bytes.Equal(got, want) {
			t.Errorf(`Bytes CopyBytes got %v, want %v`, got, want)
		}
		if got, want := x.String(), typestr+`("abc")`; got != want {
			t.Errorf(`Bytes string got %v, want %v`, got, want)
		}
	}
	// CopyBytes ignores extra bytes, just like regular copy().
	x.CopyBytes(efghval)
	if got, want := x.Bytes(), efgval; !bytes.Equal(got, want) {
		t.Errorf(`Bytes CopyBytes got %v, want %v`, got, want)
	}
	if got, want := x.String(), typestr+`("efg")`; got != want {
		t.Errorf(`Bytes string got %v, want %v`, got, want)
	}
	// Bytes gives the underlying byteslice, which may be mutated.
	x.Bytes()[1] = 'Z'
	if got, want := x.Bytes(), []byte("eZg"); !bytes.Equal(got, want) {
		t.Errorf(`Bytes got %v, want %v`, got, want)
	}
	if got, want := x.String(), typestr+`("eZg")`; got != want {
		t.Errorf(`Bytes string got %v, want %v`, got, want)
	}
	// Indexing also works, just like for any other list.
	index := x.Index(1)
	if got, want := index.Type(), ByteType; got != want {
		t.Errorf(`Bytes index type got %v, want %v`, got, want)
	}
	if got, want := index.String(), fmt.Sprintf("byte(%d)", 'Z'); got != want {
		t.Errorf(`Bytes index string got %v, want %v`, got, want)
	}
	if got, want := index.Uint(), uint64('Z'); got != want {
		t.Errorf(`Bytes index Byte got %v, want %v`, got, want)
	}
	if got, want := index, ByteValue('Z'); !EqualValue(got, want) {
		t.Errorf(`Bytes index value got %v, want %v`, got, want)
	}
	index.AssignUint(uint64('Y'))
	if got, want := index.String(), fmt.Sprintf("byte(%d)", 'Y'); got != want {
		t.Errorf(`Bytes index string got %v, want %v`, got, want)
	}
	if got, want := index.Uint(), uint64('Y'); got != want {
		t.Errorf(`Bytes index Byte got %v, want %v`, got, want)
	}
	if got, want := index, ByteValue('Y'); !EqualValue(got, want) {
		t.Errorf(`Bytes index value got %v, want %v`, got, want)
	}
	// Make sure the original bytes were mutated.
	if got, want := x.Bytes(), []byte("eYg"); !bytes.Equal(got, want) {
		t.Errorf(`Bytes got %v, want %v`, got, want)
	}
	if got, want := x.String(), typestr+`("eYg")`; got != want {
		t.Errorf(`Bytes string got %v, want %v`, got, want)
	}
}

func toStringSlice(a []*Value) []string {
	ret := make([]string, len(a))
	for ix := 0; ix < len(a); ix++ {
		ret[ix] = a[ix].String()
	}
	return ret
}

// matchKeys returns true iff a and b hold the same values, in any order.
func matchKeys(a, b []*Value) bool {
	ass := toStringSlice(a)
	bss := toStringSlice(a)
	sort.Strings(ass)
	sort.Strings(bss)
	return strings.Join(ass, "") == strings.Join(bss, "")
}

// matchMapString returns true iff a and b are equivalent string representations
// of a map, dealing with entries in different orders.
func matchMapString(a, b string) bool {
	atypeval := strings.SplitN(a, "{", 2)
	btypeval := strings.SplitN(b, "{", 2)
	if len(atypeval) != 2 || len(btypeval) != 2 || atypeval[0] != btypeval[0] {
		return false
	}

	a = atypeval[1]
	b = btypeval[1]

	n := len(a)
	if n != len(b) || n < 1 || a[n-1] != '}' || b[n-1] != '}' {
		return false
	}
	asplit := strings.Split(a[:n-1], ", ")
	bsplit := strings.Split(b[:n-1], ", ")
	sort.Strings(asplit)
	sort.Strings(bsplit)
	return strings.Join(asplit, "") == strings.Join(bsplit, "")
}

func assignSet(t *testing.T, x *Value) {
	if x.Kind() == Set {
		k1, k2, k3 := key1, key2, key3
		setstr1 := `set[struct{I int64;S string}]{{I: 1, S: "A"}, {I: 2, S: "B"}}`
		setstr2 := `set[struct{I int64;S string}]{{I: 2, S: "B"}}`
		if x.Type().Key() == StringType {
			k1, k2, k3 = strA, strB, strC
			setstr1, setstr2 = `set[string]{"A", "B"}`, `set[string]{"B"}`
		}

		if got, want := x.Keys(), []*Value{}; !matchKeys(got, want) {
			t.Errorf(`Set Keys got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k1), false; got != want {
			t.Errorf(`Set ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), false; got != want {
			t.Errorf(`Set ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Set ContainsKey k3 got %v, want %v`, got, want)
		}
		x.AssignSetKey(k1)
		x.AssignSetKey(k2)
		if got, want := x.Keys(), []*Value{k1, k2}; !matchKeys(got, want) {
			t.Errorf(`Set Keys got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k1), true; got != want {
			t.Errorf(`Set ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), true; got != want {
			t.Errorf(`Set ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Set ContainsKey k3 got %v, want %v`, got, want)
		}
		if got, want := x.String(), setstr1; !matchMapString(got, want) {
			t.Errorf(`Set String got %v, want %v`, got, want)
		}
		x.DeleteSetKey(k1)
		if got, want := x.Keys(), []*Value{k2}; !matchKeys(got, want) {
			t.Errorf(`Set Keys got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k1), false; got != want {
			t.Errorf(`Set ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), true; got != want {
			t.Errorf(`Set ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Set ContainsKey k3 got %v, want %v`, got, want)
		}
		if got, want := x.String(), setstr2; !matchMapString(got, want) {
			t.Errorf(`Set String got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.AssignSetKey(nil) })
		ExpectMismatchedKind(t, func() { x.DeleteSetKey(nil) })
		if x.Kind() != Map {
			// Keys and ContainsKey are allowed for Set and Map
			ExpectMismatchedKind(t, func() { x.Keys() })
			ExpectMismatchedKind(t, func() { x.ContainsKey(nil) })
		}
		if x.Kind() != Array && x.Kind() != List && x.Kind() != Map {
			// Len is allowed for Array, List, Set and Map
			ExpectMismatchedKind(t, func() { x.Len() })
		}
	}
}

func assignMap(t *testing.T, x *Value) {
	if x.Kind() == Map {
		k1, k2, k3 := key1, key2, key3
		v1, v2 := int1, int2
		mapstr1 := `map[struct{I int64;S string}]int64{{I: 1, S: "A"}: 1, {I: 2, S: "B"}: 2}`
		mapstr2 := `map[struct{I int64;S string}]int64{{I: 2, S: "B"}: 2}`
		if x.Type().Key() == StringType {
			k1, k2, k3 = strA, strB, strC
			mapstr1 = `map[string]int64{"A": 1, "B": 2}`
			mapstr2 = `map[string]int64{"B": 2}`
		}

		if got, want := x.Keys(), []*Value{}; !matchKeys(got, want) {
			t.Errorf(`Map Keys got %v, want %v`, got, want)
		}
		if got := x.MapIndex(k1); got != nil {
			t.Errorf(`Map MapIndex k1 got %v, want nil`, got)
		}
		if got := x.MapIndex(k2); got != nil {
			t.Errorf(`Map MapIndex k2 got %v, want nil`, got)
		}
		if got := x.MapIndex(k3); got != nil {
			t.Errorf(`Map MapIndex k3 got %v, want nil`, got)
		}
		if got, want := x.ContainsKey(k1), false; got != want {
			t.Errorf(`Map ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), false; got != want {
			t.Errorf(`Map ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Map ContainsKey k3 got %v, want %v`, got, want)
		}
		x.AssignMapIndex(k1, v1)
		x.AssignMapIndex(k2, v2)
		if got, want := x.Keys(), []*Value{k1, k2}; !matchKeys(got, want) {
			t.Errorf(`Map Keys got %v, want %v`, got, want)
		}
		if got, want := x.MapIndex(k1), v1; !EqualValue(got, want) {
			t.Errorf(`Map MapIndex k1 got %v, want %v`, got, want)
		}
		if got, want := x.MapIndex(k2), v2; !EqualValue(got, want) {
			t.Errorf(`Map MapIndex k2 got %v, want %v`, got, want)
		}
		if got := x.MapIndex(k3); got != nil {
			t.Errorf(`Map MapIndex k3 got %v, want nil`, got)
		}
		if got, want := x.ContainsKey(k1), true; got != want {
			t.Errorf(`Map ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), true; got != want {
			t.Errorf(`Map ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Map ContainsKey k3 got %v, want %v`, got, want)
		}
		if got, want := x.String(), mapstr1; !matchMapString(got, want) {
			t.Errorf(`Map string got %v, want %v`, got, want)
		}
		x.AssignMapIndex(k1, nil)
		if got, want := x.Keys(), []*Value{k1, k2}; !matchKeys(got, want) {
			t.Errorf(`Map Keys got %v, want %v`, got, want)
		}
		if got := x.MapIndex(k1); got != nil {
			t.Errorf(`Map MapIndex k1 got %v, want nil`, got)
		}
		if got, want := x.MapIndex(k2), v2; !EqualValue(got, want) {
			t.Errorf(`Map MapIndex k2 got %v, want %v`, got, want)
		}
		if got := x.MapIndex(k3); got != nil {
			t.Errorf(`Map MapIndex k3 got %v, want nil`, got)
		}
		if got, want := x.ContainsKey(k1), false; got != want {
			t.Errorf(`Map ContainsKey k1 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k2), true; got != want {
			t.Errorf(`Map ContainsKey k2 got %v, want %v`, got, want)
		}
		if got, want := x.ContainsKey(k3), false; got != want {
			t.Errorf(`Map ContainsKey k3 got %v, want %v`, got, want)
		}
		if got, want := x.String(), mapstr2; !matchMapString(got, want) {
			t.Errorf(`Map string got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.MapIndex(nil) })
		ExpectMismatchedKind(t, func() { x.AssignMapIndex(nil, nil) })
		if x.Kind() != Set {
			// Keys and ContainsKey are allowed for Set and Map
			ExpectMismatchedKind(t, func() { x.Keys() })
			ExpectMismatchedKind(t, func() { x.ContainsKey(nil) })
		}
		if x.Kind() != Array && x.Kind() != List && x.Kind() != Set {
			// Len is allowed for Array, List, Set and Map
			ExpectMismatchedKind(t, func() { x.Len() })
		}
	}
}

func assignStruct(t *testing.T, x *Value) {
	if x.Kind() == Struct {
		x.StructField(0).AssignInt(1)
		if x.IsZero() {
			t.Errorf(`Struct assign index 0 is zero`)
		}
		if x.StructField(0) != x.StructFieldByName("A") {
			t.Errorf(`struct{A int64;B string;C bool} does not have matching values at index 0 and field name A`)
		}
		if got, want := x.String(), `struct{A int64;B string;C bool}{A: 1, B: "", C: false}`; got != want {
			t.Errorf(`Struct assign index 0 got %v, want %v`, got, want)
		}
		x.StructField(1).AssignString("a")
		if x.IsZero() {
			t.Errorf(`Struct assign index 1 is zero`)
		}
		if x.StructField(1) != x.StructFieldByName("B") {
			t.Errorf(`struct{A int64;B string;C bool} does not have matching values at index 1 and field name B`)
		}
		if got, want := x.String(), `struct{A int64;B string;C bool}{A: 1, B: "a", C: false}`; got != want {
			t.Errorf(`Struct assign index 1 got %v, want %v`, got, want)
		}
		if value := x.StructFieldByName("NotAStructField"); value != nil {
			t.Errorf(`struct{A int64;B string;C bool} had value %v for field name NotAStructField`, value)
		}
		y := CopyValue(x)
		y.StructField(2).AssignBool(false)
		if !EqualValue(x, y) {
			t.Errorf(`Struct !equal %v and %v`, x, y)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.StructField(0) })
		ExpectMismatchedKind(t, func() { x.StructFieldByName("A") })
	}
}

func assignUnion(t *testing.T, x *Value) {
	if x.Kind() == Union {
		goti, gotv := x.UnionField()
		if got, want := goti, 0; got != want {
			t.Errorf(`Union zero value got index %v, want %v`, got, want)
		}
		if got, want := gotv, Int64Value(0); !EqualValue(got, want) {
			t.Errorf(`Union zero value got value %v, want %v`, got, want)
		}
		x.AssignUnionField(1, strA)
		goti, gotv = x.UnionField()
		if got, want := goti, 1; got != want {
			t.Errorf(`Union assign B value got index %v, want %v`, got, want)
		}
		if got, want := gotv, strA; !EqualValue(got, want) {
			t.Errorf(`Union assign B value got value %v, want %v`, got, want)
		}
		if x.IsZero() {
			t.Errorf(`Union assign B value is zero`)
		}
		if got, want := x.String(), `union{A int64;B string;C bool}{B: "A"}`; got != want {
			t.Errorf(`Union assign B value got %v, want %v`, got, want)
		}
	} else {
		ExpectMismatchedKind(t, func() { x.UnionField() })
		ExpectMismatchedKind(t, func() { x.AssignUnionField(0, nil) })
	}
}

func assignAny(t *testing.T, x *Value) {
	if x.Kind() == Any {
		if got := x.Elem(); got != nil {
			t.Errorf(`Any zero value got %v, want nil`, got)
		}
		x.Assign(int1)
		if got, want := x.Elem(), int1; !EqualValue(got, want) {
			t.Errorf(`Any assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), "any(int64(1))"; got != want {
			t.Errorf(`Any assign string got %v, want %v`, got, want)
		}
		x.Assign(strA)
		if got, want := x.Elem(), strA; !EqualValue(got, want) {
			t.Errorf(`Any assign value got %v, want %v`, got, want)
		}
		if got, want := x.String(), `any("A")`; got != want {
			t.Errorf(`Any assign string got %v, want %v`, got, want)
		}
	} else if x.Kind() != Optional {
		ExpectMismatchedKind(t, func() { x.Elem() })
	}
}