src/pkg/json/decode_test.go

// 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)
		}
	}
}