| // 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 { |
| s string; |
| r interface{}; |
| } |
| |
| 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) |
| } |
| } |
| } |