1 package json
2
3 import (
4 "bytes"
5 "math"
6 "math/big"
7 "strconv"
8 "testing"
9 )
10
11 var (
12 oneInt = new(big.Int).SetInt64(1)
13 oneFloat = new(big.Float).SetFloat64(1.0)
14 )
15
16 func TestValue(t *testing.T) {
17 cases := map[string]struct {
18 setter func(Value)
19 expected string
20 }{
21 "string value": {
22 setter: func(value Value) {
23 value.String("foo")
24 },
25 expected: `"foo"`,
26 },
27 "string escaped": {
28 setter: func(value Value) {
29 value.String(`{"foo":"bar"}`)
30 },
31 expected: `"{\"foo\":\"bar\"}"`,
32 },
33 "integer": {
34 setter: func(value Value) {
35 value.Long(1024)
36 },
37 expected: `1024`,
38 },
39 "float": {
40 setter: func(value Value) {
41 value.Double(1e20)
42 },
43 expected: `100000000000000000000`,
44 },
45 "float exponent component": {
46 setter: func(value Value) {
47 value.Double(3e22)
48 },
49 expected: `3e+22`,
50 },
51 "boolean true": {
52 setter: func(value Value) {
53 value.Boolean(true)
54 },
55 expected: `true`,
56 },
57 "boolean false": {
58 setter: func(value Value) {
59 value.Boolean(false)
60 },
61 expected: `false`,
62 },
63 "encode bytes": {
64 setter: func(value Value) {
65 value.Base64EncodeBytes([]byte("foo bar"))
66 },
67 expected: `"Zm9vIGJhcg=="`,
68 },
69 "encode bytes nil": {
70 setter: func(value Value) {
71 value.Base64EncodeBytes(nil)
72 },
73 expected: `null`,
74 },
75 "object": {
76 setter: func(value Value) {
77 o := value.Object()
78 defer o.Close()
79 o.Key("key").String("value")
80 },
81 expected: `{"key":"value"}`,
82 },
83 "array": {
84 setter: func(value Value) {
85 o := value.Array()
86 defer o.Close()
87 o.Value().String("value1")
88 o.Value().String("value2")
89 },
90 expected: `["value1","value2"]`,
91 },
92 "null": {
93 setter: func(value Value) {
94 value.Null()
95 },
96 expected: `null`,
97 },
98 "write bytes": {
99 setter: func(value Value) {
100 o := value.Object()
101 o.Key("inline").Write([]byte(`{"nested":"value"}`))
102 defer o.Close()
103 },
104 expected: `{"inline":{"nested":"value"}}`,
105 },
106 "bigInteger": {
107 setter: func(value Value) {
108 v := new(big.Int).SetInt64(math.MaxInt64)
109 value.BigInteger(v.Sub(v, oneInt))
110 },
111 expected: strconv.FormatInt(math.MaxInt64-1, 10),
112 },
113 "bigInteger > int64": {
114 setter: func(value Value) {
115 v := new(big.Int).SetInt64(math.MaxInt64)
116 value.BigInteger(v.Add(v, oneInt))
117 },
118 expected: "9223372036854775808",
119 },
120 "bigInteger < int64": {
121 setter: func(value Value) {
122 v := new(big.Int).SetInt64(math.MinInt64)
123 value.BigInteger(v.Sub(v, oneInt))
124 },
125 expected: "-9223372036854775809",
126 },
127 "bigFloat": {
128 setter: func(value Value) {
129 v := new(big.Float).SetFloat64(math.MaxFloat64)
130 value.BigDecimal(v.Sub(v, oneFloat))
131 },
132 expected: strconv.FormatFloat(math.MaxFloat64-1, 'e', -1, 64),
133 },
134 "bigFloat fits in int64": {
135 setter: func(value Value) {
136 v := new(big.Float).SetInt64(math.MaxInt64)
137 value.BigDecimal(v)
138 },
139 expected: "9223372036854775807",
140 },
141 }
142 scratch := make([]byte, 64)
143
144 for name, tt := range cases {
145 t.Run(name, func(t *testing.T) {
146 var b bytes.Buffer
147 value := newValue(&b, &scratch)
148
149 tt.setter(value)
150
151 if e, a := []byte(tt.expected), b.Bytes(); bytes.Compare(e, a) != 0 {
152 t.Errorf("expected %+q, but got %+q", e, a)
153 }
154 })
155 }
156 }
157
View as plain text