1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
assert('JSON.dump') do
class JsonTestIo
def initialize
@buf = ""
end
def write(str)
@buf += str
end
attr_reader :buf
end
assert_equal "[1]", JSON.dump([1])
jio = JsonTestIo.new
JSON.dump(["abc"], jio)
assert_equal '["abc"]', jio.buf
assert_raise(ArgumentError) do
JSON.dump({:a => {:b => {} } }, nil, 2)
end
JSON.dump({:a=>{:b=>{}}}, nil, 3) # should not raise
end
assert('JSON.generate: false') do
assert_equal "false", JSON.generate(false)
end
assert('JSON.generate: null') do
assert_equal "null", JSON.generate(nil)
end
assert('JSON.generate: true') do
assert_equal "true", JSON.generate(true)
end
assert('JSON.generate: object') do
assert_equal '{"key":"value"}', JSON.generate({ "key" => "value" })
assert_equal '{"ten":10}', JSON.generate({ :ten => 10 })
end
assert('JSON.generate: array') do
assert_equal '[null,1,"two"]', JSON.generate([ nil, 1, "two"])
end
assert('JSON.generate: number (Fixnum)') do
str = JSON.generate [1]
assert_equal "[1]", str
end
assert('JSON.generate: number (Float)') do
str = JSON.generate [134.625]
assert_equal "[134.625]", str
end
assert('JSON.generate: string') do
assert_equal "\"abc\"", JSON.generate("abc")
assert_equal "\"\\\"\\\\/\\b\\f\\n\\r\\t\"",
JSON.generate("\x22\x5c\x2f\x08\x0c\x0a\x0d\x09")
end
assert('JSON.load') do
assert_equal [1,2,3], JSON.load("[1,2,3]")
class JsonTestReader
def read
'{"abc":123}'
end
end
assert_equal({"abc"=>123}, JSON.load(JsonTestReader.new))
end
assert('JSON.parse: text from RFC4726') do
str = '{
"Image": {
"Width": 800,
"Height": 600,
"Title": "View from 15th Floor",
"Thumbnail": {
"Url": "http://www.example.com/image/481989943",
"Height": 125,
"Width": "100"
},
"IDs": [116, 943, 234, 38793]
}
}'
hash = {
"Image" => {
"Width" => 800,
"Height" => 600,
"Title" => "View from 15th Floor",
"Thumbnail" => {
"Url" => "http://www.example.com/image/481989943",
"Height" => 125,
"Width" => "100"
},
"IDs" => [116, 943, 234, 38793]
}
}
assert_equal hash, JSON.parse(str)
# We cannot compare `str` with `JSON.generate(hash)` because Hash entries
# will be in a random order.
assert_equal hash, JSON.parse(JSON.generate(hash))
end
assert('JSON::ParserError') do
assert_raise(JSON::ParserError) do
JSON.parse "[xxx]"
end
end
assert('JSON.parse: empty string is not a valid JSON text') do
assert_raise(JSON::ParserError) do
JSON.parse ""
end
end
assert('JSON.parse: parsing numbers around MRB_INT_MIN/MRB_INT_MAX') do
int_min = TestJSON::MRB_INT_MIN
int_max = TestJSON::MRB_INT_MAX
assert_kind_of Fixnum, JSON.load(int_min.to_s)
assert_equal int_min, JSON.load(int_min.to_s)
assert_kind_of Fixnum, JSON.load(int_max.to_s)
assert_equal int_max, JSON.load(int_max.to_s)
assert_kind_of Float, JSON.load((int_min-1).to_s)
assert_float (int_min-1)/int_min, JSON.load((int_min-1).to_s)/int_min
assert_kind_of Float, JSON.load((int_max+1).to_s)
assert_float (int_max+1)/int_max, JSON.load((int_max+1).to_s)/int_max
end
assert('#to_json') do
assert_equal 'false', false.to_json
assert_equal 'null', nil.to_json
assert_equal 'true', true.to_json
assert_equal '1', 1.to_json
assert_equal '3.125', 3.125.to_json
assert_equal '"str"', "str".to_json
assert_equal '["one",2]', [ "one", 2 ].to_json
assert_equal '{"a":1}', { "a" => 1 }.to_json
assert_equal TestJSON::MRB_INT_MIN.to_s, TestJSON::MRB_INT_MIN.to_json
assert_equal TestJSON::MRB_INT_MAX.to_s, TestJSON::MRB_INT_MAX.to_json
end
|
