272 lines
5.3 KiB
Go
272 lines
5.3 KiB
Go
package yaml
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"reflect"
|
|
"strconv"
|
|
"testing"
|
|
)
|
|
|
|
type MarshalTest struct {
|
|
A string
|
|
B int64
|
|
// Would like to test float64, but it's not supported in go-yaml.
|
|
// (See https://github.com/go-yaml/yaml/issues/83.)
|
|
C float32
|
|
}
|
|
|
|
func TestMarshal(t *testing.T) {
|
|
f32String := strconv.FormatFloat(math.MaxFloat32, 'g', -1, 32)
|
|
s := MarshalTest{"a", math.MaxInt64, math.MaxFloat32}
|
|
e := []byte(fmt.Sprintf("A: a\nB: %d\nC: %s\n", math.MaxInt64, f32String))
|
|
|
|
y, err := Marshal(s)
|
|
if err != nil {
|
|
t.Errorf("error marshaling YAML: %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(y, e) {
|
|
t.Errorf("marshal YAML was unsuccessful, expected: %#v, got: %#v",
|
|
string(e), string(y))
|
|
}
|
|
}
|
|
|
|
type UnmarshalString struct {
|
|
A string
|
|
True string
|
|
}
|
|
|
|
type UnmarshalStringMap struct {
|
|
A map[string]string
|
|
}
|
|
|
|
type UnmarshalNestedString struct {
|
|
A NestedString
|
|
}
|
|
|
|
type NestedString struct {
|
|
A string
|
|
}
|
|
|
|
type UnmarshalSlice struct {
|
|
A []NestedSlice
|
|
}
|
|
|
|
type NestedSlice struct {
|
|
B string
|
|
C *string
|
|
}
|
|
|
|
func TestUnmarshal(t *testing.T) {
|
|
y := []byte("a: 1")
|
|
s1 := UnmarshalString{}
|
|
e1 := UnmarshalString{A: "1"}
|
|
unmarshal(t, y, &s1, &e1)
|
|
|
|
y = []byte("a: true")
|
|
s1 = UnmarshalString{}
|
|
e1 = UnmarshalString{A: "true"}
|
|
unmarshal(t, y, &s1, &e1)
|
|
|
|
y = []byte("true: 1")
|
|
s1 = UnmarshalString{}
|
|
e1 = UnmarshalString{True: "1"}
|
|
unmarshal(t, y, &s1, &e1)
|
|
|
|
y = []byte("a:\n a: 1")
|
|
s2 := UnmarshalNestedString{}
|
|
e2 := UnmarshalNestedString{NestedString{"1"}}
|
|
unmarshal(t, y, &s2, &e2)
|
|
|
|
y = []byte("a:\n - b: abc\n c: def\n - b: 123\n c: 456\n")
|
|
s3 := UnmarshalSlice{}
|
|
e3 := UnmarshalSlice{[]NestedSlice{NestedSlice{"abc", strPtr("def")}, NestedSlice{"123", strPtr("456")}}}
|
|
unmarshal(t, y, &s3, &e3)
|
|
|
|
y = []byte("a:\n b: 1")
|
|
s4 := UnmarshalStringMap{}
|
|
e4 := UnmarshalStringMap{map[string]string{"b": "1"}}
|
|
unmarshal(t, y, &s4, &e4)
|
|
}
|
|
|
|
func unmarshal(t *testing.T, y []byte, s, e interface{}) {
|
|
err := Unmarshal(y, s)
|
|
if err != nil {
|
|
t.Errorf("error unmarshaling YAML: %v", err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(s, e) {
|
|
t.Errorf("unmarshal YAML was unsuccessful, expected: %+#v, got: %+#v",
|
|
e, s)
|
|
}
|
|
}
|
|
|
|
type Case struct {
|
|
input string
|
|
output string
|
|
// By default we test that reversing the output == input. But if there is a
|
|
// difference in the reversed output, you can optionally specify it here.
|
|
reverse *string
|
|
}
|
|
|
|
type RunType int
|
|
|
|
const (
|
|
RunTypeJSONToYAML RunType = iota
|
|
RunTypeYAMLToJSON
|
|
)
|
|
|
|
func TestJSONToYAML(t *testing.T) {
|
|
cases := []Case{
|
|
{
|
|
`{"t":"a"}`,
|
|
"t: a\n",
|
|
nil,
|
|
}, {
|
|
`{"t":null}`,
|
|
"t: null\n",
|
|
nil,
|
|
},
|
|
}
|
|
|
|
runCases(t, RunTypeJSONToYAML, cases)
|
|
}
|
|
|
|
func TestYAMLToJSON(t *testing.T) {
|
|
cases := []Case{
|
|
{
|
|
"t: a\n",
|
|
`{"t":"a"}`,
|
|
nil,
|
|
}, {
|
|
"t: \n",
|
|
`{"t":null}`,
|
|
strPtr("t: null\n"),
|
|
}, {
|
|
"t: null\n",
|
|
`{"t":null}`,
|
|
nil,
|
|
}, {
|
|
"1: a\n",
|
|
`{"1":"a"}`,
|
|
strPtr("\"1\": a\n"),
|
|
}, {
|
|
"1000000000000000000000000000000000000: a\n",
|
|
`{"1e+36":"a"}`,
|
|
strPtr("\"1e+36\": a\n"),
|
|
}, {
|
|
"1e+36: a\n",
|
|
`{"1e+36":"a"}`,
|
|
strPtr("\"1e+36\": a\n"),
|
|
}, {
|
|
"\"1e+36\": a\n",
|
|
`{"1e+36":"a"}`,
|
|
nil,
|
|
}, {
|
|
"\"1.2\": a\n",
|
|
`{"1.2":"a"}`,
|
|
nil,
|
|
}, {
|
|
"- t: a\n",
|
|
`[{"t":"a"}]`,
|
|
nil,
|
|
}, {
|
|
"- t: a\n" +
|
|
"- t:\n" +
|
|
" b: 1\n" +
|
|
" c: 2\n",
|
|
`[{"t":"a"},{"t":{"b":1,"c":2}}]`,
|
|
nil,
|
|
}, {
|
|
`[{t: a}, {t: {b: 1, c: 2}}]`,
|
|
`[{"t":"a"},{"t":{"b":1,"c":2}}]`,
|
|
strPtr("- t: a\n" +
|
|
"- t:\n" +
|
|
" b: 1\n" +
|
|
" c: 2\n"),
|
|
}, {
|
|
"- t: \n",
|
|
`[{"t":null}]`,
|
|
strPtr("- t: null\n"),
|
|
}, {
|
|
"- t: null\n",
|
|
`[{"t":null}]`,
|
|
nil,
|
|
},
|
|
}
|
|
|
|
// Cases that should produce errors.
|
|
_ = []Case{
|
|
{
|
|
"~: a",
|
|
`{"null":"a"}`,
|
|
nil,
|
|
}, {
|
|
"a: !!binary gIGC\n",
|
|
"{\"a\":\"\x80\x81\x82\"}",
|
|
nil,
|
|
},
|
|
}
|
|
|
|
runCases(t, RunTypeYAMLToJSON, cases)
|
|
}
|
|
|
|
func runCases(t *testing.T, runType RunType, cases []Case) {
|
|
var f func([]byte) ([]byte, error)
|
|
var invF func([]byte) ([]byte, error)
|
|
var msg string
|
|
var invMsg string
|
|
if runType == RunTypeJSONToYAML {
|
|
f = JSONToYAML
|
|
invF = YAMLToJSON
|
|
msg = "JSON to YAML"
|
|
invMsg = "YAML back to JSON"
|
|
} else {
|
|
f = YAMLToJSON
|
|
invF = JSONToYAML
|
|
msg = "YAML to JSON"
|
|
invMsg = "JSON back to YAML"
|
|
}
|
|
|
|
for _, c := range cases {
|
|
// Convert the string.
|
|
t.Logf("converting %s\n", c.input)
|
|
output, err := f([]byte(c.input))
|
|
if err != nil {
|
|
t.Errorf("Failed to convert %s, input: `%s`, err: %v", msg, c.input, err)
|
|
}
|
|
|
|
// Check it against the expected output.
|
|
if string(output) != c.output {
|
|
t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`",
|
|
msg, c.input, c.output, string(output))
|
|
}
|
|
|
|
// Set the string that we will compare the reversed output to.
|
|
reverse := c.input
|
|
// If a special reverse string was specified, use that instead.
|
|
if c.reverse != nil {
|
|
reverse = *c.reverse
|
|
}
|
|
|
|
// Reverse the output.
|
|
input, err := invF(output)
|
|
if err != nil {
|
|
t.Errorf("Failed to convert %s, input: `%s`, err: %v", invMsg, string(output), err)
|
|
}
|
|
|
|
// Check the reverse is equal to the input (or to *c.reverse).
|
|
if string(input) != reverse {
|
|
t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`",
|
|
invMsg, string(output), reverse, string(input))
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// To be able to easily fill in the *Case.reverse string above.
|
|
func strPtr(s string) *string {
|
|
return &s
|
|
}
|