Skip to content
Snippets Groups Projects
decode_test.go 3.38 KiB
Newer Older
  • Learn to ignore specific revisions
  • // 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)
    		}
    	}
    }