Mercurial > hg > Members > sugi > MessagePack-java
comparison src/test/java/org/msgpack/util/json/TestJSONPackBufferUnpack.java @ 0:cb825acd883a
first commit
author | sugi |
---|---|
date | Sat, 18 Oct 2014 15:06:15 +0900 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:cb825acd883a |
---|---|
1 package org.msgpack.util.json; | |
2 | |
3 import static org.junit.Assert.assertEquals; | |
4 import static org.junit.Assert.assertTrue; | |
5 import static org.junit.Assert.fail; | |
6 | |
7 import java.io.ByteArrayOutputStream; | |
8 import java.io.IOException; | |
9 import java.math.BigInteger; | |
10 import java.util.ArrayList; | |
11 import java.util.HashMap; | |
12 import java.util.Iterator; | |
13 import java.util.List; | |
14 import java.util.Map; | |
15 | |
16 import org.junit.Ignore; | |
17 import org.junit.Test; | |
18 import org.msgpack.MessagePack; | |
19 import org.msgpack.TestSet; | |
20 import org.msgpack.packer.Packer; | |
21 import org.msgpack.unpacker.Unpacker; | |
22 import org.msgpack.util.json.JSON; | |
23 | |
24 | |
25 public class TestJSONPackBufferUnpack extends TestSet { | |
26 | |
27 @Test @Override | |
28 public void testBoolean() throws Exception { | |
29 super.testBoolean(); | |
30 } | |
31 | |
32 @Override | |
33 public void testBoolean(boolean v) throws Exception { | |
34 MessagePack msgpack = new JSON(); | |
35 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
36 Packer packer = msgpack.createPacker(out); | |
37 packer.write(v); | |
38 byte[] bytes = out.toByteArray(); | |
39 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
40 boolean ret = unpacker.readBoolean(); | |
41 assertEquals(v, ret); | |
42 } | |
43 | |
44 @Test @Override | |
45 public void testByte() throws Exception { | |
46 super.testByte(); | |
47 } | |
48 | |
49 @Override | |
50 public void testByte(byte v) throws Exception { | |
51 MessagePack msgpack = new JSON(); | |
52 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
53 Packer packer = msgpack.createPacker(out); | |
54 packer.write(v); | |
55 byte[] bytes = out.toByteArray(); | |
56 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
57 byte ret = unpacker.readByte(); | |
58 assertEquals(v, ret); | |
59 } | |
60 | |
61 @Test @Override | |
62 public void testShort() throws Exception { | |
63 super.testShort(); | |
64 } | |
65 | |
66 @Override | |
67 public void testShort(short v) throws Exception { | |
68 MessagePack msgpack = new JSON(); | |
69 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
70 Packer packer = msgpack.createPacker(out); | |
71 packer.write(v); | |
72 byte[] bytes = out.toByteArray(); | |
73 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
74 short ret = unpacker.readShort(); | |
75 assertEquals(v, ret); | |
76 } | |
77 | |
78 @Test @Override | |
79 public void testInteger() throws Exception { | |
80 super.testInteger(); | |
81 } | |
82 | |
83 @Override | |
84 public void testInteger(int v) throws Exception { | |
85 MessagePack msgpack = new JSON(); | |
86 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
87 Packer packer = msgpack.createPacker(out); | |
88 packer.write(v); | |
89 byte[] bytes = out.toByteArray(); | |
90 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
91 int ret = unpacker.readInt(); | |
92 assertEquals(v, ret); | |
93 } | |
94 | |
95 @Test @Override | |
96 public void testLong() throws Exception { | |
97 super.testLong(); | |
98 } | |
99 | |
100 @Override | |
101 public void testLong(long v) throws Exception { | |
102 MessagePack msgpack = new JSON(); | |
103 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
104 Packer packer = msgpack.createPacker(out); | |
105 packer.write(v); | |
106 byte[] bytes = out.toByteArray(); | |
107 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
108 long ret = unpacker.readLong(); | |
109 assertEquals(v, ret); | |
110 } | |
111 | |
112 @Test @Override | |
113 public void testFloat() throws Exception { | |
114 super.testFloat(); | |
115 } | |
116 | |
117 @Override | |
118 public void testFloat(float v) throws Exception { | |
119 MessagePack msgpack = new JSON(); | |
120 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
121 Packer packer = msgpack.createPacker(out); | |
122 if(((Float)v).isInfinite() || ((Float)v).isNaN()) { | |
123 try { | |
124 packer.write(v); | |
125 fail("JSONPacker should reject infinite and NaN value"); | |
126 } catch (IOException ex) { | |
127 assertTrue(ex instanceof IOException); | |
128 } | |
129 return; | |
130 } | |
131 packer.write(v); | |
132 byte[] bytes = out.toByteArray(); | |
133 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
134 float ret = unpacker.readFloat(); | |
135 assertEquals(v, ret, 10e-10); | |
136 } | |
137 | |
138 @Test @Override | |
139 public void testDouble() throws Exception { | |
140 super.testDouble(); | |
141 } | |
142 | |
143 @Override | |
144 public void testDouble(double v) throws Exception { | |
145 MessagePack msgpack = new JSON(); | |
146 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
147 Packer packer = msgpack.createPacker(out); | |
148 if(((Double)v).isInfinite() || ((Double)v).isNaN()) { | |
149 try { | |
150 packer.write(v); | |
151 fail("JSONPacker should reject infinite and NaN value"); | |
152 } catch (IOException ex) { | |
153 assertTrue(ex instanceof IOException); | |
154 } | |
155 return; | |
156 } | |
157 packer.write(v); | |
158 byte[] bytes = out.toByteArray(); | |
159 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
160 double ret = unpacker.readDouble(); | |
161 assertEquals(v, ret, 10e-10); | |
162 } | |
163 | |
164 @Test @Override | |
165 public void testNil() throws Exception { | |
166 MessagePack msgpack = new JSON(); | |
167 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
168 Packer packer = msgpack.createPacker(out); | |
169 packer.writeNil(); | |
170 byte[] bytes = out.toByteArray(); | |
171 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
172 unpacker.readNil(); | |
173 } | |
174 | |
175 @Ignore @Test @Override // FIXME #SF JSON Unpacker doesn't support BigInteger | |
176 public void testBigInteger() throws Exception { | |
177 super.testBigInteger(); | |
178 } | |
179 | |
180 @Override | |
181 public void testBigInteger(BigInteger v) throws Exception { | |
182 MessagePack msgpack = new JSON(); | |
183 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
184 Packer packer = msgpack.createPacker(out); | |
185 packer.write(v); | |
186 byte[] bytes = out.toByteArray(); | |
187 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
188 BigInteger ret = unpacker.read(BigInteger.class); | |
189 assertEquals(v, ret); | |
190 } | |
191 | |
192 @Test @Override | |
193 public void testString() throws Exception { | |
194 super.testString(); | |
195 } | |
196 | |
197 @Override | |
198 public void testString(String v) throws Exception { | |
199 MessagePack msgpack = new JSON(); | |
200 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
201 Packer packer = msgpack.createPacker(out); | |
202 packer.write(v); | |
203 byte[] bytes = out.toByteArray(); | |
204 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
205 String ret = unpacker.read(String.class); | |
206 assertEquals(v, ret); | |
207 } | |
208 | |
209 @Ignore @Test @Override // FIXME #SF JSONPacker doesn't support bytes | |
210 public void testByteArray() throws Exception { | |
211 super.testByteArray(); | |
212 } | |
213 | |
214 @Override | |
215 public void testByteArray(byte[] v) throws Exception { | |
216 MessagePack msgpack = new JSON(); | |
217 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
218 Packer packer = msgpack.createPacker(out); | |
219 //packer.write(v); | |
220 String str = new String(v); | |
221 packer.write(str); | |
222 byte[] bytes = out.toByteArray(); | |
223 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
224 String ret = unpacker.read(String.class); | |
225 assertEquals(str, ret); | |
226 } | |
227 | |
228 @Test @Override | |
229 public void testList() throws Exception { | |
230 super.testList(); | |
231 } | |
232 | |
233 @SuppressWarnings({ "rawtypes", "unchecked" }) | |
234 @Override | |
235 public <E> void testList(List<E> v, Class<E> elementClass) throws Exception { | |
236 MessagePack msgpack = new JSON(); | |
237 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
238 Packer packer = msgpack.createPacker(out); | |
239 if (v == null) { | |
240 packer.writeNil(); | |
241 } else { | |
242 packer.writeArrayBegin(v.size()); | |
243 for (Object o : v) { | |
244 packer.write(o); | |
245 } | |
246 packer.writeArrayEnd(); | |
247 } | |
248 byte[] bytes = out.toByteArray(); | |
249 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
250 if (unpacker.trySkipNil()) { | |
251 assertEquals(null, v); | |
252 return; | |
253 } | |
254 int size = unpacker.readArrayBegin(); | |
255 List ret = new ArrayList(size); | |
256 for (int i = 0; i < size; ++i) { | |
257 ret.add(unpacker.read(elementClass)); | |
258 } | |
259 unpacker.readArrayEnd(); | |
260 assertEquals(v.size(), ret.size()); | |
261 Iterator v_iter = v.iterator(); | |
262 Iterator ret_iter = ret.iterator(); | |
263 while (v_iter.hasNext()) { | |
264 assertEquals(v_iter.next(), ret_iter.next()); | |
265 } | |
266 } | |
267 | |
268 @Test @Override | |
269 public void testMap() throws Exception { | |
270 super.testMap(); | |
271 } | |
272 | |
273 @SuppressWarnings({ "rawtypes", "unchecked" }) | |
274 @Override | |
275 public <K, V> void testMap(Map<K, V> v, Class<K> keyElementClass, Class<V> valueElementClass) throws Exception { | |
276 MessagePack msgpack = new JSON(); | |
277 ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
278 Packer packer = msgpack.createPacker(out); | |
279 if (v == null) { | |
280 packer.writeNil(); | |
281 } else { | |
282 packer.writeMapBegin(v.size()); | |
283 for (Map.Entry<Object, Object> e : ((Map<Object, Object>) v).entrySet()) { | |
284 if (!(e.getKey() instanceof String)) { | |
285 try { | |
286 packer.write(e.getKey()); | |
287 fail("JSONPacker should reject non-String value for the map key"); | |
288 } catch (IOException ex) { | |
289 assertTrue(ex instanceof IOException); | |
290 } | |
291 return; | |
292 } | |
293 packer.write(e.getKey()); | |
294 packer.write(e.getValue()); | |
295 } | |
296 packer.writeMapEnd(); | |
297 } | |
298 byte[] bytes = out.toByteArray(); | |
299 Unpacker unpacker = msgpack.createBufferUnpacker(bytes); | |
300 if (unpacker.trySkipNil()) { | |
301 assertEquals(null, v); | |
302 return; | |
303 } | |
304 int size = unpacker.readMapBegin(); | |
305 Map ret = new HashMap(size); | |
306 for (int i = 0; i < size; ++i) { | |
307 Object key = unpacker.read(keyElementClass); | |
308 Object value = unpacker.read(valueElementClass); | |
309 ret.put(key, value); | |
310 } | |
311 unpacker.readMapEnd(); | |
312 assertEquals(v.size(), ret.size()); | |
313 for (Map.Entry<Object, Object> e : ((Map<Object, Object>) v).entrySet()) { | |
314 Object value = ret.get(e.getKey()); | |
315 assertEquals(e.getValue(), value); | |
316 } | |
317 } | |
318 } |