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