Mercurial > hg > Members > sugi > MessagePack-java

comparison src/test/java/org/msgpack/util/json/TestValueToStringJSONUnpack.java @ 0:cb825acd883a

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