Skip to content

Commit 7e3cd12

Browse files
mugamuga
committed
added test program for BufferPacker and Converter
1 parent 0ecc73e commit 7e3cd12

1 file changed

Lines changed: 226 additions & 0 deletions

File tree

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

Lines changed: 226 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,226 @@
1+
package org.msgpack;
2+
3+
import static org.junit.Assert.assertEquals;
4+
import static org.junit.Assert.assertTrue;
5+
6+
import java.math.BigInteger;
7+
8+
import org.junit.Test;
9+
import org.msgpack.packer.BufferPacker;
10+
import org.msgpack.unpacker.BufferUnpacker;
11+
import org.msgpack.unpacker.Converter;
12+
import org.msgpack.value.Value;
13+
14+
15+
public class TestBufferPackConvert extends TestSet {
16+
17+
@Test @Override
18+
public void testBoolean() throws Exception {
19+
super.testBoolean();
20+
}
21+
22+
@Override
23+
public void testBoolean(boolean v) throws Exception {
24+
BufferPacker packer = new BufferPacker();
25+
packer.writeBoolean(v);
26+
byte[] bytes = packer.toByteArray();
27+
BufferUnpacker unpacker = new BufferUnpacker();
28+
unpacker.wrap(bytes);
29+
Value value = unpacker.readValue();
30+
assertTrue(value.isBoolean());
31+
boolean ret = new Converter(value).readBoolean();
32+
assertEquals(v, ret);
33+
}
34+
35+
@Test @Override
36+
public void testByte() throws Exception {
37+
super.testByte();
38+
}
39+
40+
@Override
41+
public void testByte(byte v) throws Exception {
42+
BufferPacker packer = new BufferPacker();
43+
packer.writeByte(v);
44+
byte[] bytes = packer.toByteArray();
45+
BufferUnpacker unpacker = new BufferUnpacker();
46+
unpacker.wrap(bytes);
47+
Value value = unpacker.readValue();
48+
// FIXME? false <= assertTrue(value.isRaw());
49+
//System.out.println("## value: " + value.getClass());
50+
// following result is expected?
51+
assertTrue(value.isInteger());
52+
byte ret = new Converter(value).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+
BufferPacker packer = new BufferPacker();
64+
packer.writeShort(v);
65+
byte[] bytes = packer.toByteArray();
66+
BufferUnpacker unpacker = new BufferUnpacker();
67+
unpacker.wrap(bytes);
68+
Value value = unpacker.readValue();
69+
// FIXME assertTrue(value.isShort());
70+
//System.out.println("## value: " + value.getClass());
71+
// following result is expected?
72+
assertTrue(value.isInteger());
73+
short ret = new Converter(value).readShort();
74+
assertEquals(v, ret);
75+
}
76+
77+
@Test @Override
78+
public void testInteger() throws Exception {
79+
super.testInteger();
80+
}
81+
82+
@Override
83+
public void testInteger(int v) throws Exception {
84+
BufferPacker packer = new BufferPacker();
85+
packer.writeInt(v);
86+
byte[] bytes = packer.toByteArray();
87+
BufferUnpacker unpacker = new BufferUnpacker();
88+
unpacker.wrap(bytes);
89+
Value value = unpacker.readValue();
90+
assertTrue(value.isInteger());
91+
int ret = new Converter(value).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+
BufferPacker packer = new BufferPacker();
103+
packer.writeLong(v);
104+
byte[] bytes = packer.toByteArray();
105+
BufferUnpacker unpacker = new BufferUnpacker();
106+
unpacker.wrap(bytes);
107+
Value value = unpacker.readValue();
108+
// FIXME assertTrue(value.isLong());
109+
//System.out.println("## value: " + value.getClass());
110+
// following result is expected?
111+
assertTrue(value.isInteger());
112+
long ret = new Converter(value).readLong();
113+
assertEquals(v, ret);
114+
}
115+
116+
@Test @Override
117+
public void testFloat() throws Exception {
118+
super.testFloat();
119+
}
120+
121+
@Override
122+
public void testFloat(float v) throws Exception {
123+
BufferPacker packer = new BufferPacker();
124+
packer.writeFloat(v);
125+
byte[] bytes = packer.toByteArray();
126+
BufferUnpacker unpacker = new BufferUnpacker();
127+
unpacker.wrap(bytes);
128+
Value value = unpacker.readValue();
129+
assertTrue(value.isFloat());
130+
float ret = new Converter(value).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+
BufferPacker packer = new BufferPacker();
142+
packer.writeDouble(v);
143+
byte[] bytes = packer.toByteArray();
144+
BufferUnpacker unpacker = new BufferUnpacker();
145+
unpacker.wrap(bytes);
146+
Value value = unpacker.readValue();
147+
// FIXME assertTrue(value.isDouble());
148+
//System.out.println("## value: " + value.getClass());
149+
// following result is expected?
150+
assertTrue(value.isFloat());
151+
double ret = new Converter(value).readDouble();
152+
assertEquals(v, ret, 10e-10);
153+
}
154+
155+
@Test @Override
156+
public void testNil() throws Exception {
157+
BufferPacker packer = new BufferPacker();
158+
packer.writeNil();
159+
byte[] bytes = packer.toByteArray();
160+
BufferUnpacker unpacker = new BufferUnpacker();
161+
unpacker.wrap(bytes);
162+
Value value = unpacker.readValue();
163+
assertTrue(value.isNil());
164+
new Converter(value).readNil();
165+
}
166+
167+
@Test @Override
168+
public void testBigInteger() throws Exception {
169+
super.testBigInteger();
170+
}
171+
172+
@Override
173+
public void testBigInteger(BigInteger v) throws Exception {
174+
BufferPacker packer = new BufferPacker();
175+
packer.writeBigInteger(v);
176+
byte[] bytes = packer.toByteArray();
177+
BufferUnpacker unpacker = new BufferUnpacker();
178+
unpacker.wrap(bytes);
179+
Value value = unpacker.readValue();
180+
// FIXME assertTrue(value.isBigInteger());
181+
//System.out.println("## value: " + value.getClass());
182+
// following result is strange...
183+
//assertTrue(value.is??);
184+
BigInteger ret = new Converter(value).readBigInteger();
185+
assertEquals(v, ret);
186+
}
187+
188+
@Test @Override
189+
public void testString() throws Exception {
190+
super.testString();
191+
}
192+
193+
@Override
194+
public void testString(String v) throws Exception {
195+
BufferPacker packer = new BufferPacker();
196+
packer.writeString(v);
197+
byte[] bytes = packer.toByteArray();
198+
BufferUnpacker unpacker = new BufferUnpacker();
199+
unpacker.wrap(bytes);
200+
Value value = unpacker.readValue();
201+
assertTrue(value.isRaw());
202+
String ret = new Converter(value).readString();
203+
assertEquals(v, ret);
204+
}
205+
206+
@Test @Override
207+
public void testByteArray() throws Exception {
208+
super.testByteArray();
209+
}
210+
211+
@Override
212+
public void testByteArray(byte[] v) throws Exception {
213+
BufferPacker packer = new BufferPacker();
214+
packer.writeByteArray(v);
215+
byte[] bytes = packer.toByteArray();
216+
BufferUnpacker unpacker = new BufferUnpacker();
217+
unpacker.wrap(bytes);
218+
Value value = unpacker.readValue();
219+
assertTrue(value.isRaw());
220+
byte[] ret = new Converter(value).readByteArray();
221+
assertEquals(v.length, ret.length);
222+
for (int i = 0; i < v.length; ++i) {
223+
assertEquals(v[i], ret[i]);
224+
}
225+
}
226+
}

0 commit comments

Comments
 (0)