Mercurial > hg > Members > sugi > MessagePack-java

comparison src/test/java/org/msgpack/template/builder/TestReflectionBufferPackBufferUnpack.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.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 }