Skip to content

Commit 91078ee

Browse files
frsyukifrsyuki
committed
added test programs for JSONPacker and JSONUnpacker
1 parent 499dd52 commit 91078ee

File tree

7 files changed

+1197
-8
lines changed

7 files changed

+1197
-8
lines changed

‎Makefile

100755100644
File mode changed.

‎build.xml

100755100644
File mode changed.

‎src/main/java/org/msgpack/packer/JSONPacker.java

+23-8
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,11 @@
2121
import java.io.OutputStream;
2222
import java.nio.ByteBuffer;
2323
import java.math.BigInteger;
24+
import java.nio.charset.Charset;
25+
import java.nio.charset.CharacterCodingException;
26+
import java.nio.charset.CharsetDecoder;
27+
import java.nio.charset.CodingErrorAction;
28+
import java.nio.charset.MalformedInputException;
2429
import org.json.simple.JSONValue;
2530
import org.msgpack.io.Output;
2631
import org.msgpack.io.StreamOutput;
@@ -49,6 +54,7 @@ public class JSONPacker extends AbstractPacker {
4954
private int[] flags;
5055

5156
private PackerStack stack = new PackerStack();
57+
private CharsetDecoder decoder;
5258

5359
public JSONPacker(OutputStream stream) {
5460
this(new MessagePack(), stream);
@@ -63,6 +69,9 @@ protected JSONPacker(MessagePack msgpack, Output out) {
6369
this.out = out;
6470
this.stack = new PackerStack();
6571
this.flags = new int[PackerStack.MAX_STACK_SIZE];
72+
this.decoder = Charset.forName("UTF-8").newDecoder().
73+
onMalformedInput(CodingErrorAction.REPORT).
74+
onUnmappableCharacter(CodingErrorAction.REPORT);
6675
}
6776

6877
public void writeNil() throws IOException {
@@ -118,13 +127,21 @@ public void writeBigInteger(BigInteger v) throws IOException {
118127

119128
public void writeFloat(float v) throws IOException {
120129
beginElement();
130+
Float r = v;
131+
if(r.isInfinite() || r.isNaN()) {
132+
throw new IOException("JSONPacker doesn't support NaN and infinite float value");
133+
}
121134
byte[] b = Float.toString(v).getBytes(); // TODO optimize
122135
out.write(b, 0, b.length);
123136
endElement();
124137
}
125138

126139
public void writeDouble(double v) throws IOException {
127140
beginElement();
141+
Double r = v;
142+
if(r.isInfinite() || r.isNaN()) {
143+
throw new IOException("JSONPacker doesn't support NaN and infinite float value");
144+
}
128145
byte[] b = Double.toString(v).getBytes(); // TODO optimize
129146
out.write(b, 0, b.length);
130147
endElement();
@@ -248,19 +265,17 @@ public void close() throws IOException {
248265
out.close();
249266
}
250267

251-
private static void escape(Output out, byte[] b, int off, int len) throws IOException {
252-
// TODO optimize
253-
escape(out, new String(b, off, len));
268+
private void escape(Output out, byte[] b, int off, int len) throws IOException {
269+
escape(out, ByteBuffer.wrap(b, off, len));
254270
}
255271

256-
private static void escape(Output out, ByteBuffer bb) throws IOException {
272+
private void escape(Output out, ByteBuffer bb) throws IOException {
257273
// TODO optimize
258-
byte[] b = new byte[bb.remaining()];
259-
bb.get(b);
260-
escape(out, new String(b));
274+
String str = decoder.decode(bb).toString();
275+
escape(out, str);
261276
}
262277

263-
private static void escape(Output out, String s) throws IOException {
278+
private void escape(Output out, String s) throws IOException {
264279
// TODO optimize
265280
String e = JSONValue.escape(s);
266281
byte[] raw = e.getBytes();

‎src/test/java/org/msgpack/TestJSONBufferPackBufferUnpack.java

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

0 commit comments

Comments
 (0)