internal/fields/fields_test.go - gocloud - Git at Google

 // Copyright 2016 Google LLC
 //
 // 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 fields

 import (
 	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
 	"testing"
 	"time"

 	"cloud.google.com/go/internal/testutil"
 	"github.com/google/go-cmp/cmp"
 )

 type embed1 struct {
 	Em1    int
 	Dup    int // annihilates with embed2.Dup
 	Shadow int
 	embed3
 }

 type embed2 struct {
 	Dup int
 	embed3
 	embed4
 }

 type embed3 struct {
 	Em3 int // annihilated because embed3 is in both embed1 and embed2
 	embed5
 }

 type embed4 struct {
 	Em4     int
 	Dup     int // annihilation of Dup in embed1, embed2 hides this Dup
 	*embed1     // ignored because it occurs at a higher level
 }

 type embed5 struct {
 	x int
 }

 type Anonymous int

 type S1 struct {
 	Exported   int
 	unexported int
 	Shadow     int // shadows S1.Shadow
 	embed1
 	*embed2
 	Anonymous
 }

 type Time struct {
 	time.Time
 }

 var intType = reflect.TypeOf(int(0))

 func field(name string, tval interface{}, index ...int) *Field {
 	return &Field{
 		Name:      name,
 		Type:      reflect.TypeOf(tval),
 		Index:     index,
 		ParsedTag: []string(nil),
 	}
 }

 func tfield(name string, tval interface{}, index ...int) *Field {
 	return &Field{
 		Name:        name,
 		Type:        reflect.TypeOf(tval),
 		Index:       index,
 		NameFromTag: true,
 		ParsedTag:   []string(nil),
 	}
 }

 func TestFieldsNoTags(t *testing.T) {
 	c := NewCache(nil, nil, nil)
 	got, err := c.Fields(reflect.TypeOf(S1{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	want := []*Field{
 		field("Exported", int(0), 0),
 		field("Shadow", int(0), 2),
 		field("Em1", int(0), 3, 0),
 		field("Em4", int(0), 4, 2, 0),
 		field("Anonymous", Anonymous(0), 5),
 	}
 	for _, f := range want {
 		f.ParsedTag = nil
 	}
 	if msg, ok := compareFields(got, want); !ok {
 		t.Error(msg)
 	}
 }

 func TestAgainstJSONEncodingNoTags(t *testing.T) {
 	// Demonstrates that this package produces the same set of fields as encoding/json.
 	s1 := S1{
 		Exported:   1,
 		unexported: 2,
 		Shadow:     3,
 		embed1: embed1{
 			Em1:    4,
 			Dup:    5,
 			Shadow: 6,
 			embed3: embed3{
 				Em3:    7,
 				embed5: embed5{x: 8},
 			},
 		},
 		embed2: &embed2{
 			Dup: 9,
 			embed3: embed3{
 				Em3:    10,
 				embed5: embed5{x: 11},
 			},
 			embed4: embed4{
 				Em4:    12,
 				Dup:    13,
 				embed1: &embed1{Em1: 14},
 			},
 		},
 		Anonymous: Anonymous(15),
 	}
 	var want S1
 	want.embed2 = &embed2{} // need this because reflection won't create it
 	jsonRoundTrip(t, s1, &want)
 	var got S1
 	got.embed2 = &embed2{}
 	fields, err := NewCache(nil, nil, nil).Fields(reflect.TypeOf(got))
 	if err != nil {
 		t.Fatal(err)
 	}
 	setFields(fields, &got, s1)
 	if !testutil.Equal(got, want,
 		cmp.AllowUnexported(S1{}, embed1{}, embed2{}, embed3{}, embed4{}, embed5{})) {
 		t.Errorf("got\n%+v\nwant\n%+v", got, want)
 	}
 }

 // Tests use of LeafTypes parameter to NewCache
 func TestAgainstJSONEncodingEmbeddedTime(t *testing.T) {
 	timeLeafFn := func(t reflect.Type) bool {
 		return t == reflect.TypeOf(time.Time{})
 	}
 	// Demonstrates that this package can produce the same set of
 	// fields as encoding/json for a struct with an embedded time.Time.
 	now := time.Now().UTC()
 	myt := Time{
 		now,
 	}
 	var want Time
 	jsonRoundTrip(t, myt, &want)
 	var got Time
 	fields, err := NewCache(nil, nil, timeLeafFn).Fields(reflect.TypeOf(got))
 	if err != nil {
 		t.Fatal(err)
 	}
 	setFields(fields, &got, myt)
 	if !testutil.Equal(got, want) {
 		t.Errorf("got\n%+v\nwant\n%+v", got, want)
 	}
 }

 type S2 struct {
 	NoTag     int
 	XXX       int           `json:"tag"` // tag name takes precedence
 	Anonymous `json:"anon"` // anonymous non-structs also get their name from the tag
 	Embed     `json:"em"`   // embedded structs with tags become fields
 	Tag       int
 	YYY       int `json:"Tag"` // tag takes precedence over untagged field of the same name
 	Empty     int `json:""`    // empty tag is noop
 	tEmbed1
 	tEmbed2
 }

 type Embed struct {
 	Em int
 }

 type tEmbed1 struct {
 	Dup int
 	X   int `json:"Dup2"`
 }

 type tEmbed2 struct {
 	Y int `json:"Dup"`  // takes precedence over tEmbed1.Dup because it is tagged
 	Z int `json:"Dup2"` // same name as tEmbed1.X and both tagged, so ignored
 }

 func jsonTagParser(t reflect.StructTag) (name string, keep bool, other interface{}, err error) {
 	return ParseStandardTag("json", t)
 }

 func validateFunc(t reflect.Type) (err error) {
 	if t.Kind() != reflect.Struct {
 		return errors.New("non-struct type used")
 	}

 	for i := 0; i < t.NumField(); i++ {
 		if t.Field(i).Type.Kind() == reflect.Slice {
 			return fmt.Errorf("slice field found at field %s on struct %s", t.Field(i).Name, t.Name())
 		}
 	}

 	return nil
 }

 func TestFieldsWithTags(t *testing.T) {
 	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S2{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	want := []*Field{
 		field("NoTag", int(0), 0),
 		tfield("tag", int(0), 1),
 		tfield("anon", Anonymous(0), 2),
 		tfield("em", Embed{}, 4),
 		tfield("Tag", int(0), 6),
 		field("Empty", int(0), 7),
 		tfield("Dup", int(0), 8, 0),
 	}
 	if msg, ok := compareFields(got, want); !ok {
 		t.Error(msg)
 	}
 }

 func TestAgainstJSONEncodingWithTags(t *testing.T) {
 	// Demonstrates that this package produces the same set of fields as encoding/json.
 	s2 := S2{
 		NoTag:     1,
 		XXX:       2,
 		Anonymous: 3,
 		Embed: Embed{
 			Em: 4,
 		},
 		tEmbed1: tEmbed1{
 			Dup: 5,
 			X:   6,
 		},
 		tEmbed2: tEmbed2{
 			Y: 7,
 			Z: 8,
 		},
 	}
 	var want S2
 	jsonRoundTrip(t, s2, &want)
 	var got S2
 	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(got))
 	if err != nil {
 		t.Fatal(err)
 	}
 	setFields(fields, &got, s2)
 	if !testutil.Equal(got, want, cmp.AllowUnexported(S2{})) {
 		t.Errorf("got\n%+v\nwant\n%+v", got, want)
 	}
 }

 func TestUnexportedAnonymousNonStruct(t *testing.T) {
 	// An unexported anonymous non-struct field should not be recorded.
 	// This is currently a bug in encoding/json.
 	// https://github.com/golang/go/issues/18009
 	type S struct{}

 	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(got) != 0 {
 		t.Errorf("got %d fields, want 0", len(got))
 	}
 }

 func TestUnexportedAnonymousStruct(t *testing.T) {
 	// An unexported anonymous struct with a tag is ignored.
 	// This is currently a bug in encoding/json.
 	// https://github.com/golang/go/issues/18009
 	type (
 		s1 struct{ X int }
 		S2 struct {
 			s1 `json:"Y"`
 		}
 	)
 	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S2{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(got) != 0 {
 		t.Errorf("got %d fields, want 0", len(got))
 	}
 }

 func TestDominantField(t *testing.T) {
 	// With fields sorted by index length and then by tag presence,
 	// the dominant field is always the first. Make sure all error
 	// cases are caught.
 	for _, test := range []struct {
 		fields []Field
 		wantOK bool
 	}{
 		// A single field is OK.
 		{[]Field{{Index: []int{0}}}, true},
 		{[]Field{{Index: []int{0}, NameFromTag: true}}, true},
 		// A single field at top level is OK.
 		{[]Field{{Index: []int{0}}, {Index: []int{1, 0}}}, true},
 		{[]Field{{Index: []int{0}}, {Index: []int{1, 0}, NameFromTag: true}}, true},
 		{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1, 0}, NameFromTag: true}}, true},
 		// A single tagged field is OK.
 		{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1}}}, true},
 		// Two untagged fields at the same level is an error.
 		{[]Field{{Index: []int{0}}, {Index: []int{1}}}, false},
 		// Two tagged fields at the same level is an error.
 		{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1}, NameFromTag: true}}, false},
 	} {
 		_, gotOK := dominantField(test.fields)
 		if gotOK != test.wantOK {
 			t.Errorf("%v: got %t, want %t", test.fields, gotOK, test.wantOK)
 		}
 	}
 }

 func TestIgnore(t *testing.T) {
 	type S struct {
 		X int `json:"-"`
 	}
 	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(got) != 0 {
 		t.Errorf("got %d fields, want 0", len(got))
 	}
 }

 func TestParsedTag(t *testing.T) {
 	type S struct {
 		X int `json:"name,omitempty"`
 	}
 	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	want := []*Field{
 		{Name: "name", NameFromTag: true, Type: intType,
 			Index: []int{0}, ParsedTag: []string{"omitempty"}},
 	}
 	if msg, ok := compareFields(got, want); !ok {
 		t.Error(msg)
 	}
 }

 func TestValidateFunc(t *testing.T) {
 	type MyInvalidStruct struct {
 		A string
 		B []int
 	}

 	_, err := NewCache(nil, validateFunc, nil).Fields(reflect.TypeOf(MyInvalidStruct{}))
 	if err == nil {
 		t.Fatal("expected error, got nil")
 	}

 	type MyValidStruct struct {
 		A string
 		B int
 	}
 	_, err = NewCache(nil, validateFunc, nil).Fields(reflect.TypeOf(MyValidStruct{}))
 	if err != nil {
 		t.Fatalf("expected nil, got error: %s\n", err)
 	}
 }

 func compareFields(got []Field, want []*Field) (msg string, ok bool) {
 	if len(got) != len(want) {
 		return fmt.Sprintf("got %d fields, want %d", len(got), len(want)), false
 	}
 	for i, g := range got {
 		w := *want[i]
 		if !fieldsEqual(&g, &w) {
 			return fmt.Sprintf("got\n%+v\nwant\n%+v", g, w), false
 		}
 	}
 	return "", true
 }

 // Need this because Field contains a function, which cannot be compared even
 // by testutil.Equal.
 func fieldsEqual(f1, f2 *Field) bool {
 	if f1 == nil || f2 == nil {
 		return f1 == f2
 	}
 	return f1.Name == f2.Name &&
 		f1.NameFromTag == f2.NameFromTag &&
 		f1.Type == f2.Type &&
 		testutil.Equal(f1.ParsedTag, f2.ParsedTag)
 }

 // Set the fields of dst from those of src.
 // dst must be a pointer to a struct value.
 // src must be a struct value.
 func setFields(fields []Field, dst, src interface{}) {
 	vsrc := reflect.ValueOf(src)
 	vdst := reflect.ValueOf(dst).Elem()
 	for _, f := range fields {
 		fdst := vdst.FieldByIndex(f.Index)
 		fsrc := vsrc.FieldByIndex(f.Index)
 		fdst.Set(fsrc)
 	}
 }

 func jsonRoundTrip(t *testing.T, in, out interface{}) {
 	bytes, err := json.Marshal(in)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if err := json.Unmarshal(bytes, out); err != nil {
 		t.Fatal(err)
 	}
 }

 type S3 struct {
 	S4
 	Abc        int
 	AbC        int
 	Tag        int
 	X          int `json:"Tag"`
 	unexported int
 }

 type S4 struct {
 	ABc int
 	Y   int `json:"Abc"` // ignored because of top-level Abc
 }

 func TestMatchingField(t *testing.T) {
 	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S3{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, test := range []struct {
 		name string
 		want *Field
 	}{
 		// Exact match wins.
 		{"Abc", field("Abc", int(0), 1)},
 		{"AbC", field("AbC", int(0), 2)},
 		{"ABc", field("ABc", int(0), 0, 0)},
 		// If there are multiple matches but no exact match or tag,
 		// the first field wins, lexicographically by index.
 		// Here, "ABc" is at a deeper embedding level, but since S4 appears
 		// first in S3, its index precedes the other fields of S3.
 		{"abc", field("ABc", int(0), 0, 0)},
 		// Tag name takes precedence over untagged field of the same name.
 		{"Tag", tfield("Tag", int(0), 4)},
 		// Unexported fields disappear.
 		{"unexported", nil},
 		// Untagged embedded structs disappear.
 		{"S4", nil},
 	} {
 		if got := fields.Match(test.name); !fieldsEqual(got, test.want) {
 			t.Errorf("match %q:\ngot  %+v\nwant %+v", test.name, got, test.want)
 		}
 	}
 }

 func TestAgainstJSONMatchingField(t *testing.T) {
 	s3 := S3{
 		S4:         S4{ABc: 1, Y: 2},
 		Abc:        3,
 		AbC:        4,
 		Tag:        5,
 		X:          6,
 		unexported: 7,
 	}
 	var want S3
 	jsonRoundTrip(t, s3, &want)
 	v := reflect.ValueOf(want)
 	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S3{}))
 	if err != nil {
 		t.Fatal(err)
 	}
 	for _, test := range []struct {
 		name string
 		got  int
 	}{
 		{"Abc", 3},
 		{"AbC", 4},
 		{"ABc", 1},
 		{"abc", 1},
 		{"Tag", 6},
 	} {
 		f := fields.Match(test.name)
 		if f == nil {
 			t.Fatalf("%s: no match", test.name)
 		}
 		w := v.FieldByIndex(f.Index).Interface()
 		if test.got != w {
 			t.Errorf("%s: got %d, want %d", test.name, test.got, w)
 		}
 	}
 }

 func TestTagErrors(t *testing.T) {
 	called := false
 	c := NewCache(func(t reflect.StructTag) (string, bool, interface{}, error) {
 		called = true
 		s := t.Get("f")
 		if s == "bad" {
 			return "", false, nil, errors.New("error")
 		}
 		return s, true, nil, nil
 	}, nil, nil)

 	type T struct {
 		X int `f:"ok"`
 		Y int `f:"bad"`
 	}

 	_, err := c.Fields(reflect.TypeOf(T{}))
 	if !called {
 		t.Fatal("tag parser not called")
 	}
 	if err == nil {
 		t.Error("want error, got nil")
 	}
 	// Second time, we should cache the error.
 	called = false
 	_, err = c.Fields(reflect.TypeOf(T{}))
 	if called {
 		t.Fatal("tag parser called on second time")
 	}
 	if err == nil {
 		t.Error("want error, got nil")
 	}
 }
	// Copyright 2016 Google LLC
	//
	// 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 fields

	import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"testing"
	"time"

	"cloud.google.com/go/internal/testutil"
	"github.com/google/go-cmp/cmp"
	)

	type embed1 struct {
	Em1 int
	Dup int // annihilates with embed2.Dup
	Shadow int
	embed3
	}

	type embed2 struct {
	Dup int
	embed3
	embed4
	}

	type embed3 struct {
	Em3 int // annihilated because embed3 is in both embed1 and embed2
	embed5
	}

	type embed4 struct {
	Em4 int
	Dup int // annihilation of Dup in embed1, embed2 hides this Dup
	*embed1 // ignored because it occurs at a higher level
	}

	type embed5 struct {
	x int
	}

	type Anonymous int

	type S1 struct {
	Exported int
	unexported int
	Shadow int // shadows S1.Shadow
	embed1
	*embed2
	Anonymous
	}

	type Time struct {
	time.Time
	}

	var intType = reflect.TypeOf(int(0))

	func field(name string, tval interface{}, index ...int) *Field {
	return &Field{
	Name: name,
	Type: reflect.TypeOf(tval),
	Index: index,
	ParsedTag: []string(nil),
	}
	}

	func tfield(name string, tval interface{}, index ...int) *Field {
	return &Field{
	Name: name,
	Type: reflect.TypeOf(tval),
	Index: index,
	NameFromTag: true,
	ParsedTag: []string(nil),
	}
	}

	func TestFieldsNoTags(t *testing.T) {
	c := NewCache(nil, nil, nil)
	got, err := c.Fields(reflect.TypeOf(S1{}))
	if err != nil {
	t.Fatal(err)
	}
	want := []*Field{
	field("Exported", int(0), 0),
	field("Shadow", int(0), 2),
	field("Em1", int(0), 3, 0),
	field("Em4", int(0), 4, 2, 0),
	field("Anonymous", Anonymous(0), 5),
	}
	for _, f := range want {
	f.ParsedTag = nil
	}
	if msg, ok := compareFields(got, want); !ok {
	t.Error(msg)
	}
	}

	func TestAgainstJSONEncodingNoTags(t *testing.T) {
	// Demonstrates that this package produces the same set of fields as encoding/json.
	s1 := S1{
	Exported: 1,
	unexported: 2,
	Shadow: 3,
	embed1: embed1{
	Em1: 4,
	Dup: 5,
	Shadow: 6,
	embed3: embed3{
	Em3: 7,
	embed5: embed5{x: 8},
	},
	},
	embed2: &embed2{
	Dup: 9,
	embed3: embed3{
	Em3: 10,
	embed5: embed5{x: 11},
	},
	embed4: embed4{
	Em4: 12,
	Dup: 13,
	embed1: &embed1{Em1: 14},
	},
	},
	Anonymous: Anonymous(15),
	}
	var want S1
	want.embed2 = &embed2{} // need this because reflection won't create it
	jsonRoundTrip(t, s1, &want)
	var got S1
	got.embed2 = &embed2{}
	fields, err := NewCache(nil, nil, nil).Fields(reflect.TypeOf(got))
	if err != nil {
	t.Fatal(err)
	}
	setFields(fields, &got, s1)
	if !testutil.Equal(got, want,
	cmp.AllowUnexported(S1{}, embed1{}, embed2{}, embed3{}, embed4{}, embed5{})) {
	t.Errorf("got\n%+v\nwant\n%+v", got, want)
	}
	}

	// Tests use of LeafTypes parameter to NewCache
	func TestAgainstJSONEncodingEmbeddedTime(t *testing.T) {
	timeLeafFn := func(t reflect.Type) bool {
	return t == reflect.TypeOf(time.Time{})
	}
	// Demonstrates that this package can produce the same set of
	// fields as encoding/json for a struct with an embedded time.Time.
	now := time.Now().UTC()
	myt := Time{
	now,
	}
	var want Time
	jsonRoundTrip(t, myt, &want)
	var got Time
	fields, err := NewCache(nil, nil, timeLeafFn).Fields(reflect.TypeOf(got))
	if err != nil {
	t.Fatal(err)
	}
	setFields(fields, &got, myt)
	if !testutil.Equal(got, want) {
	t.Errorf("got\n%+v\nwant\n%+v", got, want)
	}
	}

	type S2 struct {
	NoTag int
	XXX int `json:"tag"` // tag name takes precedence
	Anonymous `json:"anon"` // anonymous non-structs also get their name from the tag
	Embed `json:"em"` // embedded structs with tags become fields
	Tag int
	YYY int `json:"Tag"` // tag takes precedence over untagged field of the same name
	Empty int `json:""` // empty tag is noop
	tEmbed1
	tEmbed2
	}

	type Embed struct {
	Em int
	}

	type tEmbed1 struct {
	Dup int
	X int `json:"Dup2"`
	}

	type tEmbed2 struct {
	Y int `json:"Dup"` // takes precedence over tEmbed1.Dup because it is tagged
	Z int `json:"Dup2"` // same name as tEmbed1.X and both tagged, so ignored
	}

	func jsonTagParser(t reflect.StructTag) (name string, keep bool, other interface{}, err error) {
	return ParseStandardTag("json", t)
	}

	func validateFunc(t reflect.Type) (err error) {
	if t.Kind() != reflect.Struct {
	return errors.New("non-struct type used")
	}

	for i := 0; i < t.NumField(); i++ {
	if t.Field(i).Type.Kind() == reflect.Slice {
	return fmt.Errorf("slice field found at field %s on struct %s", t.Field(i).Name, t.Name())
	}
	}

	return nil
	}

	func TestFieldsWithTags(t *testing.T) {
	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S2{}))
	if err != nil {
	t.Fatal(err)
	}
	want := []*Field{
	field("NoTag", int(0), 0),
	tfield("tag", int(0), 1),
	tfield("anon", Anonymous(0), 2),
	tfield("em", Embed{}, 4),
	tfield("Tag", int(0), 6),
	field("Empty", int(0), 7),
	tfield("Dup", int(0), 8, 0),
	}
	if msg, ok := compareFields(got, want); !ok {
	t.Error(msg)
	}
	}

	func TestAgainstJSONEncodingWithTags(t *testing.T) {
	// Demonstrates that this package produces the same set of fields as encoding/json.
	s2 := S2{
	NoTag: 1,
	XXX: 2,
	Anonymous: 3,
	Embed: Embed{
	Em: 4,
	},
	tEmbed1: tEmbed1{
	Dup: 5,
	X: 6,
	},
	tEmbed2: tEmbed2{
	Y: 7,
	Z: 8,
	},
	}
	var want S2
	jsonRoundTrip(t, s2, &want)
	var got S2
	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(got))
	if err != nil {
	t.Fatal(err)
	}
	setFields(fields, &got, s2)
	if !testutil.Equal(got, want, cmp.AllowUnexported(S2{})) {
	t.Errorf("got\n%+v\nwant\n%+v", got, want)
	}
	}

	func TestUnexportedAnonymousNonStruct(t *testing.T) {
	// An unexported anonymous non-struct field should not be recorded.
	// This is currently a bug in encoding/json.
	// https://github.com/golang/go/issues/18009
	type S struct{}

	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
	if err != nil {
	t.Fatal(err)
	}
	if len(got) != 0 {
	t.Errorf("got %d fields, want 0", len(got))
	}
	}

	func TestUnexportedAnonymousStruct(t *testing.T) {
	// An unexported anonymous struct with a tag is ignored.
	// This is currently a bug in encoding/json.
	// https://github.com/golang/go/issues/18009
	type (
	s1 struct{ X int }
	S2 struct {
	s1 `json:"Y"`
	}
	)
	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S2{}))
	if err != nil {
	t.Fatal(err)
	}
	if len(got) != 0 {
	t.Errorf("got %d fields, want 0", len(got))
	}
	}

	func TestDominantField(t *testing.T) {
	// With fields sorted by index length and then by tag presence,
	// the dominant field is always the first. Make sure all error
	// cases are caught.
	for _, test := range []struct {
	fields []Field
	wantOK bool
	}{
	// A single field is OK.
	{[]Field{{Index: []int{0}}}, true},
	{[]Field{{Index: []int{0}, NameFromTag: true}}, true},
	// A single field at top level is OK.
	{[]Field{{Index: []int{0}}, {Index: []int{1, 0}}}, true},
	{[]Field{{Index: []int{0}}, {Index: []int{1, 0}, NameFromTag: true}}, true},
	{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1, 0}, NameFromTag: true}}, true},
	// A single tagged field is OK.
	{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1}}}, true},
	// Two untagged fields at the same level is an error.
	{[]Field{{Index: []int{0}}, {Index: []int{1}}}, false},
	// Two tagged fields at the same level is an error.
	{[]Field{{Index: []int{0}, NameFromTag: true}, {Index: []int{1}, NameFromTag: true}}, false},
	} {
	_, gotOK := dominantField(test.fields)
	if gotOK != test.wantOK {
	t.Errorf("%v: got %t, want %t", test.fields, gotOK, test.wantOK)
	}
	}
	}

	func TestIgnore(t *testing.T) {
	type S struct {
	X int `json:"-"`
	}
	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
	if err != nil {
	t.Fatal(err)
	}
	if len(got) != 0 {
	t.Errorf("got %d fields, want 0", len(got))
	}
	}

	func TestParsedTag(t *testing.T) {
	type S struct {
	X int `json:"name,omitempty"`
	}
	got, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S{}))
	if err != nil {
	t.Fatal(err)
	}
	want := []*Field{
	{Name: "name", NameFromTag: true, Type: intType,
	Index: []int{0}, ParsedTag: []string{"omitempty"}},
	}
	if msg, ok := compareFields(got, want); !ok {
	t.Error(msg)
	}
	}

	func TestValidateFunc(t *testing.T) {
	type MyInvalidStruct struct {
	A string
	B []int
	}

	_, err := NewCache(nil, validateFunc, nil).Fields(reflect.TypeOf(MyInvalidStruct{}))
	if err == nil {
	t.Fatal("expected error, got nil")
	}

	type MyValidStruct struct {
	A string
	B int
	}
	_, err = NewCache(nil, validateFunc, nil).Fields(reflect.TypeOf(MyValidStruct{}))
	if err != nil {
	t.Fatalf("expected nil, got error: %s\n", err)
	}
	}

	func compareFields(got []Field, want []*Field) (msg string, ok bool) {
	if len(got) != len(want) {
	return fmt.Sprintf("got %d fields, want %d", len(got), len(want)), false
	}
	for i, g := range got {
	w := *want[i]
	if !fieldsEqual(&g, &w) {
	return fmt.Sprintf("got\n%+v\nwant\n%+v", g, w), false
	}
	}
	return "", true
	}

	// Need this because Field contains a function, which cannot be compared even
	// by testutil.Equal.
	func fieldsEqual(f1, f2 *Field) bool {
	if f1 == nil \|\| f2 == nil {
	return f1 == f2
	}
	return f1.Name == f2.Name &&
	f1.NameFromTag == f2.NameFromTag &&
	f1.Type == f2.Type &&
	testutil.Equal(f1.ParsedTag, f2.ParsedTag)
	}

	// Set the fields of dst from those of src.
	// dst must be a pointer to a struct value.
	// src must be a struct value.
	func setFields(fields []Field, dst, src interface{}) {
	vsrc := reflect.ValueOf(src)
	vdst := reflect.ValueOf(dst).Elem()
	for _, f := range fields {
	fdst := vdst.FieldByIndex(f.Index)
	fsrc := vsrc.FieldByIndex(f.Index)
	fdst.Set(fsrc)
	}
	}

	func jsonRoundTrip(t *testing.T, in, out interface{}) {
	bytes, err := json.Marshal(in)
	if err != nil {
	t.Fatal(err)
	}
	if err := json.Unmarshal(bytes, out); err != nil {
	t.Fatal(err)
	}
	}

	type S3 struct {
	S4
	Abc int
	AbC int
	Tag int
	X int `json:"Tag"`
	unexported int
	}

	type S4 struct {
	ABc int
	Y int `json:"Abc"` // ignored because of top-level Abc
	}

	func TestMatchingField(t *testing.T) {
	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S3{}))
	if err != nil {
	t.Fatal(err)
	}
	for _, test := range []struct {
	name string
	want *Field
	}{
	// Exact match wins.
	{"Abc", field("Abc", int(0), 1)},
	{"AbC", field("AbC", int(0), 2)},
	{"ABc", field("ABc", int(0), 0, 0)},
	// If there are multiple matches but no exact match or tag,
	// the first field wins, lexicographically by index.
	// Here, "ABc" is at a deeper embedding level, but since S4 appears
	// first in S3, its index precedes the other fields of S3.
	{"abc", field("ABc", int(0), 0, 0)},
	// Tag name takes precedence over untagged field of the same name.
	{"Tag", tfield("Tag", int(0), 4)},
	// Unexported fields disappear.
	{"unexported", nil},
	// Untagged embedded structs disappear.
	{"S4", nil},
	} {
	if got := fields.Match(test.name); !fieldsEqual(got, test.want) {
	t.Errorf("match %q:\ngot %+v\nwant %+v", test.name, got, test.want)
	}
	}
	}

	func TestAgainstJSONMatchingField(t *testing.T) {
	s3 := S3{
	S4: S4{ABc: 1, Y: 2},
	Abc: 3,
	AbC: 4,
	Tag: 5,
	X: 6,
	unexported: 7,
	}
	var want S3
	jsonRoundTrip(t, s3, &want)
	v := reflect.ValueOf(want)
	fields, err := NewCache(jsonTagParser, nil, nil).Fields(reflect.TypeOf(S3{}))
	if err != nil {
	t.Fatal(err)
	}
	for _, test := range []struct {
	name string
	got int
	}{
	{"Abc", 3},
	{"AbC", 4},
	{"ABc", 1},
	{"abc", 1},
	{"Tag", 6},
	} {
	f := fields.Match(test.name)
	if f == nil {
	t.Fatalf("%s: no match", test.name)
	}
	w := v.FieldByIndex(f.Index).Interface()
	if test.got != w {
	t.Errorf("%s: got %d, want %d", test.name, test.got, w)
	}
	}
	}

	func TestTagErrors(t *testing.T) {
	called := false
	c := NewCache(func(t reflect.StructTag) (string, bool, interface{}, error) {
	called = true
	s := t.Get("f")
	if s == "bad" {
	return "", false, nil, errors.New("error")
	}
	return s, true, nil, nil
	}, nil, nil)

	type T struct {
	X int `f:"ok"`
	Y int `f:"bad"`
	}

	_, err := c.Fields(reflect.TypeOf(T{}))
	if !called {
	t.Fatal("tag parser not called")
	}
	if err == nil {
	t.Error("want error, got nil")
	}
	// Second time, we should cache the error.
	called = false
	_, err = c.Fields(reflect.TypeOf(T{}))
	if called {
	t.Fatal("tag parser called on second time")
	}
	if err == nil {
	t.Error("want error, got nil")
	}
	}