Mercurial > hg > Members > sugi > MessagePack-java

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