|
0
|
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 TestReflectionBufferPackConvert 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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(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 }
|
