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.commons.utils.CollectionUtils.*;
21 import static org.apache.juneau.http.HttpMethod.*;
22 import static org.apache.juneau.junit.bct.BctAssertions.*;
23 import static org.apache.juneau.utest.utils.Constants.*;
24 import static org.junit.jupiter.api.Assertions.*;
25
26 import java.util.*;
27
28 import org.apache.juneau.*;
29 import org.apache.juneau.html.*;
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 a(a(a(1,null),null),null);
308 }
309
310 @Override
311 public String[][][] returnString3dArray() {
312 return a(a(a("foo","bar",null),null),null);
313 }
314
315 @Override
316 public List<Integer> returnIntegerList() {
317 return asList(a(1,null));
318 }
319
320 @Override
321 public List<List<List<Integer>>> returnInteger3dList() {
322 return l(l(l(1,null),null),null);
323 }
324
325 @Override
326 public List<Integer[][][]> returnInteger1d3dList() {
327 return l(a(a(a(1,null),null),null),null);
328 }
329
330 @Override
331 public List<int[][][]> returnInt1d3dList() {
332 return l(new int[][][]{{{1,2},null},null},null);
333 }
334
335 @Override
336 public List<String> returnStringList() {
337 return asList(a("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 a(a(a(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 l(a(a(a(ABean.get(),null),null),null),null);
360 }
361
362 @Override
363 public Map<String,ABean> returnBeanMap() {
364 return m("foo",ABean.get());
365 }
366
367 @Override
368 public Map<String,List<ABean>> returnBeanListMap() {
369 return m("foo",asList(ABean.get()));
370 }
371
372 @Override
373 public Map<String,List<ABean[][][]>> returnBean1d3dListMap() {
374 return m("foo",l(a(a(a(ABean.get(),null),null),null),null));
375 }
376
377 @Override
378 public Map<Integer,List<ABean>> returnBeanListMapIntegerKeys() {
379 return m(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 a(a(a(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 l(a(a(a(TypedBeanImpl.get(),null),null),null),null);
402 }
403
404 @Override
405 public Map<String,TypedBean> returnTypedBeanMap() {
406 return m("foo",TypedBeanImpl.get());
407 }
408
409 @Override
410 public Map<String,List<TypedBean>> returnTypedBeanListMap() {
411 return m("foo",asList((TypedBean)TypedBeanImpl.get()));
412 }
413
414 @Override
415 public Map<String,List<TypedBean[][][]>> returnTypedBean1d3dListMap() {
416 return m("foo",l(a(a(a(TypedBeanImpl.get(),null),null),null),null));
417 }
418
419 @Override
420 public Map<Integer,List<TypedBean>> returnTypedBeanListMapIntegerKeys() {
421 return m(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 a(a(a(new SwappedObject(),null),null),null);
434 }
435
436 @Override
437 public Map<SwappedObject,SwappedObject> returnSwappedObjectMap() {
438 return m(new SwappedObject(),new SwappedObject());
439 }
440
441 @Override
442 public Map<SwappedObject,SwappedObject[][][]> returnSwappedObject3dMap() {
443 return m(new SwappedObject(),a(a(a(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 a(a(a(new ImplicitSwappedObject(),null),null),null);
456 }
457
458 @Override
459 public Map<ImplicitSwappedObject,ImplicitSwappedObject> returnImplicitSwappedObjectMap() {
460 return m(new ImplicitSwappedObject(),new ImplicitSwappedObject());
461 }
462
463 @Override
464 public Map<ImplicitSwappedObject,ImplicitSwappedObject[][][]> returnImplicitSwappedObject3dMap() {
465 return m(new ImplicitSwappedObject(),a(a(a(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 a(a(a(TestEnum.TWO,null),null),null);
478 }
479
480 @Override
481 public List<TestEnum> returnEnumList() {
482 return l(TestEnum.TWO,null);
483 }
484
485 @Override
486 public List<List<List<TestEnum>>> returnEnum3dList() {
487 return l(l(l(TestEnum.TWO,null),null),null);
488 }
489
490 @Override
491 public List<TestEnum[][][]> returnEnum1d3dList() {
492 return l(a(a(a(TestEnum.TWO,null),null),null),null);
493 }
494
495 @Override
496 public Map<TestEnum,TestEnum> returnEnumMap() {
497 return m(TestEnum.ONE,TestEnum.TWO);
498 }
499
500 @Override
501 public Map<TestEnum,TestEnum[][][]> returnEnum3dArrayMap() {
502 return m(TestEnum.ONE,a(a(a(TestEnum.TWO,null),null),null));
503 }
504
505 @Override
506 public Map<TestEnum,List<TestEnum[][][]>> returnEnum1d3dListMap() {
507 return m(TestEnum.ONE,l(a(a(a(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 assertBean(v, "foo", "{a:1,b:'foo'}");
638 }
639
640 @Override
641 public void setBeanListMap(Map<String,List<ABean>> v) {
642 assertBean(v, "foo", "[{a:1,b:'foo'}]");
643 }
644
645 @Override
646 public void setBean1d3dListMap(Map<String,List<ABean[][][]>> v) {
647 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 assertBean(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 @ParameterizedTest
1333 @MethodSource("input")
1334 void g02_throwException2(Input input) {
1335 try {
1336 input.proxy.throwException2();
1337 fail();
1338 } catch (InterfaceProxy.InterfaceProxyException2 e) {}
1339 }
1340
1341
1342
1343
1344
1345
1346 @ParameterizedTest
1347 @MethodSource("input")
1348 void h01_setNothing(Input input) {
1349 assertDoesNotThrow(()->input.proxy.setNothing());
1350 }
1351
1352 @ParameterizedTest
1353 @MethodSource("input")
1354 void h02_setInt(Input input) {
1355 assertDoesNotThrow(()->input.proxy.setInt(1));
1356 }
1357
1358 @ParameterizedTest
1359 @MethodSource("input")
1360 void h03_setWrongInt(Input input) {
1361 assertThrows(AssertionError.class, ()->input.proxy.setInt(2), "expected: <1> but was: <2>");
1362 }
1363
1364 @ParameterizedTest
1365 @MethodSource("input")
1366 void h04_setInteger(Input input) {
1367 assertDoesNotThrow(()->input.proxy.setInteger(1));
1368 }
1369
1370 @ParameterizedTest
1371 @MethodSource("input")
1372 void h05_setBoolean(Input input) {
1373 assertDoesNotThrow(()->input.proxy.setBoolean(true));
1374 }
1375
1376 @ParameterizedTest
1377 @MethodSource("input")
1378 void h06_setFloat(Input input) {
1379 assertDoesNotThrow(()->input.proxy.setFloat(1f));
1380 }
1381
1382 @ParameterizedTest
1383 @MethodSource("input")
1384 void h07_setFloatObject(Input input) {
1385 assertDoesNotThrow(()->input.proxy.setFloatObject(1f));
1386 }
1387
1388 @ParameterizedTest
1389 @MethodSource("input")
1390 void h08_setString(Input input) {
1391 assertDoesNotThrow(()->input.proxy.setString("foo"));
1392 }
1393
1394 @ParameterizedTest
1395 @MethodSource("input")
1396 void h09_setNullString(Input input) {
1397 assertDoesNotThrow(()->input.proxy.setNullString(null));
1398 }
1399
1400 @ParameterizedTest
1401 @MethodSource("input")
1402 void h10_setNullStringBad(Input input) {
1403 assertThrows(AssertionError.class, ()->input.proxy.setNullString("foo"), "expected: <null> but was: <foo>");
1404 }
1405
1406 @ParameterizedTest
1407 @MethodSource("input")
1408 void h11_setInt3dArray(Input input) {
1409 assertDoesNotThrow(()->input.proxy.setInt3dArray(new int[][][]{{{1,2},null},null}));
1410 }
1411
1412 @ParameterizedTest
1413 @MethodSource("input")
1414 void h12_setInteger3dArray(Input input) {
1415 assertDoesNotThrow(()->input.proxy.setInteger3dArray(a(a(a(1,null),null),null)));
1416 }
1417
1418 @ParameterizedTest
1419 @MethodSource("input")
1420 void h13_setString3dArray(Input input) {
1421 assertDoesNotThrow(()->input.proxy.setString3dArray(a(a(a("foo",null),null),null)));
1422 }
1423
1424 @ParameterizedTest
1425 @MethodSource("input")
1426 void h14_setIntegerList(Input input) {
1427 assertDoesNotThrow(()->input.proxy.setIntegerList(l(1,null)));
1428 }
1429
1430 @ParameterizedTest
1431 @MethodSource("input")
1432 void h15_setInteger3dList(Input input) {
1433 assertDoesNotThrow(()->input.proxy.setInteger3dList(l(l(l(1,null),null),null)));
1434 }
1435
1436 @ParameterizedTest
1437 @MethodSource("input")
1438 void h16_setInteger1d3dList(Input input) {
1439 assertDoesNotThrow(()->input.proxy.setInteger1d3dList(l(a(a(a(1,null),null),null),null)));
1440 }
1441
1442 @ParameterizedTest
1443 @MethodSource("input")
1444 void h17_setInt1d3dList(Input input) {
1445 assertDoesNotThrow(()->input.proxy.setInt1d3dList(l(new int[][][]{{{1,2},null},null},null)));
1446 }
1447
1448 @ParameterizedTest
1449 @MethodSource("input")
1450 void h18_setStringList(Input input) {
1451 assertDoesNotThrow(()->input.proxy.setStringList(l("foo","bar",null)));
1452 }
1453
1454
1455 @ParameterizedTest
1456 @MethodSource("input")
1457 void h19_setBean(Input input) {
1458 assertDoesNotThrow(()->input.proxy.setBean(ABean.get()));
1459 }
1460
1461 @ParameterizedTest
1462 @MethodSource("input")
1463 void h20_setBean3dArray(Input input) {
1464 assertDoesNotThrow(()->input.proxy.setBean3dArray(a(a(a(ABean.get(),null),null),null)));
1465 }
1466
1467 @ParameterizedTest
1468 @MethodSource("input")
1469 void h21_setBeanList(Input input) {
1470 assertDoesNotThrow(()->input.proxy.setBeanList(l(ABean.get())));
1471 }
1472
1473 @ParameterizedTest
1474 @MethodSource("input")
1475 void h22_setBean1d3dList(Input input) {
1476 assertDoesNotThrow(()->input.proxy.setBean1d3dList(l(a(a(a(ABean.get(),null),null),null),null)));
1477 }
1478
1479 @ParameterizedTest
1480 @MethodSource("input")
1481 void h23_setBeanMap(Input input) {
1482 assertDoesNotThrow(()->input.proxy.setBeanMap(map("foo",ABean.get())));
1483 }
1484
1485 @ParameterizedTest
1486 @MethodSource("input")
1487 void h24_setBeanListMap(Input input) {
1488 assertDoesNotThrow(()->input.proxy.setBeanListMap(map("foo",l(ABean.get()))));
1489 }
1490
1491 @ParameterizedTest
1492 @MethodSource("input")
1493 void h25_setBean1d3dListMap(Input input) {
1494 assertDoesNotThrow(()->input.proxy.setBean1d3dListMap(map("foo",l(a(a(a(ABean.get(),null),null),null),null))));
1495 }
1496
1497 @ParameterizedTest
1498 @MethodSource("input")
1499 void h26_setBeanListMapIntegerKeys(Input input) {
1500 assertDoesNotThrow(()->input.proxy.setBeanListMapIntegerKeys(map(1,l(ABean.get()))));
1501 }
1502
1503
1504
1505 @ParameterizedTest
1506 @MethodSource("input")
1507 void i01_setTypedBean(Input input) {
1508 assertDoesNotThrow(()->input.proxy.setTypedBean(TypedBeanImpl.get()));
1509 }
1510
1511 @ParameterizedTest
1512 @MethodSource("input")
1513 void i02_setTypedBean3dArray(Input input) {
1514 assertDoesNotThrow(()->input.proxy.setTypedBean3dArray(a(a(a(TypedBeanImpl.get(),null),null),null)));
1515 }
1516
1517 @ParameterizedTest
1518 @MethodSource("input")
1519 void i03_setTypedBeanList(Input input) {
1520 assertDoesNotThrow(()->input.proxy.setTypedBeanList(l((TypedBean)TypedBeanImpl.get())));
1521 }
1522
1523 @ParameterizedTest
1524 @MethodSource("input")
1525 void i04_setTypedBean1d3dList(Input input) {
1526 assertDoesNotThrow(()->input.proxy.setTypedBean1d3dList(l(a(a(a(TypedBeanImpl.get(),null),null),null),null)));
1527 }
1528
1529 @ParameterizedTest
1530 @MethodSource("input")
1531 void i05_setTypedBeanMap(Input input) {
1532 assertDoesNotThrow(()->input.proxy.setTypedBeanMap(map("foo",TypedBeanImpl.get())));
1533 }
1534
1535 @ParameterizedTest
1536 @MethodSource("input")
1537 void i06_setTypedBeanListMap(Input input) {
1538 assertDoesNotThrow(()->input.proxy.setTypedBeanListMap(map("foo",l((TypedBean)TypedBeanImpl.get()))));
1539 }
1540
1541 @ParameterizedTest
1542 @MethodSource("input")
1543 void i07_setTypedBean1d3dListMap(Input input) {
1544 assertDoesNotThrow(()->input.proxy.setTypedBean1d3dListMap(map("foo",l(a(a(a(TypedBeanImpl.get(),null),null),null),null))));
1545 }
1546
1547 @ParameterizedTest
1548 @MethodSource("input")
1549 void i08_setTypedBeanListMapIntegerKeys(Input input) {
1550 assertDoesNotThrow(()->input.proxy.setTypedBeanListMapIntegerKeys(map(1,l((TypedBean)TypedBeanImpl.get()))));
1551 }
1552
1553
1554
1555 @ParameterizedTest
1556 @MethodSource("input")
1557 void j01_setSwappedObject(Input input) {
1558 assertDoesNotThrow(()->input.proxy.setSwappedObject(new SwappedObject()));
1559 }
1560
1561 @ParameterizedTest
1562 @MethodSource("input")
1563 void j02_setSwappedObject3dArray(Input input) {
1564 assertDoesNotThrow(()->input.proxy.setSwappedObject3dArray(a(a(a(new SwappedObject(),null),null),null)));
1565 }
1566
1567 @ParameterizedTest
1568 @MethodSource("input")
1569 void j03_setSwappedObjectMap(Input input) {
1570 assertDoesNotThrow(()->input.proxy.setSwappedObjectMap(map(new SwappedObject(),new SwappedObject())));
1571 }
1572
1573 @ParameterizedTest
1574 @MethodSource("input")
1575 void j04_setSwappedObject3dMap(Input input) {
1576 assertDoesNotThrow(()->input.proxy.setSwappedObject3dMap(map(new SwappedObject(),a(a(a(new SwappedObject(),null),null),null))));
1577 }
1578
1579
1580 @ParameterizedTest
1581 @MethodSource("input")
1582 void k01_setImplicitSwappedObject(Input input) {
1583 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject(new ImplicitSwappedObject()));
1584 }
1585
1586 @ParameterizedTest
1587 @MethodSource("input")
1588 void k02_setImplicitSwappedObject3dArray(Input input) {
1589 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject3dArray(a(a(a(new ImplicitSwappedObject(),null),null),null)));
1590 }
1591
1592 @ParameterizedTest
1593 @MethodSource("input")
1594 void k03_setImplicitSwappedObjectMap(Input input) {
1595 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObjectMap(map(new ImplicitSwappedObject(),new ImplicitSwappedObject())));
1596 }
1597
1598 @ParameterizedTest
1599 @MethodSource("input")
1600 void k04_setImplicitSwappedObject3dMap(Input input) {
1601 assertDoesNotThrow(()->input.proxy.setImplicitSwappedObject3dMap(map(new ImplicitSwappedObject(),a(a(a(new ImplicitSwappedObject(),null),null),null))));
1602 }
1603
1604
1605
1606 @ParameterizedTest
1607 @MethodSource("input")
1608 void l01_setEnum(Input input) {
1609 assertDoesNotThrow(()->input.proxy.setEnum(TestEnum.TWO));
1610 }
1611
1612 @ParameterizedTest
1613 @MethodSource("input")
1614 void l02_setEnum3d(Input input) {
1615 assertDoesNotThrow(()->input.proxy.setEnum3d(a(a(a(TestEnum.TWO,null),null),null)));
1616 }
1617
1618 @ParameterizedTest
1619 @MethodSource("input")
1620 void l03_setEnumList(Input input) {
1621 assertDoesNotThrow(()->input.proxy.setEnumList(l(TestEnum.TWO,null)));
1622 }
1623
1624 @ParameterizedTest
1625 @MethodSource("input")
1626 void l04_setEnum3dList(Input input) {
1627 assertDoesNotThrow(()->input.proxy.setEnum3dList(l(l(l(TestEnum.TWO,null),null),null)));
1628 }
1629
1630 @ParameterizedTest
1631 @MethodSource("input")
1632 void l05_setEnum1d3dList(Input input) {
1633 assertDoesNotThrow(()->input.proxy.setEnum1d3dList(l(a(a(a(TestEnum.TWO,null),null),null),null)));
1634 }
1635
1636 @ParameterizedTest
1637 @MethodSource("input")
1638 void l06_setEnumMap(Input input) {
1639 assertDoesNotThrow(()->input.proxy.setEnumMap(map(TestEnum.ONE,TestEnum.TWO)));
1640 }
1641
1642 @ParameterizedTest
1643 @MethodSource("input")
1644 void l07_setEnum3dArrayMap(Input input) {
1645 assertDoesNotThrow(()->input.proxy.setEnum3dArrayMap(map(TestEnum.ONE,a(a(a(TestEnum.TWO,null),null),null))));
1646 }
1647
1648 @ParameterizedTest
1649 @MethodSource("input")
1650 void l08_setEnum1d3dListMap(Input input) {
1651 assertDoesNotThrow(()->input.proxy.setEnum1d3dListMap(map(TestEnum.ONE,l(a(a(a(TestEnum.TWO,null),null),null),null))));
1652 }
1653
1654
1655
1656
1657
1658 @ParameterizedTest
1659 @MethodSource("input")
1660 void m01_setMultiParamsInts(Input input) {
1661 var x1 = 1;
1662 var x2 = new int[][][]{{{1,2},null},null};
1663 int[][][] x2n = null;
1664 var x3 = l(x2,null);
1665 List<int[][][]> x3n = null;
1666 assertDoesNotThrow(()->input.proxy.setMultiParamsInts(x1,x2,x2n,x3,x3n));
1667 }
1668
1669 @ParameterizedTest
1670 @MethodSource("input")
1671 void m02_setMultiParamsInteger(Input input) {
1672 var x1 = Integer.valueOf(1);
1673 var x1n = (Integer)null;
1674 var x2 = a(a(a(1,null),null),null);
1675 Integer[][][] x2n = null;
1676 var x3 = l(x2,null);
1677 List<Integer[][][]> x3n = null;
1678 assertDoesNotThrow(()->input.proxy.setMultiParamsInteger(x1,x1n,x2,x2n,x3,x3n));
1679 }
1680
1681 @ParameterizedTest
1682 @MethodSource("input")
1683 void m03_setMultiParamsFloat(Input input) {
1684 var x1 = 1f;
1685 var x2 = new float[][][]{{{1,2},null},null};
1686 float[][][] x2n = null;
1687 var x3 = l(x2,null);
1688 List<float[][][]> x3n = null;
1689 assertDoesNotThrow(()->input.proxy.setMultiParamsFloat(x1,x2,x2n,x3,x3n));
1690 }
1691
1692 @ParameterizedTest
1693 @MethodSource("input")
1694 void m04_setMultiParamsFloatObject(Input input) {
1695 var x1 = 1f;
1696 var x1n = (Float)null;
1697 var x2 = a(a(a(1f,null),null),null);
1698 Float[][][] x2n = null;
1699 var x3 = l(x2,null);
1700 List<Float[][][]> x3n = null;
1701 assertDoesNotThrow(()->input.proxy.setMultiParamsFloatObject(x1,x1n,x2,x2n,x3,x3n));
1702 }
1703
1704 @ParameterizedTest
1705 @MethodSource("input")
1706 void m05_setMultiParamsString(Input input) {
1707 var x1 = "foo";
1708 var x2 = a(a(a("foo",null),null),null);
1709 String[][][] x2n = null;
1710 var x3 = l(x2,null);
1711 List<String[][][]> x3n = null;
1712 assertDoesNotThrow(()->input.proxy.setMultiParamsString(x1,x2,x2n,x3,x3n));
1713 }
1714
1715 @ParameterizedTest
1716 @MethodSource("input")
1717 void m06_setMultiParamsBean(Input input) {
1718 var x1 = ABean.get();
1719 var x2 = a(a(a(ABean.get(),null),null),null);
1720 ABean[][][] x2n = null;
1721 var x3 = l(x2,null);
1722 List<ABean[][][]> x3n = null;
1723 var x4 = m("foo",ABean.get());
1724 var x4n = (Map<String,ABean>)null;
1725 var x5 = m("foo",x3);
1726 Map<String,List<ABean[][][]>> x5n = null;
1727 assertDoesNotThrow(()->input.proxy.setMultiParamsBean(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1728 }
1729
1730 @ParameterizedTest
1731 @MethodSource("input")
1732 void m07_setMultiParamsSwappedObject(Input input) {
1733 var x1 = new SwappedObject();
1734 var x2 = a(a(a(new SwappedObject(),null),null),null);
1735 SwappedObject[][][] x2n = null;
1736 var x3 = l(x2,null);
1737 List<SwappedObject[][][]> x3n = null;
1738 var x4 = m(new SwappedObject(),new SwappedObject());
1739 var x4n = (Map<SwappedObject,SwappedObject>)null;
1740 var x5 = m(new SwappedObject(),x3);
1741 Map<SwappedObject,List<SwappedObject[][][]>> x5n = null;
1742 assertDoesNotThrow(()->input.proxy.setMultiParamsSwappedObject(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1743 }
1744
1745 @ParameterizedTest
1746 @MethodSource("input")
1747 void m08_setMultiParamsImplicitSwappedObject(Input input) {
1748 var x1 = new ImplicitSwappedObject();
1749 var x2 = a(a(a(new ImplicitSwappedObject(),null),null),null);
1750 ImplicitSwappedObject[][][] x2n = null;
1751 var x3 = l(x2,null);
1752 List<ImplicitSwappedObject[][][]> x3n = null;
1753 var x4 = m(new ImplicitSwappedObject(),new ImplicitSwappedObject());
1754 var x4n = (Map<ImplicitSwappedObject,ImplicitSwappedObject>)null;
1755 var x5 = m(new ImplicitSwappedObject(),x3);
1756 Map<ImplicitSwappedObject,List<ImplicitSwappedObject[][][]>> x5n = null;
1757 assertDoesNotThrow(()->input.proxy.setMultiParamsImplicitSwappedObject(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1758 }
1759
1760 @ParameterizedTest
1761 @MethodSource("input")
1762 void m09_setMultiParamsEnum(Input input) {
1763 var x1 = TestEnum.TWO;
1764 var x2 = a(a(a(TestEnum.TWO,null),null),null);
1765 TestEnum[][][] x2n = null;
1766 var x3 = l(x2,null);
1767 List<TestEnum[][][]> x3n = null;
1768 var x4 = m(TestEnum.ONE,TestEnum.TWO);
1769 var x4n = (Map<TestEnum,TestEnum>)null;
1770 var x5 = m(TestEnum.ONE,x3);
1771 Map<TestEnum,List<TestEnum[][][]>> x5n = null;
1772 assertDoesNotThrow(()->input.proxy.setMultiParamsEnum(x1,x2,x2n,x3,x3n,x4,x4n,x5,x5n));
1773 }
1774 }