func TestVector_Unmarshal(t *testing.T) {
b := []byte(`{"Type": "vec2.Vector", "X": 25, "Y": 12}`)
holder, err := support.ReadData(b)
if err != nil {
panic(err)
}
v := Vector{}
serialization.SerializeInPlace(&v, holder)
c := test.Checker(t)
c.Expect(test.EQ, Vector{25, 12}, v)
}
func TestSerialization(t *testing.T) {
tests := []struct {
summary string
testFn func(c *test.Chkr, obj, data interface{})
data []byte
objPtr interface{}
}{
{
summary: "serializing uses golang's encoding/json serializer",
objPtr: &testType{},
data: []byte(`{"I": 5, "F": 3.14, "S": "string", "B": true}`),
testFn: func(c *test.Chkr, obj, data interface{}) {
SerializeInPlace(obj, data)
typ := obj.(*testType)
c.Expect(test.EQ, 5, typ.I)
c.Expect(test.FloatEQ, 3.14, typ.F)
c.Expect(test.EQ, "string", typ.S)
c.Expect(test.EQ, true, typ.B)
},
},
{
summary: "tag support isn't in yet",
objPtr: &testType{},
data: []byte(`{"b": true}`),
testFn: func(c *test.Chkr, obj, data interface{}) {
c.Expect(test.Panic, func() { SerializeInPlace(obj, data) })
},
},
{
summary: "compound objects can be serialized in ",
objPtr: &testType{},
data: []byte(` {"T": { "I": 1} }`),
// data: []byte(` {"T": {"Type": "serialization.testType", "B": true } }`),
testFn: func(c *test.Chkr, obj, data interface{}) {
tf1 := testType{
T: &testType{
B: true,
},
}
b, err := json.MarshalIndent(tf1, " ", " ")
if err != nil {
panic(err)
}
fmt.Println(string(b))
tf2 := testType{}
err = json.Unmarshal(b, &tf2)
if err != nil {
panic(err)
}
fmt.Println(tf2, *tf2.T)
// SerializeInPlace(obj, data)
// typ := obj.(*testType)
c.Assert(test.True, false, "not finished")
// c.Expect(test.EQ, true, typ.T.B)
},
},
}
for i, tt := range tests {
c := test.Checker(t, test.Summary("with test %v: %v", i, tt.summary))
holder, err := support.ReadData(tt.data)
if err != nil {
panic(err)
}
tt.testFn(c, tt.objPtr, holder)
}
}