1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.juneau.http.remote;
18
19 import static java.util.Arrays.*;
20 import static org.apache.juneau.TestUtils.*;
21 import static org.apache.juneau.http.HttpMethod.*;
22 import static org.apache.juneau.utest.utils.Constants.*;
23 import static org.junit.jupiter.api.Assertions.*;
24
25 import java.util.*;
26
27 import org.apache.juneau.*;
28 import org.apache.juneau.html.*;
29 import org.apache.juneau.internal.*;
30 import org.apache.juneau.json.*;
31 import org.apache.juneau.msgpack.*;
32 import org.apache.juneau.parser.*;
33 import org.apache.juneau.rest.annotation.*;
34 import org.apache.juneau.rest.logger.*;
35 import org.apache.juneau.rest.mock.*;
36 import org.apache.juneau.rest.servlet.*;
37 import org.apache.juneau.serializer.*;
38 import org.apache.juneau.serializer.annotation.*;
39 import org.apache.juneau.testutils.pojos.*;
40 import org.apache.juneau.uon.*;
41 import org.apache.juneau.urlencoding.*;
42 import org.apache.juneau.xml.*;
43 import org.junit.jupiter.params.*;
44 import org.junit.jupiter.params.provider.*;
45 import org.opentest4j.*;
46
47 class RrpcInterface_Test extends TestBase {
48
49 private static final Input[] INPUT = {
50 input("Json", JsonSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), JsonParser.DEFAULT),
51 input("Xml", XmlSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), XmlParser.DEFAULT),
52 input("Mixed", JsonSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), XmlParser.DEFAULT),
53 input("Html", HtmlSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), HtmlParser.DEFAULT),
54 input("MessagePack", MsgPackSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), MsgPackParser.DEFAULT),
55 input("UrlEncoding", UrlEncodingSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), UrlEncodingParser.DEFAULT),
56 input("Uon", UonSerializer.DEFAULT.copy().addBeanTypes().addRootType().build(), UonParser.DEFAULT)
57 };
58
59 private static Input input(String label, Serializer serializer, Parser parser) {
60 return new Input(label, serializer, parser);
61 }
62
63 private static class Input {
64 InterfaceProxy proxy;
65
66 public Input(String label, Serializer serializer, Parser parser) {
67 proxy = MockRestClient.create(InterfaceProxyResource.class).serializer(serializer).parser(parser).noTrace().build().getRrpcInterface(InterfaceProxy.class,"/proxy");
68 }
69 }
70
71 static Input[] input() {
72 return INPUT;
73 }
74
75 public interface InterfaceProxy {
76
77 String SWAP = "swap-~!@#$%^&*()_+`-={}[]|:;\"<,>.?/";
78
79
80
81
82
83
84 void returnVoid();
85 int returnInt();
86 Integer returnInteger();
87 boolean returnBoolean();
88 float returnFloat();
89 Float returnFloatObject();
90 String returnString();
91 String returnNullString();
92 int[][][] returnInt3dArray();
93 Integer[][][] returnInteger3dArray();
94 String[][][] returnString3dArray();
95 List<Integer> returnIntegerList();
96 List<List<List<Integer>>> returnInteger3dList();
97 List<Integer[][][]> returnInteger1d3dList();
98 List<int[][][]> returnInt1d3dList();
99 List<String> returnStringList();
100
101
102 ABean returnBean();
103 ABean[][][] returnBean3dArray();
104 List<ABean> returnBeanList();
105 List<ABean[][][]> returnBean1d3dList();
106 Map<String,ABean> returnBeanMap();
107 Map<String,List<ABean>> returnBeanListMap();
108 Map<String,List<ABean[][][]>> returnBean1d3dListMap();
109 Map<Integer,List<ABean>> returnBeanListMapIntegerKeys();
110
111
112 TypedBean returnTypedBean();
113 TypedBean[][][] returnTypedBean3dArray();
114 List<TypedBean> returnTypedBeanList();
115 List<TypedBean[][][]> returnTypedBean1d3dList();
116 Map<String,TypedBean> returnTypedBeanMap();
117 Map<String,List<TypedBean>> returnTypedBeanListMap();
118 Map<String,List<TypedBean[][][]>> returnTypedBean1d3dListMap();
119 Map<Integer,List<TypedBean>> returnTypedBeanListMapIntegerKeys();
120
121
122 SwappedObject returnSwappedObject();
123 SwappedObject[][][] returnSwappedObject3dArray();
124 Map<SwappedObject,SwappedObject> returnSwappedObjectMap();
125 Map<SwappedObject,SwappedObject[][][]> returnSwappedObject3dMap();
126
127
128 ImplicitSwappedObject returnImplicitSwappedObject();
129 ImplicitSwappedObject[][][] returnImplicitSwappedObject3dArray();
130 Map<ImplicitSwappedObject,ImplicitSwappedObject> returnImplicitSwappedObjectMap();
131 Map<ImplicitSwappedObject,ImplicitSwappedObject[][][]> returnImplicitSwappedObject3dMap();
132
133
134 TestEnum returnEnum();
135 TestEnum[][][] returnEnum3d();
136 List<TestEnum> returnEnumList();
137 List<List<List<TestEnum>>> returnEnum3dList();
138 List<TestEnum[][][]> returnEnum1d3dList();
139 Map<TestEnum,TestEnum> returnEnumMap();
140 Map<TestEnum,TestEnum[][][]> returnEnum3dArrayMap();
141 Map<TestEnum,List<TestEnum[][][]>> returnEnum1d3dListMap();
142
143
144
145
146
147 void throwException1() throws InterfaceProxyException1;
148 void throwException2() throws InterfaceProxyException2;
149
150
151
152
153
154
155 void setNothing();
156 void setInt(int x) throws AssertionFailedError;
157 void setInteger(Integer x);
158 void setBoolean(boolean x);
159 void setFloat(float x);
160 void setFloatObject(Float x);
161 void setString(String x);
162 void setNullString(String x) throws AssertionFailedError;
163 void setInt3dArray(int[][][] x);
164 void setInteger3dArray(Integer[][][] x);
165 void setString3dArray(String[][][] x);
166 void setIntegerList(List<Integer> x);
167 void setInteger3dList(List<List<List<Integer>>> x);
168 void setInteger1d3dList(List<Integer[][][]> x);
169 void setInt1d3dList(List<int[][][]> x);
170 void setStringList(List<String> x);
171
172
173 void setBean(ABean x);
174 void setBean3dArray(ABean[][][] x);
175 void setBeanList(List<ABean> x);
176 void setBean1d3dList(List<ABean[][][]> x);
177 void setBeanMap(Map<String,ABean> x);
178 void setBeanListMap(Map<String,List<ABean>> x);
179 void setBean1d3dListMap(Map<String,List<ABean[][][]>> x);
180 void setBeanListMapIntegerKeys(Map<Integer,List<ABean>> x);
181
182
183 void setTypedBean(TypedBean x);
184 void setTypedBean3dArray(TypedBean[][][] x);
185 void setTypedBeanList(List<TypedBean> x);
186 void setTypedBean1d3dList(List<TypedBean[][][]> x);
187 void setTypedBeanMap(Map<String,TypedBean> x);
188 void setTypedBeanListMap(Map<String,List<TypedBean>> x);
189 void setTypedBean1d3dListMap(Map<String,List<TypedBean[][][]>> x);
190 void setTypedBeanListMapIntegerKeys(Map<Integer,List<TypedBean>> x);
191
192
193 void setSwappedObject(SwappedObject x);
194 void setSwappedObject3dArray(SwappedObject[][][] x);
195 void setSwappedObjectMap(Map<SwappedObject,SwappedObject> x);
196 void setSwappedObject3dMap(Map<SwappedObject,SwappedObject[][][]> x);
197
198
199 void setImplicitSwappedObject(ImplicitSwappedObject x);
200 void setImplicitSwappedObject3dArray(ImplicitSwappedObject[][][] x);
201 void setImplicitSwappedObjectMap(Map<ImplicitSwappedObject,ImplicitSwappedObject> x);
202 void setImplicitSwappedObject3dMap(Map<ImplicitSwappedObject,ImplicitSwappedObject[][][]> x);
203
204
205 void setEnum(TestEnum x);
206 void setEnum3d(TestEnum[][][] x);
207 void setEnumList(List<TestEnum> x);
208 void setEnum3dList(List<List<List<TestEnum>>> x);
209 void setEnum1d3dList(List<TestEnum[][][]> x);
210 void setEnumMap(Map<TestEnum,TestEnum> x);
211 void setEnum3dArrayMap(Map<TestEnum,TestEnum[][][]> x);
212 void setEnum1d3dListMap(Map<TestEnum,List<TestEnum[][][]>> x);
213
214
215
216
217
218 void setMultiParamsInts(int x1,int[][][] x2,int[][][] x2n,List<int[][][]> x3,List<int[][][]> x3n);
219 void setMultiParamsInteger(Integer x1,Integer x1n,Integer[][][] x2,Integer[][][] x2n,List<Integer[][][]> x3,List<Integer[][][]> x3n);
220 void setMultiParamsFloat(float x1,float[][][] x2,float[][][] x2n,List<float[][][]> x3,List<float[][][]> x3n);
221 void setMultiParamsFloatObject(Float x1,Float x1n,Float[][][] x2,Float[][][] x2n,List<Float[][][]> x3,List<Float[][][]> x3n);
222 void setMultiParamsString(String x1,String[][][] x2,String[][][] x2n,List<String[][][]> x3,List<String[][][]> x3n);
223 void setMultiParamsBean(ABean x1,ABean[][][] x2,ABean[][][] x2n,List<ABean[][][]> x3,List<ABean[][][]> x3n,Map<String,ABean> x4,Map<String,ABean> x4n,Map<String,List<ABean[][][]>> x5,Map<String,List<ABean[][][]>> x5n);
224 void setMultiParamsSwappedObject(SwappedObject x1,SwappedObject[][][] x2,SwappedObject[][][] x2n,List<SwappedObject[][][]> x3,List<SwappedObject[][][]> x3n,Map<SwappedObject,SwappedObject> x4,Map<SwappedObject,SwappedObject> x4n,Map<SwappedObject,List<SwappedObject[][][]>> x5,Map<SwappedObject,List<SwappedObject[][][]>> x5n);
225 void setMultiParamsImplicitSwappedObject(ImplicitSwappedObject x1,ImplicitSwappedObject[][][] x2,ImplicitSwappedObject[][][] x2n,List<ImplicitSwappedObject[][][]> x3,List<ImplicitSwappedObject[][][]> x3n,Map<ImplicitSwappedObject,ImplicitSwappedObject> x4,Map<ImplicitSwappedObject,ImplicitSwappedObject> x4n,Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5,Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5n);
226 void setMultiParamsEnum(TestEnum x1,TestEnum[][][] x2,TestEnum[][][] x2n,List<TestEnum[][][]> x3,List<TestEnum[][][]> x3n,Map<TestEnum,TestEnum> x4,Map<TestEnum,TestEnum> x4n,Map<TestEnum,List<TestEnum[][][]>> x5,Map<TestEnum,List<TestEnum[][][]>> x5n);
227
228
229
230
231
232 @SuppressWarnings("serial")
233 public static class InterfaceProxyException1 extends Exception {
234 public InterfaceProxyException1(String msg) {
235 super(msg);
236 }
237 }
238
239 @SuppressWarnings("serial")
240 public static class InterfaceProxyException2 extends Exception {
241 }
242 }
243
244 @Rest(callLogger=BasicDisabledCallLogger.class)
245 @SerializerConfig(addRootType="true",addBeanTypes="true")
246 public static class InterfaceProxyResource extends BasicRestServlet {
247 private static final long serialVersionUID = 1L;
248
249
250
251
252 @RestOp(method=RRPC,path="/proxy/*")
253 public InterfaceProxy proxy() {
254 return new InterfaceProxy() {
255
256
257
258
259
260
261
262 @Override
263 public void returnVoid() {}
264
265 @Override
266 public Integer returnInteger() {
267 return 1;
268 }
269
270 @Override
271 public int returnInt() {
272 return 1;
273 }
274
275 @Override
276 public boolean returnBoolean() {
277 return true;
278 }
279
280 @Override
281 public float returnFloat() {
282 return 1f;
283 }
284
285 @Override
286 public Float returnFloatObject() {
287 return 1f;
288 }
289
290 @Override
291 public String returnString() {
292 return "foobar";
293 }
294
295 @Override
296 public String returnNullString() {
297 return null;
298 }
299
300 @Override
301 public int[][][] returnInt3dArray() {
302 return new int[][][]{{{1,2},null},null};
303 }
304
305 @Override
306 public Integer[][][] returnInteger3dArray() {
307 return new Integer[][][]{{{1,null},null},null};
308 }
309
310 @Override
311 public String[][][] returnString3dArray() {
312 return new String[][][]{{{"foo","bar",null},null},null};
313 }
314
315 @Override
316 public List<Integer> returnIntegerList() {
317 return asList(new Integer[]{1,null});
318 }
319
320 @Override
321 public List<List<List<Integer>>> returnInteger3dList() {
322 return alist(alist(alist(1,null),null),null);
323 }
324
325 @Override
326 public List<Integer[][][]> returnInteger1d3dList() {
327 return alist(new Integer[][][]{{{1,null},null},null},null);
328 }
329
330 @Override
331 public List<int[][][]> returnInt1d3dList() {
332 return alist(new int[][][]{{{1,2},null},null},null);
333 }
334
335 @Override
336 public List<String> returnStringList() {
337 return asList(new String[]{"foo","bar",null});
338 }
339
340
341
342 @Override
343 public ABean returnBean() {
344 return ABean.get();
345 }
346
347 @Override
348 public ABean[][][] returnBean3dArray() {
349 return new ABean[][][]{{{ABean.get(),null},null},null};
350 }
351
352 @Override
353 public List<ABean> returnBeanList() {
354 return asList(ABean.get());
355 }
356
357 @Override
358 public List<ABean[][][]> returnBean1d3dList() {
359 return alist(new ABean[][][]{{{ABean.get(),null},null},null},null);
360 }
361
362 @Override
363 public Map<String,ABean> returnBeanMap() {
364 return map("foo",ABean.get());
365 }
366
367 @Override
368 public Map<String,List<ABean>> returnBeanListMap() {
369 return map("foo",asList(ABean.get()));
370 }
371
372 @Override
373 public Map<String,List<ABean[][][]>> returnBean1d3dListMap() {
374 return map("foo",alist(new ABean[][][]{{{ABean.get(),null},null},null},null));
375 }
376
377 @Override
378 public Map<Integer,List<ABean>> returnBeanListMapIntegerKeys() {
379 return map(1,asList(ABean.get()));
380 }
381
382
383
384 @Override
385 public TypedBean returnTypedBean() {
386 return TypedBeanImpl.get();
387 }
388
389 @Override
390 public TypedBean[][][] returnTypedBean3dArray() {
391 return new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null};
392 }
393
394 @Override
395 public List<TypedBean> returnTypedBeanList() {
396 return asList((TypedBean)TypedBeanImpl.get());
397 }
398
399 @Override
400 public List<TypedBean[][][]> returnTypedBean1d3dList() {
401 return alist(new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null},null);
402 }
403
404 @Override
405 public Map<String,TypedBean> returnTypedBeanMap() {
406 return map("foo",TypedBeanImpl.get());
407 }
408
409 @Override
410 public Map<String,List<TypedBean>> returnTypedBeanListMap() {
411 return map("foo",asList((TypedBean)TypedBeanImpl.get()));
412 }
413
414 @Override
415 public Map<String,List<TypedBean[][][]>> returnTypedBean1d3dListMap() {
416 return map("foo",alist(new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null},null));
417 }
418
419 @Override
420 public Map<Integer,List<TypedBean>> returnTypedBeanListMapIntegerKeys() {
421 return map(1,asList((TypedBean)TypedBeanImpl.get()));
422 }
423
424
425
426 @Override
427 public SwappedObject returnSwappedObject() {
428 return new SwappedObject();
429 }
430
431 @Override
432 public SwappedObject[][][] returnSwappedObject3dArray() {
433 return new SwappedObject[][][]{{{new SwappedObject(),null},null},null};
434 }
435
436 @Override
437 public Map<SwappedObject,SwappedObject> returnSwappedObjectMap() {
438 return map(new SwappedObject(),new SwappedObject());
439 }
440
441 @Override
442 public Map<SwappedObject,SwappedObject[][][]> returnSwappedObject3dMap() {
443 return map(new SwappedObject(),new SwappedObject[][][]{{{new SwappedObject(),null},null},null});
444 }
445
446
447
448 @Override
449 public ImplicitSwappedObject returnImplicitSwappedObject() {
450 return new ImplicitSwappedObject();
451 }
452
453 @Override
454 public ImplicitSwappedObject[][][] returnImplicitSwappedObject3dArray() {
455 return new ImplicitSwappedObject[][][]{{{new ImplicitSwappedObject(),null},null},null};
456 }
457
458 @Override
459 public Map<ImplicitSwappedObject,ImplicitSwappedObject> returnImplicitSwappedObjectMap() {
460 return map(new ImplicitSwappedObject(),new ImplicitSwappedObject());
461 }
462
463 @Override
464 public Map<ImplicitSwappedObject,ImplicitSwappedObject[][][]> returnImplicitSwappedObject3dMap() {
465 return map(new ImplicitSwappedObject(),new ImplicitSwappedObject[][][]{{{new ImplicitSwappedObject(),null},null},null});
466 }
467
468
469
470 @Override
471 public TestEnum returnEnum() {
472 return TestEnum.TWO;
473 }
474
475 @Override
476 public TestEnum[][][] returnEnum3d() {
477 return new TestEnum[][][]{{{TestEnum.TWO,null},null},null};
478 }
479
480 @Override
481 public List<TestEnum> returnEnumList() {
482 return alist(TestEnum.TWO,null);
483 }
484
485 @Override
486 public List<List<List<TestEnum>>> returnEnum3dList() {
487 return alist(alist(alist(TestEnum.TWO,null),null),null);
488 }
489
490 @Override
491 public List<TestEnum[][][]> returnEnum1d3dList() {
492 return alist(new TestEnum[][][]{{{TestEnum.TWO,null},null},null},null);
493 }
494
495 @Override
496 public Map<TestEnum,TestEnum> returnEnumMap() {
497 return map(TestEnum.ONE,TestEnum.TWO);
498 }
499
500 @Override
501 public Map<TestEnum,TestEnum[][][]> returnEnum3dArrayMap() {
502 return map(TestEnum.ONE,new TestEnum[][][]{{{TestEnum.TWO,null},null},null});
503 }
504
505 @Override
506 public Map<TestEnum,List<TestEnum[][][]>> returnEnum1d3dListMap() {
507 return map(TestEnum.ONE,alist(new TestEnum[][][]{{{TestEnum.TWO,null},null},null},null));
508 }
509
510
511
512
513
514 @Override
515 public void throwException1() throws InterfaceProxy.InterfaceProxyException1 {
516 throw new InterfaceProxy.InterfaceProxyException1("foo");
517 }
518
519 @Override
520 public void throwException2() throws InterfaceProxy.InterfaceProxyException2 {
521 throw new InterfaceProxy.InterfaceProxyException2();
522 }
523
524
525
526
527
528
529
530 @Override
531 public void setNothing() {}
532
533 @Override
534 public void setInt(int v) {
535 assertEquals(1,v);
536 }
537
538 @Override
539 public void setInteger(Integer v) {
540 assertEquals((Integer)1,v);
541 }
542
543 @Override
544 public void setBoolean(boolean v) {
545 assertTrue(v);
546 }
547
548 @Override
549 public void setFloat(float v) {
550 assertEquals(1f, v, 0.1f);
551 }
552
553 @Override
554 public void setFloatObject(Float v) {
555 assertEquals(1f, v, 0.1f);
556 }
557
558 @Override
559 public void setString(String v) {
560 assertEquals("foo",v);
561 }
562
563 @Override
564 public void setNullString(String v) {
565 assertNull(v);
566 }
567
568 @Override
569 public void setInt3dArray(int[][][] v) {
570 assertList(v, "[[1,2],<null>]", null);
571 }
572
573 @Override
574 public void setInteger3dArray(Integer[][][] v) {
575 assertList(v, "[[1,<null>],<null>]", null);
576 }
577
578 @Override
579 public void setString3dArray(String[][][] v) {
580 assertList(v, "[[foo,<null>],<null>]", null);
581 }
582
583 @Override
584 public void setIntegerList(List<Integer> v) {
585 assertList(v, "1", null);
586 assertInstanceOf(Integer.class, v.get(0));
587 }
588
589 @Override
590 public void setInteger3dList(List<List<List<Integer>>> v) {
591 assertList(v, "[[1,<null>],<null>]", null);
592 assertInstanceOf(Integer.class, v.get(0).get(0).get(0));
593 }
594
595 @Override
596 public void setInteger1d3dList(List<Integer[][][]> v) {
597 assertList(v, "[[[1,<null>],<null>],<null>]", null);
598 assertInstanceOf(Integer[][][].class, v.get(0));
599 assertInstanceOf(Integer.class, v.get(0)[0][0][0]);
600 }
601
602 @Override
603 public void setInt1d3dList(List<int[][][]> v) {
604 assertList(v, "[[[1,2],<null>],<null>]", null);
605 assertInstanceOf(int[][][].class, v.get(0));
606 }
607
608 @Override
609 public void setStringList(List<String> v) {
610 assertList(v, "foo", "bar", null);
611 }
612
613
614
615 @Override
616 public void setBean(ABean v) {
617 assertBean(v, "a,b", "1,foo");
618 }
619
620 @Override
621 public void setBean3dArray(ABean[][][] v) {
622 assertList(v, "[[{a:1,b:'foo'},<null>],<null>]",null);
623 }
624
625 @Override
626 public void setBeanList(List<ABean> v) {
627 assertList(v, "{a:1,b:'foo'}");
628 }
629
630 @Override
631 public void setBean1d3dList(List<ABean[][][]> v) {
632 assertList(v, "[[[{a:1,b:'foo'},<null>],<null>],<null>]", null);
633 }
634
635 @Override
636 public void setBeanMap(Map<String,ABean> v) {
637 assertMap(v, "foo", "{a:1,b:'foo'}");
638 }
639
640 @Override
641 public void setBeanListMap(Map<String,List<ABean>> v) {
642 assertMap(v, "foo", "[{a:1,b:'foo'}]");
643 }
644
645 @Override
646 public void setBean1d3dListMap(Map<String,List<ABean[][][]>> v) {
647 assertMap(v, "foo", "[[[[{a:1,b:'foo'},<null>],<null>],<null>],<null>]");
648 }
649
650 @Override
651 public void setBeanListMapIntegerKeys(Map<Integer,List<ABean>> v) {
652 assertList(v, "1=[{a:1,b:'foo'}]");
653 assertInstanceOf(Integer.class, v.keySet().iterator().next());
654 }
655
656
657
658 @Override
659 public void setTypedBean(TypedBean v) {
660 assertBean(v, "a,b", "1,foo");
661 assertInstanceOf(TypedBeanImpl.class, v);
662 }
663
664 @Override
665 public void setTypedBean3dArray(TypedBean[][][] v) {
666 assertList(v, "[[a:1;b:foo,<null>],<null>]" ,null);
667 assertInstanceOf(TypedBeanImpl.class, v[0][0][0]);
668 }
669
670 @Override
671 public void setTypedBeanList(List<TypedBean> v) {
672 assertList(v, "a:1;b:foo");
673 assertInstanceOf(TypedBeanImpl.class, v.get(0));
674 }
675
676 @Override
677 public void setTypedBean1d3dList(List<TypedBean[][][]> v) {
678 assertList(v, "[[[a:1;b:foo,<null>],<null>],<null>]", null);
679 assertInstanceOf(TypedBeanImpl.class, v.get(0)[0][0][0]);
680 }
681
682 @Override
683 public void setTypedBeanMap(Map<String,TypedBean> v) {
684 assertMap(v, "foo", "a:1;b:foo");
685 assertInstanceOf(TypedBeanImpl.class, v.get("foo"));
686 }
687
688 @Override
689 public void setTypedBeanListMap(Map<String,List<TypedBean>> v) {
690 assertMap(v, "foo", "[a:1;b:foo]");
691 assertInstanceOf(TypedBeanImpl.class, v.get("foo").get(0));
692 }
693
694 @Override
695 public void setTypedBean1d3dListMap(Map<String,List<TypedBean[][][]>> v) {
696 assertMap(v, "foo", "[[[[a:1;b:foo,<null>],<null>],<null>],<null>]");
697 assertInstanceOf(TypedBeanImpl.class, v.get("foo").get(0)[0][0][0]);
698 }
699
700 @Override
701 public void setTypedBeanListMapIntegerKeys(Map<Integer,List<TypedBean>> v) {
702 assertList(v, "1=[a:1;b:foo]");
703 assertInstanceOf(TypedBeanImpl.class, v.get(1).get(0));
704 }
705
706
707
708 @Override
709 public void setSwappedObject(SwappedObject v) {
710 assertTrue(v.wasUnswapped);
711 }
712
713 @Override
714 public void setSwappedObject3dArray(SwappedObject[][][] v) {
715 assertList(v, "[[wasUnswapped:true,<null>],<null>]" ,null);
716 assertTrue(v[0][0][0].wasUnswapped);
717 }
718
719 @Override
720 public void setSwappedObjectMap(Map<SwappedObject,SwappedObject> v) {
721 assertList(v, "wasUnswapped:true=wasUnswapped:true");
722 var e = v.entrySet().iterator().next();
723 assertTrue(e.getKey().wasUnswapped);
724 assertTrue(e.getValue().wasUnswapped);
725 }
726
727 @Override
728 public void setSwappedObject3dMap(Map<SwappedObject,SwappedObject[][][]> v) {
729 assertList(v, "wasUnswapped:true=[[[wasUnswapped:true,<null>],<null>],<null>]");
730 var e = v.entrySet().iterator().next();
731 assertTrue(e.getKey().wasUnswapped);
732 assertTrue(e.getValue()[0][0][0].wasUnswapped);
733 }
734
735
736
737 @Override
738 public void setImplicitSwappedObject(ImplicitSwappedObject v) {
739 assertTrue(v.wasUnswapped);
740 }
741
742 @Override
743 public void setImplicitSwappedObject3dArray(ImplicitSwappedObject[][][] v) {
744 assertList(v, "[["+SWAP+",<null>],<null>]", null);
745 assertTrue(v[0][0][0].wasUnswapped);
746 }
747
748 @Override
749 public void setImplicitSwappedObjectMap(Map<ImplicitSwappedObject,ImplicitSwappedObject> v) {
750 assertList(v, SWAP+"="+SWAP);
751 var e = v.entrySet().iterator().next();
752 assertTrue(e.getKey().wasUnswapped);
753 assertTrue(e.getValue().wasUnswapped);
754 }
755
756 @Override
757 public void setImplicitSwappedObject3dMap(Map<ImplicitSwappedObject,ImplicitSwappedObject[][][]> v) {
758 assertList(v, SWAP+"=[[["+SWAP+",<null>],<null>],<null>]");
759 var e = v.entrySet().iterator().next();
760 assertTrue(e.getKey().wasUnswapped);
761 assertTrue(e.getValue()[0][0][0].wasUnswapped);
762 }
763
764
765
766 @Override
767 public void setEnum(TestEnum v) {
768 assertEquals(TestEnum.TWO,v);
769 }
770
771 @Override
772 public void setEnum3d(TestEnum[][][] v) {
773 assertList(v, "[[TWO,<null>],<null>]", null);
774 }
775
776 @Override
777 public void setEnumList(List<TestEnum> v) {
778 assertList(v, "TWO", null);
779 assertInstanceOf(TestEnum.class, v.get(0));
780 }
781
782 @Override
783 public void setEnum3dList(List<List<List<TestEnum>>> v) {
784 assertList(v, "[[TWO,<null>],<null>]", null);
785 assertInstanceOf(TestEnum.class, v.get(0).get(0).get(0));
786 }
787
788 @Override
789 public void setEnum1d3dList(List<TestEnum[][][]> v) {
790 assertList(v, "[[[TWO,<null>],<null>],<null>]", null);
791 assertInstanceOf(TestEnum[][][].class, v.get(0));
792 }
793
794 @Override
795 public void setEnumMap(Map<TestEnum,TestEnum> v) {
796 assertList(v, "ONE=TWO");
797 var e = v.entrySet().iterator().next();
798 assertInstanceOf(TestEnum.class, e.getKey());
799 assertInstanceOf(TestEnum.class, e.getValue());
800 }
801
802 @Override
803 public void setEnum3dArrayMap(Map<TestEnum,TestEnum[][][]> v) {
804 assertList(v, "ONE=[[[TWO,<null>],<null>],<null>]");
805 var e = v.entrySet().iterator().next();
806 assertInstanceOf(TestEnum.class, e.getKey());
807 assertInstanceOf(TestEnum[][][].class, e.getValue());
808 }
809
810 @Override
811 public void setEnum1d3dListMap(Map<TestEnum,List<TestEnum[][][]>> v) {
812 assertList(v, "ONE=[[[[TWO,<null>],<null>],<null>],<null>]");
813 Map.Entry<TestEnum,List<TestEnum[][][]>> e = v.entrySet().iterator().next();
814 assertInstanceOf(TestEnum.class, e.getKey());
815 assertInstanceOf(TestEnum[][][].class, e.getValue().get(0));
816 }
817
818
819
820
821
822 @Override
823 public void setMultiParamsInts(int x1,int[][][] x2,int[][][] x2n,List<int[][][]> x3,List<int[][][]> x3n) {
824 assertEquals(1, x1);
825 assertList(x2, "[[1,2],<null>]" ,null);
826 assertNull(x2n);
827 assertList(x3, "[[[1,2],<null>],<null>]", null);
828 assertInstanceOf(int[][][].class, x3.get(0));
829 assertNull(x3n);
830 }
831
832 @Override
833 public void setMultiParamsInteger(Integer x1,Integer x1n,Integer[][][] x2,Integer[][][] x2n,List<Integer[][][]> x3,List<Integer[][][]> x3n) {
834 assertEquals((Integer)1, x1);
835 assertList(x2, "[[1,<null>],<null>]", null);
836 assertNull(x2n);
837 assertList(x3, "[[[1,<null>],<null>],<null>]", null);
838 assertInstanceOf(Integer[][][].class, x3.get(0));
839 assertNull(x3n);
840 }
841
842 @Override
843 public void setMultiParamsFloat(float x1,float[][][] x2,float[][][] x2n,List<float[][][]> x3,List<float[][][]> x3n) {
844 assertEquals(1.0f, x1, 0.1f);
845 assertList(x2, "[[1.0,2.0],<null>]", null);
846 assertNull(x2n);
847 assertList(x3, "[[[1.0,2.0],<null>],<null>]", null);
848 assertInstanceOf(float[][][].class, x3.get(0));
849 assertNull(x3n);
850 }
851
852 @Override
853 public void setMultiParamsFloatObject(Float x1,Float x1n,Float[][][] x2,Float[][][] x2n,List<Float[][][]> x3,List<Float[][][]> x3n) {
854 assertEquals(1.0f, x1, 0.1f);
855 assertList(x2, "[[1.0,<null>],<null>]", null);
856 assertNull(x2n);
857 assertList(x3, "[[[1.0,<null>],<null>],<null>]", null);
858 assertInstanceOf(Float[][][].class, x3.get(0));
859 assertNull(x3n);
860 }
861
862 @Override
863 public void setMultiParamsString(String x1,String[][][] x2,String[][][] x2n,List<String[][][]> x3,List<String[][][]> x3n) {
864 assertEquals("foo", x1);
865 assertList(x2, "[[foo,<null>],<null>]", null);
866 assertNull(x2n);
867 assertList(x3, "[[[foo,<null>],<null>],<null>]", null);
868 assertInstanceOf(String[][][].class, x3.get(0));
869 assertNull(x3n);
870 }
871
872 @Override
873 public void setMultiParamsBean(ABean x1,ABean[][][] x2,ABean[][][] x2n,List<ABean[][][]> x3,List<ABean[][][]> x3n,Map<String,ABean> x4,Map<String,ABean> x4n,Map<String,List<ABean[][][]>> x5,Map<String,List<ABean[][][]>> x5n) {
874 assertBean(x1, "a,b", "1,foo");
875 assertList(x2, "[[{a:1,b:'foo'},<null>],<null>]", null);
876 assertNull(x2n);
877 assertList(x3, "[[[{a:1,b:'foo'},<null>],<null>],<null>]", null);
878 assertInstanceOf(ABean[][][].class, x3.get(0));
879 assertNull(x3n);
880 assertList(x4, "foo={a:1,b:'foo'}");
881 assertNull(x4n);
882 assertList(x5, "foo=[[[[{a:1,b:'foo'},<null>],<null>],<null>],<null>]");
883 assertNull(x5n);
884 }
885
886 @Override
887 public void setMultiParamsSwappedObject(SwappedObject x1,SwappedObject[][][] x2,SwappedObject[][][] x2n,List<SwappedObject[][][]> x3,List<SwappedObject[][][]> x3n,Map<SwappedObject,SwappedObject> x4,Map<SwappedObject,SwappedObject> x4n,Map<SwappedObject,List<SwappedObject[][][]>> x5,Map<SwappedObject,List<SwappedObject[][][]>> x5n) {
888 assertTrue(x1.wasUnswapped);
889 assertList(x2, "[[wasUnswapped:true,<null>],<null>]", null);
890 assertNull(x2n);
891 assertList(x3, "[[[wasUnswapped:true,<null>],<null>],<null>]", null);
892 assertInstanceOf(SwappedObject[][][].class, x3.get(0));
893 assertNull(x3n);
894 assertList(x4, "wasUnswapped:true=wasUnswapped:true");
895 assertNull(x4n);
896 assertList(x5, "wasUnswapped:true=[[[[wasUnswapped:true,<null>],<null>],<null>],<null>]");
897 assertNull(x5n);
898 }
899
900 @Override
901 public void setMultiParamsImplicitSwappedObject(ImplicitSwappedObject x1,ImplicitSwappedObject[][][] x2,ImplicitSwappedObject[][][] x2n,List<ImplicitSwappedObject[][][]> x3,List<ImplicitSwappedObject[][][]> x3n,Map<ImplicitSwappedObject,ImplicitSwappedObject> x4,Map<ImplicitSwappedObject,ImplicitSwappedObject> x4n,Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5,Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5n) {
902 assertTrue(x1.wasUnswapped);
903 assertList(x2, "[["+SWAP+",<null>],<null>]", null);
904 assertNull(x2n);
905 assertList(x3, "[[["+SWAP+",<null>],<null>],<null>]", null);
906 assertInstanceOf(ImplicitSwappedObject[][][].class, x3.get(0));
907 assertNull(x3n);
908 assertList(x4, SWAP+"="+SWAP);
909 assertNull(x4n);
910 assertList(x5, SWAP+"=[[[["+SWAP+",<null>],<null>],<null>],<null>]");
911 assertNull(x5n);
912 }
913
914 @Override
915 public void setMultiParamsEnum(TestEnum x1,TestEnum[][][] x2,TestEnum[][][] x2n,List<TestEnum[][][]> x3,List<TestEnum[][][]> x3n,Map<TestEnum,TestEnum> x4,Map<TestEnum,TestEnum> x4n,Map<TestEnum,List<TestEnum[][][]>> x5,Map<TestEnum,List<TestEnum[][][]>> x5n) {
916 assertEquals(TestEnum.TWO, x1);
917 assertList(x2, "[[TWO,<null>],<null>]", null);
918 assertNull(x2n);
919 assertList(x3, "[[[TWO,<null>],<null>],<null>]", null);
920 assertInstanceOf(TestEnum[][][].class, x3.get(0));
921 assertNull(x3n);
922 assertList(x4, "ONE=TWO");
923 assertNull(x4n);
924 assertList(x5, "ONE=[[[[TWO,<null>],<null>],<null>],<null>]");
925 assertNull(x5n);
926 }
927 };
928 }
929 }
930
931
932
933
934
935
936 @ParameterizedTest
937 @MethodSource("input")
938 void a01_returnVoid(Input input) {
939 assertDoesNotThrow(()->input.proxy.returnVoid());
940 }
941
942 @ParameterizedTest
943 @MethodSource("input")
944 void a02_returnInteger(Input input) {
945 assertEquals((Integer)1, input.proxy.returnInteger());
946 }
947
948 @ParameterizedTest
949 @MethodSource("input")
950 void a03_returnInt(Input input) {
951 assertEquals(1, input.proxy.returnInt());
952 }
953
954 @ParameterizedTest
955 @MethodSource("input")
956 void a04_returnBoolean(Input input) {
957 assertEquals(true, input.proxy.returnBoolean());
958 }
959
960 @ParameterizedTest
961 @MethodSource("input")
962 void a05_returnFloat(Input input) {
963 assertEquals(1f, input.proxy.returnFloat(), 0.1f);
964 }
965
966 @ParameterizedTest
967 @MethodSource("input")
968 void a06_returnFloatObject(Input input) {
969 assertEquals(1f, input.proxy.returnFloatObject(), 0.1f);
970 }
971
972 @ParameterizedTest
973 @MethodSource("input")
974 void a07_returnString(Input input) {
975 assertEquals("foobar",input.proxy.returnString());
976 }
977
978 @ParameterizedTest
979 @MethodSource("input")
980 void a08_returnNullString(Input input) {
981 assertNull(input.proxy.returnNullString());
982 }
983
984 @ParameterizedTest
985 @MethodSource("input")
986 void a09_returnInt3dArray(Input input) {
987 assertList(input.proxy.returnInt3dArray(), "[[1,2],<null>]", null);
988 }
989
990 @ParameterizedTest
991 @MethodSource("input")
992 void a10_returnInteger3dArray(Input input) {
993 assertList(input.proxy.returnInteger3dArray(), "[[1,<null>],<null>]", null);
994 }
995
996 @ParameterizedTest
997 @MethodSource("input")
998 void a11_returnString3dArray(Input input) {
999 assertList(input.proxy.returnString3dArray(), "[[foo,bar,<null>],<null>]", null);
1000 }
1001
1002 @ParameterizedTest
1003 @MethodSource("input")
1004 void a12_returnIntegerList(Input input) {
1005 var x = input.proxy.returnIntegerList();
1006 assertList(x, "1", null);
1007 assertInstanceOf(Integer.class, x.get(0));
1008 }
1009
1010 @ParameterizedTest
1011 @MethodSource("input")
1012 void a13_returnInteger3dList(Input input) {
1013 var x = input.proxy.returnInteger3dList();
1014 assertList(x, "[[1,<null>],<null>]", null);
1015 assertInstanceOf(Integer.class, x.get(0).get(0).get(0));
1016 }
1017
1018 @ParameterizedTest
1019 @MethodSource("input")
1020 void a14_returnInteger1d3dList(Input input) {
1021 var x = input.proxy.returnInteger1d3dList();
1022 assertList(x, "[[[1,<null>],<null>],<null>]", null);
1023 assertInstanceOf(Integer.class, x.get(0)[0][0][0]);
1024 }
1025
1026 @ParameterizedTest
1027 @MethodSource("input")
1028 void a15_returnInt1d3dList(Input input) {
1029 var x = input.proxy.returnInt1d3dList();
1030 assertList(x, "[[[1,2],<null>],<null>]", null);
1031 assertInstanceOf(int[][][].class, x.get(0));
1032 }
1033
1034 @ParameterizedTest
1035 @MethodSource("input")
1036 void a16_returnStringList(Input input) {
1037 assertList(input.proxy.returnStringList(), "foo", "bar", null);
1038 }
1039
1040
1041
1042 @ParameterizedTest
1043 @MethodSource("input")
1044 void b01_returnBean(Input input) {
1045 var x = input.proxy.returnBean();
1046 assertBean(x, "a,b", "1,foo");
1047 assertInstanceOf(ABean.class, x);
1048 }
1049
1050 @ParameterizedTest
1051 @MethodSource("input")
1052 void b02_returnBean3dArray(Input input) {
1053 var x = input.proxy.returnBean3dArray();
1054 assertList(x, "[[{a:1,b:'foo'},<null>],<null>]", null);
1055 assertInstanceOf(ABean.class, x[0][0][0]);
1056 }
1057
1058 @ParameterizedTest
1059 @MethodSource("input")
1060 void b03_returnBeanList(Input input) {
1061 var x = input.proxy.returnBeanList();
1062 assertList(x, "{a:1,b:'foo'}");
1063 assertInstanceOf(ABean.class, x.get(0));
1064 }
1065
1066 @ParameterizedTest
1067 @MethodSource("input")
1068 void b04_returnBean1d3dList(Input input) {
1069 var x = input.proxy.returnBean1d3dList();
1070 assertList(x, "[[[{a:1,b:'foo'},<null>],<null>],<null>]", null);
1071 assertInstanceOf(ABean.class, x.get(0)[0][0][0]);
1072 }
1073
1074 @ParameterizedTest
1075 @MethodSource("input")
1076 void b05_returnBeanMap(Input input) {
1077 var x = input.proxy.returnBeanMap();
1078 assertMap(x, "foo", "{a:1,b:'foo'}");
1079 assertInstanceOf(ABean.class, x.get("foo"));
1080 }
1081
1082 @ParameterizedTest
1083 @MethodSource("input")
1084 void b06_returnBeanListMap(Input input) {
1085 var x = input.proxy.returnBeanListMap();
1086 assertMap(x, "foo", "[{a:1,b:'foo'}]");
1087 assertInstanceOf(ABean.class, x.get("foo").get(0));
1088 }
1089
1090 @ParameterizedTest
1091 @MethodSource("input")
1092 void b07_returnBean1d3dListMap(Input input) {
1093 var x = input.proxy.returnBean1d3dListMap();
1094 assertMap(x, "foo", "[[[[{a:1,b:'foo'},<null>],<null>],<null>],<null>]");
1095 assertInstanceOf(ABean.class, x.get("foo").get(0)[0][0][0]);
1096 }
1097
1098 @ParameterizedTest
1099 @MethodSource("input")
1100 void b08_returnBeanListMapIntegerKeys(Input input) {
1101
1102 var x = input.proxy.returnBeanListMapIntegerKeys();
1103 assertList(x, "1=[{a:1,b:'foo'}]");
1104 assertInstanceOf(Integer.class, x.keySet().iterator().next());
1105 }
1106
1107
1108
1109 @ParameterizedTest
1110 @MethodSource("input")
1111 void c01_returnTypedBean(Input input) {
1112 var x = input.proxy.returnTypedBean();
1113 assertBean(x, "a,b", "1,foo");
1114 assertInstanceOf(TypedBeanImpl.class, x);
1115 }
1116
1117 @ParameterizedTest
1118 @MethodSource("input")
1119 void c02_returnTypedBean3dArray(Input input) {
1120 var x = input.proxy.returnTypedBean3dArray();
1121 assertList(x, "[[a:1;b:foo,<null>],<null>]", null);
1122 assertInstanceOf(TypedBeanImpl.class, x[0][0][0]);
1123 }
1124
1125 @ParameterizedTest
1126 @MethodSource("input")
1127 void c03_returnTypedBeanList(Input input) {
1128 var x = input.proxy.returnTypedBeanList();
1129 assertList(x, "a:1;b:foo");
1130 assertInstanceOf(TypedBeanImpl.class, x.get(0));
1131 }
1132
1133 @ParameterizedTest
1134 @MethodSource("input")
1135 void c04_returnTypedBean1d3dList(Input input) {
1136 var x = input.proxy.returnTypedBean1d3dList();
1137 assertList(x, "[[[a:1;b:foo,<null>],<null>],<null>]", null);
1138 assertInstanceOf(TypedBeanImpl.class, x.get(0)[0][0][0]);
1139 }
1140
1141 @ParameterizedTest
1142 @MethodSource("input")
1143 void c05_returnTypedBeanMap(Input input) {
1144 var x = input.proxy.returnTypedBeanMap();
1145 assertMap(x, "foo", "a:1;b:foo");
1146 assertInstanceOf(TypedBeanImpl.class, x.get("foo"));
1147 }
1148
1149 @ParameterizedTest
1150 @MethodSource("input")
1151 void c06_returnTypedBeanListMap(Input input) {
1152 var x = input.proxy.returnTypedBeanListMap();
1153 assertMap(x, "foo", "[a:1;b:foo]");
1154 assertInstanceOf(TypedBeanImpl.class, x.get("foo").get(0));
1155 }
1156
1157 @ParameterizedTest
1158 @MethodSource("input")
1159 void c07_returnTypedBean1d3dListMap(Input input) {
1160 var x = input.proxy.returnTypedBean1d3dListMap();
1161 assertMap(x, "foo", "[[[[a:1;b:foo,<null>],<null>],<null>],<null>]");
1162 assertInstanceOf(TypedBeanImpl.class, x.get("foo").get(0)[0][0][0]);
1163 }
1164
1165 @ParameterizedTest
1166 @MethodSource("input")
1167 void c08_returnTypedBeanListMapIntegerKeys(Input input) {
1168
1169 var x = input.proxy.returnTypedBeanListMapIntegerKeys();
1170 assertList(x, "1=[a:1;b:foo]");
1171 assertInstanceOf(TypedBeanImpl.class, x.get(1).get(0));
1172 }
1173
1174
1175
1176 @ParameterizedTest
1177 @MethodSource("input")
1178 void d01_returnSwappedObject(Input input) {
1179 var x = input.proxy.returnSwappedObject();
1180 assertTrue(x.wasUnswapped);
1181 }
1182
1183 @ParameterizedTest
1184 @MethodSource("input")
1185 void d02_returnSwappedObject3dArray(Input input) {
1186 var x = input.proxy.returnSwappedObject3dArray();
1187 assertList(x, "[[wasUnswapped:true,<null>],<null>]", null);
1188 assertTrue(x[0][0][0].wasUnswapped);
1189 }
1190
1191 @ParameterizedTest
1192 @MethodSource("input")
1193 void d03_returnSwappedObjectMap(Input input) {
1194 var x = input.proxy.returnSwappedObjectMap();
1195 assertList(x, "wasUnswapped:true=wasUnswapped:true");
1196 var e = x.entrySet().iterator().next();
1197 assertTrue(e.getKey().wasUnswapped);
1198 assertTrue(e.getValue().wasUnswapped);
1199 }
1200
1201 @ParameterizedTest
1202 @MethodSource("input")
1203 void d04_returnSwappedObject3dMap(Input input) {
1204 var x = input.proxy.returnSwappedObject3dMap();
1205 assertList(x, "wasUnswapped:true=[[[wasUnswapped:true,<null>],<null>],<null>]");
1206 var e = x.entrySet().iterator().next();
1207 assertTrue(e.getKey().wasUnswapped);
1208 assertTrue(e.getValue()[0][0][0].wasUnswapped);
1209 }
1210
1211
1212
1213 @ParameterizedTest
1214 @MethodSource("input")
1215 void e01_returnImplicitSwappedObject(Input input) {
1216 var x = input.proxy.returnImplicitSwappedObject();
1217 assertTrue(x.wasUnswapped);
1218 }
1219
1220 @ParameterizedTest
1221 @MethodSource("input")
1222 void e02_returnImplicitSwappedObject3dArray(Input input) {
1223 var x = input.proxy.returnImplicitSwappedObject3dArray();
1224 assertList(x, "[["+SWAP+",<null>],<null>]", null);
1225 assertTrue(x[0][0][0].wasUnswapped);
1226 }
1227
1228 @ParameterizedTest
1229 @MethodSource("input")
1230 void e03_returnImplicitSwappedObjectMap(Input input) {
1231 var x = input.proxy.returnImplicitSwappedObjectMap();
1232 assertList(x, SWAP+"="+SWAP);
1233 var e = x.entrySet().iterator().next();
1234 assertTrue(e.getKey().wasUnswapped);
1235 assertTrue(e.getValue().wasUnswapped);
1236 }
1237
1238 @ParameterizedTest
1239 @MethodSource("input")
1240 void e04_returnImplicitSwappedObject3dMap(Input input) {
1241 var x = input.proxy.returnImplicitSwappedObject3dMap();
1242 assertList(x, SWAP+"=[[["+SWAP+",<null>],<null>],<null>]");
1243 var e = x.entrySet().iterator().next();
1244 assertTrue(e.getKey().wasUnswapped);
1245 assertTrue(e.getValue()[0][0][0].wasUnswapped);
1246 }
1247
1248
1249
1250 @ParameterizedTest
1251 @MethodSource("input")
1252 void f01_returnEnum(Input input) {
1253 var x = input.proxy.returnEnum();
1254 assertEquals(TestEnum.TWO, x);
1255 }
1256
1257 @ParameterizedTest
1258 @MethodSource("input")
1259 void f02_returnEnum3d(Input input) {
1260 var x = input.proxy.returnEnum3d();
1261 assertList(x, "[[TWO,<null>],<null>]", null);
1262 assertInstanceOf(TestEnum.class, x[0][0][0]);
1263 }
1264
1265 @ParameterizedTest
1266 @MethodSource("input")
1267 void f03_returnEnumList(Input input) {
1268 var x = input.proxy.returnEnumList();
1269 assertList(x, "TWO", null);
1270 assertInstanceOf(TestEnum.class, x.get(0));
1271 }
1272
1273 @ParameterizedTest
1274 @MethodSource("input")
1275 void f04_returnEnum3dList(Input input) {
1276 var x = input.proxy.returnEnum3dList();
1277 assertList(x, "[[TWO,<null>],<null>]", null);
1278 assertInstanceOf(TestEnum.class, x.get(0).get(0).get(0));
1279 }
1280
1281 @ParameterizedTest
1282 @MethodSource("input")
1283 void f05_returnEnum1d3dList(Input input) {
1284 var x = input.proxy.returnEnum1d3dList();
1285 assertList(x, "[[[TWO,<null>],<null>],<null>]", null);
1286 assertInstanceOf(TestEnum[][][].class, x.get(0));
1287 }
1288
1289 @ParameterizedTest
1290 @MethodSource("input")
1291 void f06_returnEnumMap(Input input) {
1292 var x = input.proxy.returnEnumMap();
1293 assertList(x, "ONE=TWO");
1294 var e = x.entrySet().iterator().next();
1295 assertInstanceOf(TestEnum.class, e.getKey());
1296 assertInstanceOf(TestEnum.class, e.getValue());
1297 }
1298
1299 @ParameterizedTest
1300 @MethodSource("input")
1301 void f07_returnEnum3dArrayMap(Input input) {
1302 var x = input.proxy.returnEnum3dArrayMap();
1303 assertList(x, "ONE=[[[TWO,<null>],<null>],<null>]");
1304 var e = x.entrySet().iterator().next();
1305 assertInstanceOf(TestEnum.class, e.getKey());
1306 assertInstanceOf(TestEnum[][][].class, e.getValue());
1307 }
1308
1309 @ParameterizedTest
1310 @MethodSource("input")
1311 void f08_returnEnum1d3dListMap(Input input) {
1312 var x = input.proxy.returnEnum1d3dListMap();
1313 assertList(x, "ONE=[[[[TWO,<null>],<null>],<null>],<null>]");
1314 assertInstanceOf(TestEnum[][][].class, x.get(TestEnum.ONE).get(0));
1315 }
1316
1317
1318
1319
1320
1321 @ParameterizedTest
1322 @MethodSource("input")
1323 void g01_throwException1(Input input) {
1324 try {
1325 input.proxy.throwException1();
1326 fail();
1327 } catch (InterfaceProxy.InterfaceProxyException1 e) {
1328 assertEquals("foo",e.getMessage());
1329 }
1330 }
1331
1332 @SuppressWarnings("unused")
1333 @ParameterizedTest
1334 @MethodSource("input")
1335 void g02_throwException2(Input input) {
1336 try {
1337 input.proxy.throwException2();
1338 fail();
1339 } catch (InterfaceProxy.InterfaceProxyException2 e) {}
1340 }
1341
1342
1343
1344
1345
1346
1347 @ParameterizedTest
1348 @MethodSource("input")
1349 void h01_setNothing(Input input) {
1350 assertDoesNotThrow(()->input.proxy.setNothing());
1351 }
1352
1353 @ParameterizedTest
1354 @MethodSource("input")
1355 void h02_setInt(Input input) {
1356 assertDoesNotThrow(()->input.proxy.setInt(1));
1357 }
1358
1359 @ParameterizedTest
1360 @MethodSource("input")
1361 void h03_setWrongInt(Input input) {
1362 assertThrows(AssertionError.class, ()->input.proxy.setInt(2), "expected: <1> but was: <2>");
1363 }
1364
1365 @ParameterizedTest
1366 @MethodSource("input")
1367 void h04_setInteger(Input input) {
1368 assertDoesNotThrow(()->input.proxy.setInteger(1));
1369 }
1370
1371 @ParameterizedTest
1372 @MethodSource("input")
1373 void h05_setBoolean(Input input) {
1374 assertDoesNotThrow(()->input.proxy.setBoolean(true));
1375 }
1376
1377 @ParameterizedTest
1378 @MethodSource("input")
1379 void h06_setFloat(Input input) {
1380 assertDoesNotThrow(()->input.proxy.setFloat(1f));
1381 }
1382
1383 @ParameterizedTest
1384 @MethodSource("input")
1385 void h07_setFloatObject(Input input) {
1386 assertDoesNotThrow(()->input.proxy.setFloatObject(1f));
1387 }
1388
1389 @ParameterizedTest
1390 @MethodSource("input")
1391 void h08_setString(Input input) {
1392 assertDoesNotThrow(()->input.proxy.setString("foo"));
1393 }
1394
1395 @ParameterizedTest
1396 @MethodSource("input")
1397 void h09_setNullString(Input input) {
1398 assertDoesNotThrow(()->input.proxy.setNullString(null));
1399 }
1400
1401 @ParameterizedTest
1402 @MethodSource("input")
1403 void h10_setNullStringBad(Input input) {
1404 assertThrows(AssertionError.class, ()->input.proxy.setNullString("foo"), "expected: <null> but was: <foo>");
1405 }
1406
1407 @ParameterizedTest
1408 @MethodSource("input")
1409 void h11_setInt3dArray(Input input) {
1410 assertDoesNotThrow(()->input.proxy.setInt3dArray(new int[][][]{{{1,2},null},null}));
1411 }
1412
1413 @ParameterizedTest
1414 @MethodSource("input")
1415 void h12_setInteger3dArray(Input input) {
1416 assertDoesNotThrow(()->input.proxy.setInteger3dArray(new Integer[][][]{{{1,null},null},null}));
1417 }
1418
1419 @ParameterizedTest
1420 @MethodSource("input")
1421 void h13_setString3dArray(Input input) {
1422 assertDoesNotThrow(()->input.proxy.setString3dArray(new String[][][]{{{"foo",null},null},null}));
1423 }
1424
1425 @ParameterizedTest
1426 @MethodSource("input")
1427 void h14_setIntegerList(Input input) {
1428 assertDoesNotThrow(()->input.proxy.setIntegerList(alist(1,null)));
1429 }
1430
1431 @ParameterizedTest
1432 @MethodSource("input")
1433 void h15_setInteger3dList(Input input) {
1434 assertDoesNotThrow(()->input.proxy.setInteger3dList(alist(alist(alist(1,null),null),null)));
1435 }
1436
1437 @ParameterizedTest
1438 @MethodSource("input")
1439 void h16_setInteger1d3dList(Input input) {
1440 assertDoesNotThrow(()->input.proxy.setInteger1d3dList(alist(new Integer[][][]{{{1,null},null},null},null)));
1441 }
1442
1443 @ParameterizedTest
1444 @MethodSource("input")
1445 void h17_setInt1d3dList(Input input) {
1446 assertDoesNotThrow(()->input.proxy.setInt1d3dList(alist(new int[][][]{{{1,2},null},null},null)));
1447 }
1448
1449 @ParameterizedTest
1450 @MethodSource("input")
1451 void h18_setStringList(Input input) {
1452 assertDoesNotThrow(()->input.proxy.setStringList(Arrays.asList("foo","bar",null)));
1453 }
1454
1455
1456 @ParameterizedTest
1457 @MethodSource("input")
1458 void h19_setBean(Input input) {
1459 assertDoesNotThrow(()->input.proxy.setBean(ABean.get()));
1460 }
1461
1462 @ParameterizedTest
1463 @MethodSource("input")
1464 void h20_setBean3dArray(Input input) {
1465 assertDoesNotThrow(()->input.proxy.setBean3dArray(new ABean[][][]{{{ABean.get(),null},null},null}));
1466 }
1467
1468 @ParameterizedTest
1469 @MethodSource("input")
1470 void h21_setBeanList(Input input) {
1471 assertDoesNotThrow(()->input.proxy.setBeanList(Arrays.asList(ABean.get())));
1472 }
1473
1474 @ParameterizedTest
1475 @MethodSource("input")
1476 void h22_setBean1d3dList(Input input) {
1477 assertDoesNotThrow(()->input.proxy.setBean1d3dList(alist(new ABean[][][]{{{ABean.get(),null},null},null},null)));
1478 }
1479
1480 @ParameterizedTest
1481 @MethodSource("input")
1482 void h23_setBeanMap(Input input) {
1483 assertDoesNotThrow(()->input.proxy.setBeanMap(map("foo",ABean.get())));
1484 }
1485
1486 @ParameterizedTest
1487 @MethodSource("input")
1488 void h24_setBeanListMap(Input input) {
1489 assertDoesNotThrow(()->input.proxy.setBeanListMap(map("foo",Arrays.asList(ABean.get()))));
1490 }
1491
1492 @ParameterizedTest
1493 @MethodSource("input")
1494 void h25_setBean1d3dListMap(Input input) {
1495 assertDoesNotThrow(()->input.proxy.setBean1d3dListMap(map("foo",alist(new ABean[][][]{{{ABean.get(),null},null},null},null))));
1496 }
1497
1498 @ParameterizedTest
1499 @MethodSource("input")
1500 void h26_setBeanListMapIntegerKeys(Input input) {
1501 assertDoesNotThrow(()->input.proxy.setBeanListMapIntegerKeys(map(1,Arrays.asList(ABean.get()))));
1502 }
1503
1504
1505
1506 @ParameterizedTest
1507 @MethodSource("input")
1508 void i01_setTypedBean(Input input) {
1509 assertDoesNotThrow(()->input.proxy.setTypedBean(TypedBeanImpl.get()));
1510 }
1511
1512 @ParameterizedTest
1513 @MethodSource("input")
1514 void i02_setTypedBean3dArray(Input input) {
1515 assertDoesNotThrow(()->input.proxy.setTypedBean3dArray(new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null}));
1516 }
1517
1518 @ParameterizedTest
1519 @MethodSource("input")
1520 void i03_setTypedBeanList(Input input) {
1521 assertDoesNotThrow(()->input.proxy.setTypedBeanList(Arrays.asList((TypedBean)TypedBeanImpl.get())));
1522 }
1523
1524 @ParameterizedTest
1525 @MethodSource("input")
1526 void i04_setTypedBean1d3dList(Input input) {
1527 assertDoesNotThrow(()->input.proxy.setTypedBean1d3dList(alist(new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null},null)));
1528 }
1529
1530 @ParameterizedTest
1531 @MethodSource("input")
1532 void i05_setTypedBeanMap(Input input) {
1533 assertDoesNotThrow(()->input.proxy.setTypedBeanMap(map("foo",TypedBeanImpl.get())));
1534 }
1535
1536 @ParameterizedTest
1537 @MethodSource("input")
1538 void i06_setTypedBeanListMap(Input input) {
1539 assertDoesNotThrow(()->input.proxy.setTypedBeanListMap(map("foo",Arrays.asList((TypedBean)TypedBeanImpl.get()))));
1540 }
1541
1542 @ParameterizedTest
1543 @MethodSource("input")
1544 void i07_setTypedBean1d3dListMap(Input input) {
1545 assertDoesNotThrow(()->input.proxy.setTypedBean1d3dListMap(map("foo",alist(new TypedBean[][][]{{{TypedBeanImpl.get(),null},null},null},null))));
1546 }
1547
1548 @ParameterizedTest
1549 @MethodSource("input")
1550 void i08_setTypedBeanListMapIntegerKeys(Input input) {
1551 assertDoesNotThrow(()->input.proxy.setTypedBeanListMapIntegerKeys(map(1,Arrays.asList((TypedBean)TypedBeanImpl.get()))));
1552 }
1553
1554
1555
1556 @ParameterizedTest
1557 @MethodSource("input")
1558 void j01_setSwappedObject(Input input) {
1559 assertDoesNotThrow(()->input.proxy.setSwappedObject(new SwappedObject()));
1560 }
1561
1562 @ParameterizedTest
1563 @MethodSource("input")
1564 void j02_setSwappedObject3dArray(Input input) {
1565 assertDoesNotThrow(()->input.proxy.setSwappedObject3dArray(new SwappedObject[][][]{{{new SwappedObject(),null},null},null}));
1566 }
1567
1568 @ParameterizedTest
1569 @MethodSource("input")
1570 void j03_setSwappedObjectMap(Input input) {
1571 assertDoesNotThrow(()->input.proxy.setSwappedObjectMap(map(new SwappedObject(),new SwappedObject())));
1572 }
1573
1574 @ParameterizedTest
1575 @MethodSource("input")
1576 void j04_setSwappedObject3dMap(Input input) {
1577 assertDoesNotThrow(()->input.proxy.setSwappedObject3dMap(map(new SwappedObject(),new SwappedObject[][][]{{{new SwappedObject(),null},null},null})));
1578 }
1579
1580
1581 @ParameterizedTest
1582 @MethodSource("input")
1583 void k01_setImplicitSwappedObject(Input input) {
1584 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject(new ImplicitSwappedObject()));
1585 }
1586
1587 @ParameterizedTest
1588 @MethodSource("input")
1589 void k02_setImplicitSwappedObject3dArray(Input input) {
1590 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject3dArray(new ImplicitSwappedObject[][][]{{{new ImplicitSwappedObject(),null},null},null}));
1591 }
1592
1593 @ParameterizedTest
1594 @MethodSource("input")
1595 void k03_setImplicitSwappedObjectMap(Input input) {
1596 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObjectMap(map(new ImplicitSwappedObject(),new ImplicitSwappedObject())));
1597 }
1598
1599 @ParameterizedTest
1600 @MethodSource("input")
1601 void k04_setImplicitSwappedObject3dMap(Input input) {
1602 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject3dMap(map(new ImplicitSwappedObject(),new ImplicitSwappedObject[][][]{{{new ImplicitSwappedObject(),null},null},null})));
1603 }
1604
1605
1606
1607 @ParameterizedTest
1608 @MethodSource("input")
1609 void l01_setEnum(Input input) {
1610 assertDoesNotThrow(()->input.proxy.setEnum(TestEnum.TWO));
1611 }
1612
1613 @ParameterizedTest
1614 @MethodSource("input")
1615 void l02_setEnum3d(Input input) {
1616 assertDoesNotThrow(()->input.proxy.setEnum3d(new TestEnum[][][]{{{TestEnum.TWO,null},null},null}));
1617 }
1618
1619 @ParameterizedTest
1620 @MethodSource("input")
1621 void l03_setEnumList(Input input) {
1622 assertDoesNotThrow(()->input.proxy.setEnumList(alist(TestEnum.TWO,null)));
1623 }
1624
1625 @ParameterizedTest
1626 @MethodSource("input")
1627 void l04_setEnum3dList(Input input) {
1628 assertDoesNotThrow(()->input.proxy.setEnum3dList(alist(alist(alist(TestEnum.TWO,null),null),null)));
1629 }
1630
1631 @ParameterizedTest
1632 @MethodSource("input")
1633 void l05_setEnum1d3dList(Input input) {
1634 assertDoesNotThrow(()->input.proxy.setEnum1d3dList(alist(new TestEnum[][][]{{{TestEnum.TWO,null},null},null},null)));
1635 }
1636
1637 @ParameterizedTest
1638 @MethodSource("input")
1639 void l06_setEnumMap(Input input) {
1640 assertDoesNotThrow(()->input.proxy.setEnumMap(map(TestEnum.ONE,TestEnum.TWO)));
1641 }
1642
1643 @ParameterizedTest
1644 @MethodSource("input")
1645 void l07_setEnum3dArrayMap(Input input) {
1646 assertDoesNotThrow(()->input.proxy.setEnum3dArrayMap(map(TestEnum.ONE,new TestEnum[][][]{{{TestEnum.TWO,null},null},null})));
1647 }
1648
1649 @ParameterizedTest
1650 @MethodSource("input")
1651 void l08_setEnum1d3dListMap(Input input) {
1652 assertDoesNotThrow(()->input.proxy.setEnum1d3dListMap(map(TestEnum.ONE,alist(new TestEnum[][][]{{{TestEnum.TWO,null},null},null},null))));
1653 }
1654
1655
1656
1657
1658
1659 @ParameterizedTest
1660 @MethodSource("input")
1661 void m01_setMultiParamsInts(Input input) {
1662 var x1 = 1;
1663 var x2 = new int[][][]{{{1,2},null},null};
1664 int[][][] x2n = null;
1665 var x3 = alist(x2,null);
1666 List<int[][][]> x3n = null;
1667 assertDoesNotThrow(()->input.proxy.setMultiParamsInts(x1,x2,x2n,x3,x3n));
1668 }
1669
1670 @ParameterizedTest
1671 @MethodSource("input")
1672 void m02_setMultiParamsInteger(Input input) {
1673 var x1 = Integer.valueOf(1);
1674 Integer x1n = null;
1675 var x2 = new Integer[][][]{{{1,null},null},null};
1676 Integer[][][] x2n = null;
1677 var x3 = alist(x2,null);
1678 List<Integer[][][]> x3n = null;
1679 assertDoesNotThrow(()->input.proxy.setMultiParamsInteger(x1,x1n,x2,x2n,x3,x3n));
1680 }
1681
1682 @ParameterizedTest
1683 @MethodSource("input")
1684 void m03_setMultiParamsFloat(Input input) {
1685 var x1 = 1f;
1686 var x2 = new float[][][]{{{1,2},null},null};
1687 float[][][] x2n = null;
1688 var x3 = alist(x2,null);
1689 List<float[][][]> x3n = null;
1690 assertDoesNotThrow(()->input.proxy.setMultiParamsFloat(x1,x2,x2n,x3,x3n));
1691 }
1692
1693 @ParameterizedTest
1694 @MethodSource("input")
1695 void m04_setMultiParamsFloatObject(Input input) {
1696 var x1 = 1f;
1697 Float x1n = null;
1698 var x2 = new Float[][][]{{{1f,null},null},null};
1699 Float[][][] x2n = null;
1700 var x3 = alist(x2,null);
1701 List<Float[][][]> x3n = null;
1702 assertDoesNotThrow(()->input.proxy.setMultiParamsFloatObject(x1,x1n,x2,x2n,x3,x3n));
1703 }
1704
1705 @ParameterizedTest
1706 @MethodSource("input")
1707 void m05_setMultiParamsString(Input input) {
1708 var x1 = "foo";
1709 var x2 = new String[][][]{{{"foo",null},null},null};
1710 String[][][] x2n = null;
1711 var x3 = alist(x2,null);
1712 List<String[][][]> x3n = null;
1713 assertDoesNotThrow(()->input.proxy.setMultiParamsString(x1,x2,x2n,x3,x3n));
1714 }
1715
1716 @ParameterizedTest
1717 @MethodSource("input")
1718 void m06_setMultiParamsBean(Input input) {
1719 var x1 = ABean.get();
1720 var x2 = new ABean[][][]{{{ABean.get(),null},null},null};
1721 ABean[][][] x2n = null;
1722 var x3 = alist(x2,null);
1723 List<ABean[][][]> x3n = null;
1724 var x4 = CollectionUtils.map("foo",ABean.get());
1725 Map<String,ABean> x4n = null;
1726 var x5 = CollectionUtils.map("foo",x3);
1727 Map<String,List<ABean[][][]>> x5n = null;
1728 assertDoesNotThrow(()->input.proxy.setMultiParamsBean(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1729 }
1730
1731 @ParameterizedTest
1732 @MethodSource("input")
1733 void m07_setMultiParamsSwappedObject(Input input) {
1734 var x1 = new SwappedObject();
1735 var x2 = new SwappedObject[][][]{{{new SwappedObject(),null},null},null};
1736 SwappedObject[][][] x2n = null;
1737 var x3 = alist(x2,null);
1738 List<SwappedObject[][][]> x3n = null;
1739 var x4 = CollectionUtils.map(new SwappedObject(),new SwappedObject());
1740 Map<SwappedObject,SwappedObject> x4n = null;
1741 var x5 = CollectionUtils.map(new SwappedObject(),x3);
1742 Map<SwappedObject,List<SwappedObject[][][]>> x5n = null;
1743 assertDoesNotThrow(()->input.proxy.setMultiParamsSwappedObject(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1744 }
1745
1746 @ParameterizedTest
1747 @MethodSource("input")
1748 void m08_setMultiParamsImplicitSwappedObject(Input input) {
1749 var x1 = new ImplicitSwappedObject();
1750 var x2 = new ImplicitSwappedObject[][][]{{{new ImplicitSwappedObject(),null},null},null};
1751 ImplicitSwappedObject[][][] x2n = null;
1752 var x3 = alist(x2,null);
1753 List<ImplicitSwappedObject[][][]> x3n = null;
1754 var x4 = CollectionUtils.map(new ImplicitSwappedObject(),new ImplicitSwappedObject());
1755 Map<ImplicitSwappedObject,ImplicitSwappedObject> x4n = null;
1756 var x5 = CollectionUtils.map(new ImplicitSwappedObject(),x3);
1757 Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5n = null;
1758 assertDoesNotThrow(()->input.proxy.setMultiParamsImplicitSwappedObject(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1759 }
1760
1761 @ParameterizedTest
1762 @MethodSource("input")
1763 void m09_setMultiParamsEnum(Input input) {
1764 var x1 = TestEnum.TWO;
1765 var x2 = new TestEnum[][][]{{{TestEnum.TWO,null},null},null};
1766 TestEnum[][][] x2n = null;
1767 var x3 = alist(x2,null);
1768 List<TestEnum[][][]> x3n = null;
1769 var x4 = CollectionUtils.map(TestEnum.ONE,TestEnum.TWO);
1770 Map<TestEnum,TestEnum> x4n = null;
1771 var x5 = CollectionUtils.map(TestEnum.ONE,x3);
1772 Map<TestEnum,List<TestEnum[][][]>> x5n = null;
1773 assertDoesNotThrow(()->input.proxy.setMultiParamsEnum(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1774 }
1775 }