Mercurial > hg > Members > sugi > MessagePack-java

comparison src/test/java/org/msgpack/template/builder/TestJavassistBufferPackConvert.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.template.builder;
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 org.junit.Test;
8 import org.msgpack.MessagePack;
9 import org.msgpack.packer.BufferPacker;
10 import org.msgpack.template.TemplateRegistry;
11 import org.msgpack.template.Template;
12 import org.msgpack.testclasses.AbstractClass;
13 import org.msgpack.testclasses.FinalClass;
14 import org.msgpack.testclasses.InheritanceClass;
15 import org.msgpack.testclasses.InheritanceClassNotNullable;
16 import org.msgpack.testclasses.Interface;
17 import org.msgpack.testclasses.ListTypeFieldsClass;
18 import org.msgpack.testclasses.ListTypeFieldsClassNotNullable;
19 import org.msgpack.testclasses.MapTypeFieldsClass;
20 import org.msgpack.testclasses.MapTypeFieldsClassNotNullable;
21 import org.msgpack.testclasses.MessagePackableTypeFieldsClass;
22 import org.msgpack.testclasses.MessagePackableTypeFieldsClassNotNullable;
23 import org.msgpack.testclasses.ModifiersFieldsClass;
24 import org.msgpack.testclasses.ModifiersFieldsClassNotNullable;
25 import org.msgpack.testclasses.PrimitiveTypeFieldsClass;
26 import org.msgpack.testclasses.PrimitiveTypeFieldsClassNotNullable;
27 import org.msgpack.testclasses.ReferenceCycleTypeFieldsClass;
28 import org.msgpack.testclasses.ReferenceCycleTypeFieldsClassNotNullable;
29 import org.msgpack.testclasses.ReferenceTypeFieldsClass;
30 import org.msgpack.testclasses.ReferenceTypeFieldsClassNotNullable;
31 import org.msgpack.testclasses.UserDefinedTypeFieldsClass;
32 import org.msgpack.testclasses.UserDefinedTypeFieldsClassNotNullable;
33 import org.msgpack.type.Value;
34 import org.msgpack.unpacker.BufferUnpacker;
35 import org.msgpack.unpacker.Converter;
36
37
38 public class TestJavassistBufferPackConvert extends TestSet {
39
40 @Test @Override
41 public void testPrimitiveTypeFieldsClass() throws Exception {
42 super.testPrimitiveTypeFieldsClass();
43 }
44
45 @Override
46 public void testPrimitiveTypeFieldsClass(PrimitiveTypeFieldsClass v) throws Exception {
47 MessagePack msgpack = new MessagePack();
48 TemplateRegistry registry = new TemplateRegistry(null);
49 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
50 Template<PrimitiveTypeFieldsClass> tmpl = builder.buildTemplate(PrimitiveTypeFieldsClass.class);
51 BufferPacker packer = msgpack.createBufferPacker();
52 tmpl.write(packer, v);
53 byte[] bytes = packer.toByteArray();
54 BufferUnpacker u = msgpack.createBufferUnpacker();
55 u.resetReadByteCount();
56 u.wrap(bytes);
57 Value value = u.readValue();
58 Converter unpacker = new Converter(value);
59 PrimitiveTypeFieldsClass ret = tmpl.read(unpacker, null);
60 assertEquals(v, ret);
61 assertEquals(bytes.length, u.getReadByteCount());
62 }
63
64 @Test @Override
65 public void testPrimitiveTypeFieldsClassNotNullable() throws Exception {
66 super.testPrimitiveTypeFieldsClassNotNullable();
67 }
68
69 @Override
70 public void testPrimitiveTypeFieldsClassNotNullable(PrimitiveTypeFieldsClassNotNullable v) throws Exception {
71 MessagePack msgpack = new MessagePack();
72 TemplateRegistry registry = new TemplateRegistry(null);
73 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
74 Template<PrimitiveTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(PrimitiveTypeFieldsClassNotNullable.class);
75 BufferPacker packer = msgpack.createBufferPacker();
76 tmpl.write(packer, v);
77 byte[] bytes = packer.toByteArray();
78 BufferUnpacker u = msgpack.createBufferUnpacker();
79 u.resetReadByteCount();
80 u.wrap(bytes);
81 Value value = u.readValue();
82 Converter unpacker = new Converter(value);
83 PrimitiveTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
84 assertEquals(v, ret);
85 assertEquals(bytes.length, u.getReadByteCount());
86 }
87
88 @Test @Override
89 public void testReferenceTypeFieldsClass() throws Exception {
90 super.testReferenceTypeFieldsClass();
91 }
92
93 @Override
94 public void testReferenceTypeFieldsClass(ReferenceTypeFieldsClass v) throws Exception {
95 MessagePack msgpack = new MessagePack();
96 TemplateRegistry registry = new TemplateRegistry(null);
97 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
98 Template<ReferenceTypeFieldsClass> tmpl = builder.buildTemplate(ReferenceTypeFieldsClass.class);
99 BufferPacker packer = msgpack.createBufferPacker();
100 tmpl.write(packer, v);
101 byte[] bytes = packer.toByteArray();
102 BufferUnpacker u = msgpack.createBufferUnpacker();
103 u.resetReadByteCount();
104 u.wrap(bytes);
105 Value value = u.readValue();
106 Converter unpacker = new Converter(value);
107 ReferenceTypeFieldsClass ret = tmpl.read(unpacker, null);
108 assertEquals(v, ret);
109 assertEquals(bytes.length, u.getReadByteCount());
110 }
111
112 @Test @Override
113 public void testReferenceTypeFieldsClassNotNullable() throws Exception {
114 super.testReferenceTypeFieldsClassNotNullable();
115 }
116
117 @Override
118 public void testReferenceTypeFieldsClassNotNullable(ReferenceTypeFieldsClassNotNullable v) throws Exception {
119 MessagePack msgpack = new MessagePack();
120 TemplateRegistry registry = new TemplateRegistry(null);
121 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
122 Template<ReferenceTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ReferenceTypeFieldsClassNotNullable.class);
123 BufferPacker packer = msgpack.createBufferPacker();
124 tmpl.write(packer, v);
125 byte[] bytes = packer.toByteArray();
126 BufferUnpacker u = msgpack.createBufferUnpacker();
127 u.resetReadByteCount();
128 u.wrap(bytes);
129 Value value = u.readValue();
130 Converter unpacker = new Converter(value);
131 ReferenceTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
132 assertEquals(v, ret);
133 assertEquals(bytes.length, u.getReadByteCount());
134 }
135
136 @Test @Override
137 public void testListTypeFieldsClass() throws Exception {
138 super.testListTypeFieldsClass();
139 }
140
141 @Override
142 public void testListTypeFieldsClass(ListTypeFieldsClass v) throws Exception {
143 MessagePack msgpack = new MessagePack();
144 TemplateRegistry registry = new TemplateRegistry(null);
145 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
146 Template<ListTypeFieldsClass> tmpl = builder.buildTemplate(ListTypeFieldsClass.class);
147 BufferPacker packer = msgpack.createBufferPacker();
148 tmpl.write(packer, v);
149 byte[] bytes = packer.toByteArray();
150 BufferUnpacker u = msgpack.createBufferUnpacker();
151 u.resetReadByteCount();
152 u.wrap(bytes);
153 Value value = u.readValue();
154 Converter unpacker = new Converter(value);
155 ListTypeFieldsClass ret = tmpl.read(unpacker, null);
156 assertEquals(v, ret);
157 assertEquals(bytes.length, u.getReadByteCount());
158 }
159
160 @Test @Override
161 public void testListTypeFieldsClassNotNullable() throws Exception {
162 super.testListTypeFieldsClassNotNullable();
163 }
164
165 @Override
166 public void testListTypeFieldsClassNotNullable(ListTypeFieldsClassNotNullable v) throws Exception {
167 MessagePack msgpack = new MessagePack();
168 TemplateRegistry registry = new TemplateRegistry(null);
169 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
170 Template<ListTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ListTypeFieldsClassNotNullable.class);
171 BufferPacker packer = msgpack.createBufferPacker();
172 tmpl.write(packer, v);
173 byte[] bytes = packer.toByteArray();
174 BufferUnpacker u = msgpack.createBufferUnpacker();
175 u.resetReadByteCount();
176 u.wrap(bytes);
177 Value value = u.readValue();
178 Converter unpacker = new Converter(value);
179 ListTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
180 assertEquals(v, ret);
181 assertEquals(bytes.length, u.getReadByteCount());
182 }
183
184 @Test @Override
185 public void testMapTypeFieldsClass() throws Exception {
186 super.testMapTypeFieldsClass();
187 }
188
189 @Override
190 public void testMapTypeFieldsClass(MapTypeFieldsClass v) throws Exception {
191 MessagePack msgpack = new MessagePack();
192 TemplateRegistry registry = new TemplateRegistry(null);
193 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
194 Template<MapTypeFieldsClass> tmpl = builder.buildTemplate(MapTypeFieldsClass.class);
195 BufferPacker packer = msgpack.createBufferPacker();
196 tmpl.write(packer, v);
197 byte[] bytes = packer.toByteArray();
198 BufferUnpacker u = msgpack.createBufferUnpacker();
199 u.resetReadByteCount();
200 u.wrap(bytes);
201 Value value = u.readValue();
202 Converter unpacker = new Converter(value);
203 MapTypeFieldsClass ret = tmpl.read(unpacker, null);
204 assertEquals(v, ret);
205 assertEquals(bytes.length, u.getReadByteCount());
206 }
207
208 @Test @Override
209 public void testMapTypeFieldsClassNotNullable() throws Exception {
210 super.testMapTypeFieldsClassNotNullable();
211 }
212
213 @Override
214 public void testMapTypeFieldsClassNotNullable(MapTypeFieldsClassNotNullable v) throws Exception {
215 MessagePack msgpack = new MessagePack();
216 TemplateRegistry registry = new TemplateRegistry(null);
217 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
218 Template<MapTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(MapTypeFieldsClassNotNullable.class);
219 BufferPacker packer = msgpack.createBufferPacker();
220 tmpl.write(packer, v);
221 byte[] bytes = packer.toByteArray();
222 BufferUnpacker u = msgpack.createBufferUnpacker();
223 u.resetReadByteCount();
224 u.wrap(bytes);
225 Value value = u.readValue();
226 Converter unpacker = new Converter(value);
227 MapTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
228 assertEquals(v, ret);
229 assertEquals(bytes.length, u.getReadByteCount());
230 }
231
232 @Test @Override
233 public void testFinalClass() throws Exception {
234 super.testFinalClass();
235 }
236
237 @Override
238 public void testFinalClass(FinalClass v) throws Exception {
239 MessagePack msgpack = new MessagePack();
240 TemplateRegistry registry = new TemplateRegistry(null);
241 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
242 Template<FinalClass> tmpl = builder.buildTemplate(FinalClass.class);
243 BufferPacker packer = msgpack.createBufferPacker();
244 tmpl.write(packer, v);
245 byte[] bytes = packer.toByteArray();
246 BufferUnpacker u = msgpack.createBufferUnpacker();
247 u.resetReadByteCount();
248 u.wrap(bytes);
249 Value value = u.readValue();
250 Converter unpacker = new Converter(value);
251 FinalClass ret = tmpl.read(unpacker, null);
252 assertEquals(v, ret);
253 assertEquals(bytes.length, u.getReadByteCount());
254 }
255
256 @Test @Override
257 public void testAbstractClass() throws Exception {
258 TemplateRegistry registry = new TemplateRegistry(null);
259 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
260 try {
261 builder.buildTemplate(AbstractClass.class);
262 fail();
263 } catch (Throwable t) {
264 assertTrue(t instanceof TemplateBuildException);
265 }
266 }
267
268 @Test @Override
269 public void testInterface() throws Exception {
270 TemplateRegistry registry = new TemplateRegistry(null);
271 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
272 try {
273 builder.buildTemplate(Interface.class);
274 fail();
275 } catch (Throwable t) {
276 assertTrue(t instanceof TemplateBuildException);
277 }
278 }
279
280 @Test @Override
281 public void testModifiersFieldsClass() throws Exception {
282 super.testModifiersFieldsClass();
283 }
284
285 @Override
286 public void testModifiersFieldsClass(ModifiersFieldsClass v) throws Exception {
287 MessagePack msgpack = new MessagePack();
288 TemplateRegistry registry = new TemplateRegistry(null);
289 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
290 Template<ModifiersFieldsClass> tmpl = builder.buildTemplate(ModifiersFieldsClass.class);
291 BufferPacker packer = msgpack.createBufferPacker();
292 tmpl.write(packer, v);
293 byte[] bytes = packer.toByteArray();
294 BufferUnpacker u = msgpack.createBufferUnpacker();
295 u.resetReadByteCount();
296 u.wrap(bytes);
297 Value value = u.readValue();
298 Converter unpacker = new Converter(value);
299 ModifiersFieldsClass ret = tmpl.read(unpacker, null);
300 assertEquals(v, ret);
301 assertEquals(bytes.length, u.getReadByteCount());
302 }
303
304 @Test @Override
305 public void testModifiersFieldsClassNotNullable() throws Exception {
306 super.testModifiersFieldsClassNotNullable();
307 }
308
309 @Override
310 public void testModifiersFieldsClassNotNullable(ModifiersFieldsClassNotNullable v) throws Exception {
311 MessagePack msgpack = new MessagePack();
312 TemplateRegistry registry = new TemplateRegistry(null);
313 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
314 Template<ModifiersFieldsClassNotNullable> tmpl = builder.buildTemplate(ModifiersFieldsClassNotNullable.class);
315 BufferPacker packer = msgpack.createBufferPacker();
316 tmpl.write(packer, v);
317 byte[] bytes = packer.toByteArray();
318 BufferUnpacker u = msgpack.createBufferUnpacker();
319 u.resetReadByteCount();
320 u.wrap(bytes);
321 Value value = u.readValue();
322 Converter unpacker = new Converter(value);
323 ModifiersFieldsClassNotNullable ret = tmpl.read(unpacker, null);
324 assertEquals(v, ret);
325 assertEquals(bytes.length, u.getReadByteCount());
326 }
327
328 @Test @Override
329 public void testUserDefinedTypeFieldsClass() throws Exception {
330 super.testUserDefinedTypeFieldsClass();
331 }
332
333 @Override
334 public void testUserDefinedTypeFieldsClass(UserDefinedTypeFieldsClass v) throws Exception {
335 MessagePack msgpack = new MessagePack();
336 TemplateRegistry registry = new TemplateRegistry(null);
337 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
338 Template<UserDefinedTypeFieldsClass> tmpl = builder.buildTemplate(UserDefinedTypeFieldsClass.class);
339 BufferPacker packer = msgpack.createBufferPacker();
340 tmpl.write(packer, v);
341 byte[] bytes = packer.toByteArray();
342 BufferUnpacker u = msgpack.createBufferUnpacker();
343 u.resetReadByteCount();
344 u.wrap(bytes);
345 Value value = u.readValue();
346 Converter unpacker = new Converter(value);
347 UserDefinedTypeFieldsClass ret = tmpl.read(unpacker, null);
348 assertEquals(v, ret);
349 assertEquals(bytes.length, u.getReadByteCount());
350 }
351
352 @Test @Override
353 public void testUserDefinedTypeFieldsClassNotNullable() throws Exception {
354 super.testUserDefinedTypeFieldsClassNotNullable();
355 }
356
357 @Override
358 public void testUserDefinedTypeFieldsClassNotNullable(UserDefinedTypeFieldsClassNotNullable v) throws Exception {
359 MessagePack msgpack = new MessagePack();
360 TemplateRegistry registry = new TemplateRegistry(null);
361 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
362 Template<UserDefinedTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(UserDefinedTypeFieldsClassNotNullable.class);
363 BufferPacker packer = msgpack.createBufferPacker();
364 tmpl.write(packer, v);
365 byte[] bytes = packer.toByteArray();
366 BufferUnpacker u = msgpack.createBufferUnpacker();
367 u.resetReadByteCount();
368 u.wrap(bytes);
369 Value value = u.readValue();
370 Converter unpacker = new Converter(value);
371 UserDefinedTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
372 assertEquals(v, ret);
373 assertEquals(bytes.length, u.getReadByteCount());
374 }
375
376 @Test @Override
377 public void testReferenceCycleTypeFieldsClass() throws Exception {
378 super.testReferenceCycleTypeFieldsClass();
379 }
380
381 @Override
382 public void testReferenceCycleTypeFieldsClass(ReferenceCycleTypeFieldsClass v) throws Exception {
383 MessagePack msgpack = new MessagePack();
384 TemplateRegistry registry = new TemplateRegistry(null);
385 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
386 Template<ReferenceCycleTypeFieldsClass> tmpl = builder.buildTemplate(ReferenceCycleTypeFieldsClass.class);
387 BufferPacker packer = msgpack.createBufferPacker();
388 tmpl.write(packer, v);
389 byte[] bytes = packer.toByteArray();
390 BufferUnpacker u = msgpack.createBufferUnpacker();
391 u.resetReadByteCount();
392 u.wrap(bytes);
393 Value value = u.readValue();
394 Converter unpacker = new Converter(value);
395 ReferenceCycleTypeFieldsClass ret = tmpl.read(unpacker, null);
396 assertEquals(v, ret);
397 assertEquals(bytes.length, u.getReadByteCount());
398 }
399
400 @Test @Override
401 public void testReferenceCycleTypeFieldsClassNotNullable() throws Exception {
402 super.testReferenceCycleTypeFieldsClassNotNullable();
403 }
404
405 @Override
406 public void testReferenceCycleTypeFieldsClassNotNullable(ReferenceCycleTypeFieldsClassNotNullable v) throws Exception {
407 MessagePack msgpack = new MessagePack();
408 TemplateRegistry registry = new TemplateRegistry(null);
409 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
410 Template<ReferenceCycleTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ReferenceCycleTypeFieldsClassNotNullable.class);
411 BufferPacker packer = msgpack.createBufferPacker();
412 tmpl.write(packer, v);
413 byte[] bytes = packer.toByteArray();
414 BufferUnpacker u = msgpack.createBufferUnpacker();
415 u.resetReadByteCount();
416 u.wrap(bytes);
417 Value value = u.readValue();
418 Converter unpacker = new Converter(value);
419 ReferenceCycleTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
420 assertEquals(v, ret);
421 assertEquals(bytes.length, u.getReadByteCount());
422 }
423
424 @Test @Override
425 public void testInheritanceClass() throws Exception {
426 super.testInheritanceClass();
427 }
428
429 @Override
430 public void testInheritanceClass(InheritanceClass v) throws Exception {
431 MessagePack msgpack = new MessagePack();
432 TemplateRegistry registry = new TemplateRegistry(null);
433 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
434 Template<InheritanceClass> tmpl = builder.buildTemplate(InheritanceClass.class);
435 BufferPacker packer = msgpack.createBufferPacker();
436 tmpl.write(packer, v);
437 byte[] bytes = packer.toByteArray();
438 BufferUnpacker u = msgpack.createBufferUnpacker();
439 u.resetReadByteCount();
440 u.wrap(bytes);
441 Value value = u.readValue();
442 Converter unpacker = new Converter(value);
443 InheritanceClass ret = tmpl.read(unpacker, null);
444 assertEquals(v, ret);
445 assertEquals(bytes.length, u.getReadByteCount());
446 }
447
448 @Test @Override
449 public void testInheritanceClassNotNullable() throws Exception {
450 super.testInheritanceClassNotNullable();
451 }
452
453 @Override
454 public void testInheritanceClassNotNullable(InheritanceClassNotNullable v) throws Exception {
455 MessagePack msgpack = new MessagePack();
456 TemplateRegistry registry = new TemplateRegistry(null);
457 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
458 Template<InheritanceClassNotNullable> tmpl = builder.buildTemplate(InheritanceClassNotNullable.class);
459 BufferPacker packer = msgpack.createBufferPacker();
460 tmpl.write(packer, v);
461 byte[] bytes = packer.toByteArray();
462 BufferUnpacker u = msgpack.createBufferUnpacker();
463 u.resetReadByteCount();
464 u.wrap(bytes);
465 Value value = u.readValue();
466 Converter unpacker = new Converter(value);
467 InheritanceClassNotNullable ret = tmpl.read(unpacker, null);
468 assertEquals(v, ret);
469 assertEquals(bytes.length, u.getReadByteCount());
470 }
471
472 @Test @Override
473 public void testMessagePackableTypeFieldsClass() throws Exception {
474 super.testMessagePackableTypeFieldsClass();
475 }
476
477 @Override
478 public void testMessagePackableTypeFieldsClass(MessagePackableTypeFieldsClass v) throws Exception {
479 MessagePack msgpack = new MessagePack();
480 TemplateRegistry registry = new TemplateRegistry(null);
481 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
482 Template<MessagePackableTypeFieldsClass> tmpl = builder.buildTemplate(MessagePackableTypeFieldsClass.class);
483 BufferPacker packer = msgpack.createBufferPacker();
484 tmpl.write(packer, v);
485 byte[] bytes = packer.toByteArray();
486 BufferUnpacker u = msgpack.createBufferUnpacker();
487 u.resetReadByteCount();
488 u.wrap(bytes);
489 Value value = u.readValue();
490 Converter unpacker = new Converter(value);
491 MessagePackableTypeFieldsClass ret = tmpl.read(unpacker, null);
492 assertEquals(v, ret);
493 assertEquals(bytes.length, u.getReadByteCount());
494 }
495
496 @Test @Override
497 public void testMessagePackableTypeFieldsClassNotNullable() throws Exception {
498 super.testMessagePackableTypeFieldsClassNotNullable();
499 }
500
501 @Override
502 public void testMessagePackableTypeFieldsClassNotNullable(MessagePackableTypeFieldsClassNotNullable v) throws Exception {
503 MessagePack msgpack = new MessagePack();
504 TemplateRegistry registry = new TemplateRegistry(null);
505 JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
506 Template<MessagePackableTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(MessagePackableTypeFieldsClassNotNullable.class);
507 BufferPacker packer = msgpack.createBufferPacker();
508 tmpl.write(packer, v);
509 byte[] bytes = packer.toByteArray();
510 BufferUnpacker u = msgpack.createBufferUnpacker();
511 u.resetReadByteCount();
512 u.wrap(bytes);
513 Value value = u.readValue();
514 Converter unpacker = new Converter(value);
515 MessagePackableTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
516 assertEquals(v, ret);
517 assertEquals(bytes.length, u.getReadByteCount());
518 }
519
520 }