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