ostiwe/go-toml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wip making reflection tests pass

Browse Source
This commit is contained in:
Thomas Pelletier
2021-02-19 19:26:46 -05:00
parent 4526154571
commit d24deebee3
3 changed files with 116 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/imported_tests/unmarshal_imported_test.go
+58 -45
View File
@@ -565,13 +565,8 @@ StringPtr = [["Three", "Four"]]
func TestNestedUnmarshal(t *testing.T) {
result := nestedMarshalTestStruct{}
err := toml.Unmarshal(nestedTestToml, &result)
expected := nestedTestData
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(result, expected) {
t.Errorf("Bad nested unmarshal: expected %v, got %v", expected, result)
}
require.NoError(t, err)
assert.Equal(t, nestedTestData, result)
}
type customMarshalerParent struct {
@@ -822,18 +817,13 @@ func TestUnmarshalTabInStringAndQuotedKey(t *testing.T) {
},
}
for i := range testCases {
result := Test{}
err := toml.Unmarshal(testCases[i].input, &result)
if err != nil {
t.Errorf("%s test error:%v", testCases[i].desc, err)
continue
}
if !reflect.DeepEqual(result, testCases[i].expected) {
t.Errorf("%s test error: expected\n-----\n%+v\n-----\ngot\n-----\n%+v\n-----\n",
testCases[i].desc, testCases[i].expected, result)
}
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
result := Test{}
err := toml.Unmarshal(test.input, &result)
require.NoError(t, err)
assert.Equal(t, test.expected, result)
})
}
}
@@ -940,9 +930,7 @@ func TestUnmarshalNonPointer(t *testing.T) {
func TestUnmarshalInvalidPointerKind(t *testing.T) {
a := 1
err := toml.Unmarshal([]byte{}, &a)
if err == nil {
t.Fatal("unmarshal should err when given an invalid pointer type")
}
assert.Error(t, err)
}
type testDuration struct {
@@ -987,6 +975,7 @@ type testBadDuration struct {
var testCamelCaseKeyToml = []byte(`fooBar = 10`)
func TestUnmarshalCamelCaseKey(t *testing.T) {
t.Skipf("don't know if it is a good idea to automatically convert like that yet")
var x struct {
FooBar int
B int
@@ -1004,9 +993,7 @@ func TestUnmarshalCamelCaseKey(t *testing.T) {
func TestUnmarshalNegativeUint(t *testing.T) {
type check struct{ U uint }
err := toml.Unmarshal([]byte("u = -1"), &check{})
if err.Error() != "(1, 1): -1(int64) is negative so does not fit in uint" {
t.Error("expect err:(1, 1): -1(int64) is negative so does not fit in uint but got:", err)
}
assert.Error(t, err)
}
func TestUnmarshalCheckConversionFloatInt(t *testing.T) {
@@ -1016,18 +1003,31 @@ func TestUnmarshalCheckConversionFloatInt(t *testing.T) {
F float64
}
errU := toml.Unmarshal([]byte(`u = 1e300`), &conversionCheck{})
errI := toml.Unmarshal([]byte(`i = 1e300`), &conversionCheck{})
errF := toml.Unmarshal([]byte(`f = 9223372036854775806`), &conversionCheck{})
type TestCase struct {
desc string
input string
}
if errU.Error() != "(1, 1): Can't convert 1e+300(float64) to uint" {
t.Error("expect err:(1, 1): Can't convert 1e+300(float64) to uint but got:", errU)
testCases := []TestCase{
{
desc: "unsigned int",
input: `u = 1e300`,
},
{
desc: "int",
input: `i = 1e300`,
},
{
desc: "float",
input: `f = 9223372036854775806`,
},
}
if errI.Error() != "(1, 1): Can't convert 1e+300(float64) to int" {
t.Error("expect err:(1, 1): Can't convert 1e+300(float64) to int but got:", errI)
}
if errF.Error() != "(1, 1): Can't convert 9223372036854775806(int64) to float64" {
t.Error("expect err:(1, 1): Can't convert 9223372036854775806(int64) to float64 but got:", errF)
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
err := toml.Unmarshal([]byte(test.input), &conversionCheck{})
require.Error(t, err)
})
}
}
@@ -1038,18 +1038,31 @@ func TestUnmarshalOverflow(t *testing.T) {
F32 float32
}
errU8 := toml.Unmarshal([]byte(`u8 = 300`), &overflow{})
errI8 := toml.Unmarshal([]byte(`i8 = 300`), &overflow{})
errF32 := toml.Unmarshal([]byte(`f32 = 1e300`), &overflow{})
type TestCase struct {
desc string
input string
}
if errU8.Error() != "(1, 1): 300(int64) would overflow uint8" {
t.Error("expect err:(1, 1): 300(int64) would overflow uint8 but got:", errU8)
testCases := []TestCase{
{
desc: "byte",
input: `u8 = 300`,
},
{
desc: "int8",
input: `i8 = 300`,
},
{
desc: "float32",
input: `f32 = 1e300`,
},
}
if errI8.Error() != "(1, 1): 300(int64) would overflow int8" {
t.Error("expect err:(1, 1): 300(int64) would overflow int8 but got:", errI8)
}
if errF32.Error() != "(1, 1): 1e+300(float64) would overflow float32" {
t.Error("expect err:(1, 1): 1e+300(float64) would overflow float32 but got:", errF32)
for _, test := range testCases {
t.Run(test.desc, func(t *testing.T) {
err := toml.Unmarshal([]byte(test.input), &overflow{})
require.Error(t, err)
})
}
}
internal/reflectbuild/reflectbuild.go
+54 -6
View File
@@ -47,7 +47,10 @@ func (v valueTarget) set(value reflect.Value) error {
err := isAssignable(rv.Type(), value)
if err != nil {
return err
if !value.Type().ConvertibleTo(rv.Type()) {
return err
}
value = value.Convert(rv.Type())
}
reflect.Value(v).Set(value)
return nil
@@ -74,14 +77,27 @@ func (v mapTarget) set(value reflect.Value) error {
value = value.Elem()
}
err := isAssignable(v.m.Type().Elem(), value)
targetType := v.m.Type().Elem()
value, err := convertAsNeeded(targetType, value)
if err != nil {
return err
}
v.m.SetMapIndex(v.index, value)
return nil
}
func convertAsNeeded(t reflect.Type, v reflect.Value) (reflect.Value, error) {
err := isAssignable(t, v)
if err != nil {
if !v.Type().ConvertibleTo(t) {
return reflect.Value{}, err
}
v = v.Convert(t)
}
return v, nil
}
func (v mapTarget) String() string {
return fmt.Sprintf("mapTarget: '%s'[%s]", v.m, v.index)
}
@@ -259,6 +275,11 @@ func (b *Builder) DigField(s string) error {
// TODO: handle error when map is not indexed by strings
key := reflect.ValueOf(s)
key, err := convertAsNeeded(v.Type().Key(), key)
if err != nil {
return err
}
b.replace(mapTarget{
index: key,
m: v,
@@ -358,6 +379,11 @@ func (b *Builder) SliceLastOrCreate() error {
func (b *Builder) SliceNewElem() error {
t := b.top()
v := t.get()
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
err := checkKind(v.Type(), reflect.Slice)
if err != nil {
return err
@@ -519,7 +545,11 @@ func (b *Builder) EnsureSlice() error {
}
if v.Kind() != reflect.Slice {
return IncorrectKindError{Actual: v.Kind(), Expected: []reflect.Kind{reflect.Slice}}
return IncorrectKindError{
Reason: "EnsureSlice",
Actual: v.Kind(),
Expected: []reflect.Kind{reflect.Slice},
}
}
if v.IsNil() {
@@ -539,10 +569,13 @@ func (b *Builder) EnsureStructOrMap() error {
case reflect.Struct:
case reflect.Map:
if v.IsNil() {
return t.set(reflect.MakeMap(v.Type()))
x := reflect.New(v.Type())
x.Elem().Set(reflect.MakeMap(v.Type()))
return t.set(x)
}
default:
return IncorrectKindError{
Reason: "EnsureStructOrMap",
Actual: v.Kind(),
Expected: []reflect.Kind{reflect.Struct, reflect.Map},
}
@@ -557,6 +590,7 @@ func checkKindInt(rt reflect.Type) error {
}
return IncorrectKindError{
Reason: "CheckKindInt",
Actual: rt.Kind(),
Expected: []reflect.Kind{reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64},
}
@@ -569,6 +603,7 @@ func checkKindFloat(rt reflect.Type) error {
}
return IncorrectKindError{
Reason: "CheckKindFloat",
Actual: rt.Kind(),
Expected: []reflect.Kind{reflect.Float64},
}
@@ -577,6 +612,7 @@ func checkKindFloat(rt reflect.Type) error {
func checkKind(rt reflect.Type, expected reflect.Kind) error {
if rt.Kind() != expected {
return IncorrectKindError{
Reason: "CheckKind",
Actual: rt.Kind(),
Expected: []reflect.Kind{expected},
}
@@ -585,15 +621,27 @@ func checkKind(rt reflect.Type, expected reflect.Kind) error {
}
type IncorrectKindError struct {
Reason string
Actual reflect.Kind
Expected []reflect.Kind
}
func (e IncorrectKindError) Error() string {
b := strings.Builder{}
b.WriteString("incorrect kind: ")
if len(e.Expected) < 2 {
return fmt.Sprintf("incorrect kind: expected '%s', got '%s'", e.Expected[0], e.Actual)
b.WriteString(fmt.Sprintf("expected '%s', got '%s'", e.Expected[0], e.Actual))
} else {
b.WriteString(fmt.Sprintf("expected any of '%s', got '%s'", e.Expected, e.Actual))
}
return fmt.Sprintf("incorrect kind: expected any of '%s', got '%s'", e.Expected, e.Actual)
if e.Reason != "" {
b.WriteString(": ")
b.WriteString(e.Reason)
}
return b.String()
}
type FieldNotFoundError struct {