2009-11-30 14:55:09 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package json
|
|
|
|
|
|
|
|
import (
|
|
|
|
"container/vector";
|
|
|
|
"reflect";
|
|
|
|
"testing";
|
|
|
|
)
|
|
|
|
|
|
|
|
func TestDecodeInt64(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Int64(-15);
|
|
|
|
assertResult(t, nb.Data(), float64(-15));
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeUint64(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Uint64(15);
|
|
|
|
assertResult(t, nb.Data(), float64(15));
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeFloat64(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Float64(3.14159);
|
|
|
|
assertResult(t, nb.Data(), float64(3.14159));
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeString(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.String("Some string");
|
|
|
|
assertResult(t, nb.Data(), "Some string");
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeBool(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Bool(true);
|
|
|
|
assertResult(t, nb.Data(), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeNull(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Null();
|
|
|
|
assertResult(t, nb.Data(), nil);
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeEmptyArray(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Array();
|
|
|
|
assertResult(t, nb.Data(), []interface{}{});
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeEmptyMap(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Map();
|
|
|
|
assertResult(t, nb.Data(), map[string]interface{}{});
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeFlushElem(t *testing.T) {
|
|
|
|
testVec := new(vector.Vector).Resize(2, 2);
|
|
|
|
nb := newDecoder(testVec, 1);
|
|
|
|
nb.Float64(3.14159);
|
|
|
|
nb.Flush();
|
|
|
|
assertResult(t, testVec.Data(), []interface{}{nil, float64(3.14159)});
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeFlushKey(t *testing.T) {
|
|
|
|
testMap := make(map[string]interface{});
|
|
|
|
nb := newDecoder(testMap, "key");
|
|
|
|
nb.Float64(3.14159);
|
|
|
|
nb.Flush();
|
|
|
|
assertResult(t, testMap, map[string]interface{}{"key": float64(3.14159)});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Elem() and Key() are hard to test in isolation because all they do
|
|
|
|
// is create a new, properly initialized, decoder, and modify state of
|
|
|
|
// the underlying decoder. I'm testing them through already tested
|
|
|
|
// Array(), String(), and Flush().
|
|
|
|
|
|
|
|
func TestDecodeElem(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Array();
|
|
|
|
var b Builder = nb.Elem(0);
|
|
|
|
b.String("0");
|
|
|
|
b.Flush();
|
|
|
|
assertResult(t, nb.Data(), []interface{}{"0"});
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecodeKey(t *testing.T) {
|
|
|
|
nb := newDecoder(nil, nil);
|
|
|
|
nb.Map();
|
|
|
|
var b Builder = nb.Key("a");
|
|
|
|
b.String("0");
|
|
|
|
b.Flush();
|
|
|
|
assertResult(t, nb.Data(), map[string]interface{}{"a": "0"});
|
|
|
|
}
|
|
|
|
|
|
|
|
func assertResult(t *testing.T, results, expected interface{}) {
|
|
|
|
if !reflect.DeepEqual(results, expected) {
|
|
|
|
t.Fatalf("have %T(%#v) want %T(%#v)", results, results, expected, expected)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type decodeTest struct {
|
2009-12-02 12:40:54 -07:00
|
|
|
s string;
|
|
|
|
r interface{};
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
var tests = []decodeTest{
|
|
|
|
decodeTest{`null`, nil},
|
|
|
|
decodeTest{`true`, true},
|
|
|
|
decodeTest{`false`, false},
|
|
|
|
decodeTest{`"abc"`, "abc"},
|
|
|
|
decodeTest{`123`, float64(123)},
|
|
|
|
decodeTest{`0.1`, float64(0.1)},
|
|
|
|
decodeTest{`1e-10`, float64(1e-10)},
|
|
|
|
decodeTest{`[]`, []interface{}{}},
|
|
|
|
decodeTest{`[1,2,3,4]`, []interface{}{float64(1), float64(2), float64(3), float64(4)}},
|
|
|
|
decodeTest{`[1,2,"abc",null,true,false]`, []interface{}{float64(1), float64(2), "abc", nil, true, false}},
|
|
|
|
decodeTest{`{}`, map[string]interface{}{}},
|
|
|
|
decodeTest{`{"a":1}`, map[string]interface{}{"a": float64(1)}},
|
|
|
|
decodeTest{`"q\u0302"`, "q\u0302"},
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestDecode(t *testing.T) {
|
|
|
|
for _, test := range tests {
|
|
|
|
if val, err := Decode(test.s); err != nil || !reflect.DeepEqual(val, test.r) {
|
|
|
|
t.Errorf("Decode(%#q) = %v, %v want %v, nil", test.s, val, err, test.r)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|