Function runCompatibilityCase

go/fory/fory_compatible_test.go:635–680

(t *testing.T, tc compatibilityCase)

}

func runCompatibilityCase(t *testing.T, tc compatibilityCase) {
	t.Helper()

	writer := NewForyWithOptions(WithXlang(true), WithCompatible(true))
	if tc.writerSetup != nil {
		err := tc.writerSetup(writer)
		assert.NoError(t, err)
	}
	err := writer.RegisterStructByName(tc.writeType, tc.tag)
	assert.NoError(t, err)

	marshalInput := tc.input
	if tc.input != nil {
		value := reflect.ValueOf(tc.input)
		if value.Kind() == reflect.Struct {
			ptr := reflect.New(value.Type())
			ptr.Elem().Set(value)
			marshalInput = ptr.Interface()
		}
	}
	data, err := writer.Marshal(marshalInput)
	assert.NoError(t, err)

	reader := NewForyWithOptions(WithXlang(true), WithCompatible(true))
	if tc.readerSetup != nil {
		err = tc.readerSetup(reader)
		assert.NoError(t, err)
	}
	err = reader.RegisterStructByName(tc.readType, tc.tag)
	assert.NoError(t, err)

	target := reflect.New(reflect.TypeOf(tc.readType))
	var unmarshalErr error
	assert.NotPanics(t, func() {
		unmarshalErr = reader.Unmarshal(data, target.Interface())
	})
	if tc.unmarshalErrContains != "" {
		if assert.Error(t, unmarshalErr) {
			assert.Contains(t, unmarshalErr.Error(), tc.unmarshalErrContains)
		}
		return
	}
	assert.NoError(t, unmarshalErr)

	tc.assertFunc(t, tc.input, target.Elem().Interface())
}