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