Mercurial > hg > Members > sugi > MessagePack-java

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