1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package org.graalvm.compiler.core.test;
24
25 import jdk.vm.ci.code.InstalledCode;
26 import jdk.vm.ci.meta.ResolvedJavaMethod;
27
28 import org.junit.Test;
29
30 import org.graalvm.compiler.nodes.StructuredGraph;
31 import org.graalvm.compiler.options.OptionValues;
32
33 public class MemoryArithmeticTest extends GraalCompilerTest {
34
35 @Override
36 protected InstalledCode getCode(ResolvedJavaMethod method, StructuredGraph graph, boolean forceCompile, boolean installAsDefault, OptionValues options) {
37 return super.getCode(method, graph, true, installAsDefault, options);
38 }
39
40 /**
41 * Called before a test is executed.
42 */
43 @Override
44 protected void before(ResolvedJavaMethod method) {
45 // don't let any null exception tracking change the generated code.
46 method.reprofile();
47 }
48
49 /**
50 * A dummy field used by some tests to create side effects.
51 */
52 protected static int count;
53
54 static class FieldObject {
55 boolean booleanValue;
56 byte byteValue;
57 short shortValue;
58 char charValue;
59 int intValue;
60 float floatValue;
61 long longValue;
62 double doubleValue;
63 Object objectValue;
64 }
65
66 static FieldObject maxObject = new FieldObject();
67 static FieldObject minObject;
68
69 static final boolean booleanTestValue1 = false;
70 static final byte byteTestValue1 = 0;
71 static final short shortTestValue1 = 0;
72 static final char charTestValue1 = 0;
73 static final int intTestValue1 = 0;
74 static final float floatTestValue1 = 0;
75 static final long longTestValue1 = 0;
76 static final double doubleTestValue1 = 0;
77 static final Object objectTestValue1 = null;
78
79 static final boolean booleanTestValue2 = true;
80 static final byte byteTestValue2 = Byte.MAX_VALUE;
81 static final short shortTestValue2 = Short.MAX_VALUE;
82 static final char charTestValue2 = Character.MAX_VALUE;
83 static final int intTestValue2 = Integer.MAX_VALUE;
84 static final float floatTestValue2 = Float.MAX_VALUE;
85 static final long longTestValue2 = Long.MAX_VALUE;
86 static final double doubleTestValue2 = Double.MAX_VALUE;
87 static final Object objectTestValue2 = "String";
88
89 static {
90 maxObject.booleanValue = true;
91 maxObject.byteValue = Byte.MAX_VALUE;
92 maxObject.shortValue = Short.MAX_VALUE;
93 maxObject.charValue = Character.MAX_VALUE;
94 maxObject.intValue = Integer.MAX_VALUE;
95 maxObject.floatValue = Float.MAX_VALUE;
96 maxObject.longValue = Long.MAX_VALUE;
97 maxObject.doubleValue = Double.MAX_VALUE;
98 maxObject.objectValue = "String";
99 }
100
101 public static Object testBooleanCompare(FieldObject f, boolean booleanValue) {
102 if (f.booleanValue == booleanValue) {
103 return f;
104 }
105 return null;
106 }
107
108 public static Object testBooleanCompareConstant1(FieldObject f) {
109 if (f.booleanValue == booleanTestValue1) {
110 return f;
111 }
112 return null;
113 }
114
115 public static Object testBooleanCompareConstant2(FieldObject f) {
116 if (f.booleanValue == booleanTestValue2) {
117 return f;
118 }
119 return null;
120 }
121
122 @Test
123 public void testBooleanCompares() {
124 FieldObject f = new FieldObject();
125 test("testBooleanCompare", f, booleanTestValue1);
126 test("testBooleanCompareConstant1", f);
127 test("testBooleanCompareConstant2", f);
128 }
129
130 @Test
131 public void testBooleanNullCompares() {
132 test("testBooleanCompare", null, booleanTestValue1);
133 }
134
135 @Test
136 public void testBooleanNullCompares1() {
137 test("testBooleanCompareConstant1", (Object) null);
138 }
139
140 @Test
141 public void testBooleanNullCompares2() {
142 test("testBooleanCompareConstant2", (Object) null);
143 }
144
145 public static Object testByteCompare(FieldObject f, byte byteValue) {
146 if (f.byteValue == byteValue) {
147 return f;
148 }
149 return null;
150 }
151
152 public static Object testByteCompareConstant1(FieldObject f) {
153 if (f.byteValue == byteTestValue1) {
154 return f;
155 }
156 return null;
157 }
158
159 public static Object testByteCompareConstant2(FieldObject f) {
160 if (f.byteValue == byteTestValue2) {
161 return f;
162 }
163 return null;
164 }
165
166 @Test
167 public void testByteCompares() {
168 FieldObject f = new FieldObject();
169 test("testByteCompare", f, byteTestValue1);
170 test("testByteCompareConstant1", f);
171 test("testByteCompareConstant2", f);
172 }
173
174 @Test
175 public void testByteNullCompares() {
176 test("testByteCompare", null, byteTestValue1);
177 }
178
179 @Test
180 public void testByteNullCompares1() {
181 test("testByteCompareConstant1", (Object) null);
182 }
183
184 @Test
185 public void testByteNullCompares2() {
186 test("testByteCompareConstant2", (Object) null);
187 }
188
189 public static Object testByteCompareLess(FieldObject f, byte byteValue) {
190 if (f.byteValue < byteValue) {
191 return f;
192 }
193 return null;
194 }
195
196 public static Object testByteCompareLessConstant1(FieldObject f) {
197 if (f.byteValue < byteTestValue1) {
198 return f;
199 }
200 return null;
201 }
202
203 public static Object testByteCompareLessConstant2(FieldObject f) {
204 if (f.byteValue < byteTestValue2) {
205 return f;
206 }
207 return null;
208 }
209
210 @Test
211 public void testByteComparesLess() {
212 FieldObject f = new FieldObject();
213 test("testByteCompareLess", f, byteTestValue1);
214 test("testByteCompareLessConstant1", f);
215 test("testByteCompareLessConstant2", f);
216 }
217
218 @Test
219 public void testByteNullComparesLess() {
220 test("testByteCompareLess", null, byteTestValue1);
221 }
222
223 @Test
224 public void testByteNullComparesLess1() {
225 test("testByteCompareLessConstant1", (Object) null);
226 }
227
228 @Test
229 public void testByteNullComparesLess2() {
230 test("testByteCompareLessConstant2", (Object) null);
231 }
232
233 public static Object testByteSwappedCompareLess(FieldObject f, byte byteValue) {
234 if (byteValue < f.byteValue) {
235 return f;
236 }
237 return null;
238 }
239
240 public static Object testByteSwappedCompareLessConstant1(FieldObject f) {
241 if (byteTestValue1 < f.byteValue) {
242 return f;
243 }
244 return null;
245 }
246
247 public static Object testByteSwappedCompareLessConstant2(FieldObject f) {
248 if (byteTestValue2 < f.byteValue) {
249 return f;
250 }
251 return null;
252 }
253
254 @Test
255 public void testByteSwappedComparesLess() {
256 FieldObject f = new FieldObject();
257 test("testByteSwappedCompareLess", f, byteTestValue1);
258 test("testByteSwappedCompareLessConstant1", f);
259 test("testByteSwappedCompareLessConstant2", f);
260 }
261
262 @Test
263 public void testByteNullSwappedComparesLess() {
264 test("testByteSwappedCompareLess", null, byteTestValue1);
265 }
266
267 @Test
268 public void testByteNullSwappedComparesLess1() {
269 test("testByteSwappedCompareLessConstant1", (Object) null);
270 }
271
272 @Test
273 public void testByteNullSwappedComparesLess2() {
274 test("testByteSwappedCompareLessConstant2", (Object) null);
275 }
276
277 public static Object testByteCompareLessEqual(FieldObject f, byte byteValue) {
278 if (f.byteValue <= byteValue) {
279 return f;
280 }
281 return null;
282 }
283
284 public static Object testByteCompareLessEqualConstant1(FieldObject f) {
285 if (f.byteValue <= byteTestValue1) {
286 return f;
287 }
288 return null;
289 }
290
291 public static Object testByteCompareLessEqualConstant2(FieldObject f) {
292 if (f.byteValue <= byteTestValue2) {
293 return f;
294 }
295 return null;
296 }
297
298 @Test
299 public void testByteComparesLessEqual() {
300 FieldObject f = new FieldObject();
301 test("testByteCompareLessEqual", f, byteTestValue1);
302 test("testByteCompareLessEqualConstant1", f);
303 test("testByteCompareLessEqualConstant2", f);
304 }
305
306 @Test
307 public void testByteNullComparesLessEqual() {
308 test("testByteCompareLessEqual", null, byteTestValue1);
309 }
310
311 @Test
312 public void testByteNullComparesLessEqual1() {
313 test("testByteCompareLessEqualConstant1", (Object) null);
314 }
315
316 @Test
317 public void testByteNullComparesLessEqual2() {
318 test("testByteCompareLessEqualConstant2", (Object) null);
319 }
320
321 public static Object testByteSwappedCompareLessEqual(FieldObject f, byte byteValue) {
322 if (byteValue <= f.byteValue) {
323 return f;
324 }
325 return null;
326 }
327
328 public static Object testByteSwappedCompareLessEqualConstant1(FieldObject f) {
329 if (byteTestValue1 <= f.byteValue) {
330 return f;
331 }
332 return null;
333 }
334
335 public static Object testByteSwappedCompareLessEqualConstant2(FieldObject f) {
336 if (byteTestValue2 <= f.byteValue) {
337 return f;
338 }
339 return null;
340 }
341
342 @Test
343 public void testByteSwappedComparesLessEqual() {
344 FieldObject f = new FieldObject();
345 test("testByteSwappedCompareLessEqual", f, byteTestValue1);
346 test("testByteSwappedCompareLessEqualConstant1", f);
347 test("testByteSwappedCompareLessEqualConstant2", f);
348 }
349
350 @Test
351 public void testByteNullSwappedComparesLessEqual() {
352 test("testByteSwappedCompareLessEqual", null, byteTestValue1);
353 }
354
355 @Test
356 public void testByteNullSwappedComparesLessEqual1() {
357 test("testByteSwappedCompareLessEqualConstant1", (Object) null);
358 }
359
360 @Test
361 public void testByteNullSwappedComparesLessEqual2() {
362 test("testByteSwappedCompareLessEqualConstant2", (Object) null);
363 }
364
365 public static Object testByteCompareGreater(FieldObject f, byte byteValue) {
366 if (f.byteValue > byteValue) {
367 return f;
368 }
369 return null;
370 }
371
372 public static Object testByteCompareGreaterConstant1(FieldObject f) {
373 if (f.byteValue > byteTestValue1) {
374 return f;
375 }
376 return null;
377 }
378
379 public static Object testByteCompareGreaterConstant2(FieldObject f) {
380 if (f.byteValue > byteTestValue2) {
381 return f;
382 }
383 return null;
384 }
385
386 @Test
387 public void testByteComparesGreater() {
388 FieldObject f = new FieldObject();
389 test("testByteCompareGreater", f, byteTestValue1);
390 test("testByteCompareGreaterConstant1", f);
391 test("testByteCompareGreaterConstant2", f);
392 }
393
394 @Test
395 public void testByteNullComparesGreater() {
396 test("testByteCompareGreater", null, byteTestValue1);
397 }
398
399 @Test
400 public void testByteNullComparesGreater1() {
401 test("testByteCompareGreaterConstant1", (Object) null);
402 }
403
404 @Test
405 public void testByteNullComparesGreater2() {
406 test("testByteCompareGreaterConstant2", (Object) null);
407 }
408
409 public static Object testByteSwappedCompareGreater(FieldObject f, byte byteValue) {
410 if (byteValue > f.byteValue) {
411 return f;
412 }
413 return null;
414 }
415
416 public static Object testByteSwappedCompareGreaterConstant1(FieldObject f) {
417 if (byteTestValue1 > f.byteValue) {
418 return f;
419 }
420 return null;
421 }
422
423 public static Object testByteSwappedCompareGreaterConstant2(FieldObject f) {
424 if (byteTestValue2 > f.byteValue) {
425 return f;
426 }
427 return null;
428 }
429
430 @Test
431 public void testByteSwappedComparesGreater() {
432 FieldObject f = new FieldObject();
433 test("testByteSwappedCompareGreater", f, byteTestValue1);
434 test("testByteSwappedCompareGreaterConstant1", f);
435 test("testByteSwappedCompareGreaterConstant2", f);
436 }
437
438 @Test
439 public void testByteNullSwappedComparesGreater() {
440 test("testByteSwappedCompareGreater", null, byteTestValue1);
441 }
442
443 @Test
444 public void testByteNullSwappedComparesGreater1() {
445 test("testByteSwappedCompareGreaterConstant1", (Object) null);
446 }
447
448 @Test
449 public void testByteNullSwappedComparesGreater2() {
450 test("testByteSwappedCompareGreaterConstant2", (Object) null);
451 }
452
453 public static Object testByteCompareGreaterEqual(FieldObject f, byte byteValue) {
454 if (f.byteValue >= byteValue) {
455 return f;
456 }
457 return null;
458 }
459
460 public static Object testByteCompareGreaterEqualConstant1(FieldObject f) {
461 if (f.byteValue >= byteTestValue1) {
462 return f;
463 }
464 return null;
465 }
466
467 public static Object testByteCompareGreaterEqualConstant2(FieldObject f) {
468 if (f.byteValue >= byteTestValue2) {
469 return f;
470 }
471 return null;
472 }
473
474 @Test
475 public void testByteComparesGreaterEqual() {
476 FieldObject f = new FieldObject();
477 test("testByteCompareGreaterEqual", f, byteTestValue1);
478 test("testByteCompareGreaterEqualConstant1", f);
479 test("testByteCompareGreaterEqualConstant2", f);
480 }
481
482 @Test
483 public void testByteNullComparesGreaterEqual() {
484 test("testByteCompareGreaterEqual", null, byteTestValue1);
485 }
486
487 @Test
488 public void testByteNullComparesGreaterEqual1() {
489 test("testByteCompareGreaterEqualConstant1", (Object) null);
490 }
491
492 @Test
493 public void testByteNullComparesGreaterEqual2() {
494 test("testByteCompareGreaterEqualConstant2", (Object) null);
495 }
496
497 public static Object testByteSwappedCompareGreaterEqual(FieldObject f, byte byteValue) {
498 if (byteValue >= f.byteValue) {
499 return f;
500 }
501 return null;
502 }
503
504 public static Object testByteSwappedCompareGreaterEqualConstant1(FieldObject f) {
505 if (byteTestValue1 >= f.byteValue) {
506 return f;
507 }
508 return null;
509 }
510
511 public static Object testByteSwappedCompareGreaterEqualConstant2(FieldObject f) {
512 if (byteTestValue2 >= f.byteValue) {
513 return f;
514 }
515 return null;
516 }
517
518 @Test
519 public void testByteSwappedComparesGreaterEqual() {
520 FieldObject f = new FieldObject();
521 test("testByteSwappedCompareGreaterEqual", f, byteTestValue1);
522 test("testByteSwappedCompareGreaterEqualConstant1", f);
523 test("testByteSwappedCompareGreaterEqualConstant2", f);
524 }
525
526 @Test
527 public void testByteNullSwappedComparesGreaterEqual() {
528 test("testByteSwappedCompareGreaterEqual", null, byteTestValue1);
529 }
530
531 @Test
532 public void testByteNullSwappedComparesGreaterEqual1() {
533 test("testByteSwappedCompareGreaterEqualConstant1", (Object) null);
534 }
535
536 @Test
537 public void testByteNullSwappedComparesGreaterEqual2() {
538 test("testByteSwappedCompareGreaterEqualConstant2", (Object) null);
539 }
540
541 public static Object testShortCompare(FieldObject f, short shortValue) {
542 if (f.shortValue == shortValue) {
543 return f;
544 }
545 return null;
546 }
547
548 public static Object testShortCompareConstant1(FieldObject f) {
549 if (f.shortValue == shortTestValue1) {
550 return f;
551 }
552 return null;
553 }
554
555 public static Object testShortCompareConstant2(FieldObject f) {
556 if (f.shortValue == shortTestValue2) {
557 return f;
558 }
559 return null;
560 }
561
562 @Test
563 public void testShortCompares() {
564 FieldObject f = new FieldObject();
565 test("testShortCompare", f, shortTestValue1);
566 test("testShortCompareConstant1", f);
567 test("testShortCompareConstant2", f);
568 }
569
570 @Test
571 public void testShortNullCompares() {
572 test("testShortCompare", null, shortTestValue1);
573 }
574
575 @Test
576 public void testShortNullCompares1() {
577 test("testShortCompareConstant1", (Object) null);
578 }
579
580 @Test
581 public void testShortNullCompares2() {
582 test("testShortCompareConstant2", (Object) null);
583 }
584
585 public static Object testShortCompareLess(FieldObject f, short shortValue) {
586 if (f.shortValue < shortValue) {
587 return f;
588 }
589 return null;
590 }
591
592 public static Object testShortCompareLessConstant1(FieldObject f) {
593 if (f.shortValue < shortTestValue1) {
594 return f;
595 }
596 return null;
597 }
598
599 public static Object testShortCompareLessConstant2(FieldObject f) {
600 if (f.shortValue < shortTestValue2) {
601 return f;
602 }
603 return null;
604 }
605
606 @Test
607 public void testShortComparesLess() {
608 FieldObject f = new FieldObject();
609 test("testShortCompareLess", f, shortTestValue1);
610 test("testShortCompareLessConstant1", f);
611 test("testShortCompareLessConstant2", f);
612 }
613
614 @Test
615 public void testShortNullComparesLess() {
616 test("testShortCompareLess", null, shortTestValue1);
617 }
618
619 @Test
620 public void testShortNullComparesLess1() {
621 test("testShortCompareLessConstant1", (Object) null);
622 }
623
624 @Test
625 public void testShortNullComparesLess2() {
626 test("testShortCompareLessConstant2", (Object) null);
627 }
628
629 public static Object testShortSwappedCompareLess(FieldObject f, short shortValue) {
630 if (shortValue < f.shortValue) {
631 return f;
632 }
633 return null;
634 }
635
636 public static Object testShortSwappedCompareLessConstant1(FieldObject f) {
637 if (shortTestValue1 < f.shortValue) {
638 return f;
639 }
640 return null;
641 }
642
643 public static Object testShortSwappedCompareLessConstant2(FieldObject f) {
644 if (shortTestValue2 < f.shortValue) {
645 return f;
646 }
647 return null;
648 }
649
650 @Test
651 public void testShortSwappedComparesLess() {
652 FieldObject f = new FieldObject();
653 test("testShortSwappedCompareLess", f, shortTestValue1);
654 test("testShortSwappedCompareLessConstant1", f);
655 test("testShortSwappedCompareLessConstant2", f);
656 }
657
658 @Test
659 public void testShortNullSwappedComparesLess() {
660 test("testShortSwappedCompareLess", null, shortTestValue1);
661 }
662
663 @Test
664 public void testShortNullSwappedComparesLess1() {
665 test("testShortSwappedCompareLessConstant1", (Object) null);
666 }
667
668 @Test
669 public void testShortNullSwappedComparesLess2() {
670 test("testShortSwappedCompareLessConstant2", (Object) null);
671 }
672
673 public static Object testShortCompareLessEqual(FieldObject f, short shortValue) {
674 if (f.shortValue <= shortValue) {
675 return f;
676 }
677 return null;
678 }
679
680 public static Object testShortCompareLessEqualConstant1(FieldObject f) {
681 if (f.shortValue <= shortTestValue1) {
682 return f;
683 }
684 return null;
685 }
686
687 public static Object testShortCompareLessEqualConstant2(FieldObject f) {
688 if (f.shortValue <= shortTestValue2) {
689 return f;
690 }
691 return null;
692 }
693
694 @Test
695 public void testShortComparesLessEqual() {
696 FieldObject f = new FieldObject();
697 test("testShortCompareLessEqual", f, shortTestValue1);
698 test("testShortCompareLessEqualConstant1", f);
699 test("testShortCompareLessEqualConstant2", f);
700 }
701
702 @Test
703 public void testShortNullComparesLessEqual() {
704 test("testShortCompareLessEqual", null, shortTestValue1);
705 }
706
707 @Test
708 public void testShortNullComparesLessEqual1() {
709 test("testShortCompareLessEqualConstant1", (Object) null);
710 }
711
712 @Test
713 public void testShortNullComparesLessEqual2() {
714 test("testShortCompareLessEqualConstant2", (Object) null);
715 }
716
717 public static Object testShortSwappedCompareLessEqual(FieldObject f, short shortValue) {
718 if (shortValue <= f.shortValue) {
719 return f;
720 }
721 return null;
722 }
723
724 public static Object testShortSwappedCompareLessEqualConstant1(FieldObject f) {
725 if (shortTestValue1 <= f.shortValue) {
726 return f;
727 }
728 return null;
729 }
730
731 public static Object testShortSwappedCompareLessEqualConstant2(FieldObject f) {
732 if (shortTestValue2 <= f.shortValue) {
733 return f;
734 }
735 return null;
736 }
737
738 @Test
739 public void testShortSwappedComparesLessEqual() {
740 FieldObject f = new FieldObject();
741 test("testShortSwappedCompareLessEqual", f, shortTestValue1);
742 test("testShortSwappedCompareLessEqualConstant1", f);
743 test("testShortSwappedCompareLessEqualConstant2", f);
744 }
745
746 @Test
747 public void testShortNullSwappedComparesLessEqual() {
748 test("testShortSwappedCompareLessEqual", null, shortTestValue1);
749 }
750
751 @Test
752 public void testShortNullSwappedComparesLessEqual1() {
753 test("testShortSwappedCompareLessEqualConstant1", (Object) null);
754 }
755
756 @Test
757 public void testShortNullSwappedComparesLessEqual2() {
758 test("testShortSwappedCompareLessEqualConstant2", (Object) null);
759 }
760
761 public static Object testShortCompareGreater(FieldObject f, short shortValue) {
762 if (f.shortValue > shortValue) {
763 return f;
764 }
765 return null;
766 }
767
768 public static Object testShortCompareGreaterConstant1(FieldObject f) {
769 if (f.shortValue > shortTestValue1) {
770 return f;
771 }
772 return null;
773 }
774
775 public static Object testShortCompareGreaterConstant2(FieldObject f) {
776 if (f.shortValue > shortTestValue2) {
777 return f;
778 }
779 return null;
780 }
781
782 @Test
783 public void testShortComparesGreater() {
784 FieldObject f = new FieldObject();
785 test("testShortCompareGreater", f, shortTestValue1);
786 test("testShortCompareGreaterConstant1", f);
787 test("testShortCompareGreaterConstant2", f);
788 }
789
790 @Test
791 public void testShortNullComparesGreater() {
792 test("testShortCompareGreater", null, shortTestValue1);
793 }
794
795 @Test
796 public void testShortNullComparesGreater1() {
797 test("testShortCompareGreaterConstant1", (Object) null);
798 }
799
800 @Test
801 public void testShortNullComparesGreater2() {
802 test("testShortCompareGreaterConstant2", (Object) null);
803 }
804
805 public static Object testShortSwappedCompareGreater(FieldObject f, short shortValue) {
806 if (shortValue > f.shortValue) {
807 return f;
808 }
809 return null;
810 }
811
812 public static Object testShortSwappedCompareGreaterConstant1(FieldObject f) {
813 if (shortTestValue1 > f.shortValue) {
814 return f;
815 }
816 return null;
817 }
818
819 public static Object testShortSwappedCompareGreaterConstant2(FieldObject f) {
820 if (shortTestValue2 > f.shortValue) {
821 return f;
822 }
823 return null;
824 }
825
826 @Test
827 public void testShortSwappedComparesGreater() {
828 FieldObject f = new FieldObject();
829 test("testShortSwappedCompareGreater", f, shortTestValue1);
830 test("testShortSwappedCompareGreaterConstant1", f);
831 test("testShortSwappedCompareGreaterConstant2", f);
832 }
833
834 @Test
835 public void testShortNullSwappedComparesGreater() {
836 test("testShortSwappedCompareGreater", null, shortTestValue1);
837 }
838
839 @Test
840 public void testShortNullSwappedComparesGreater1() {
841 test("testShortSwappedCompareGreaterConstant1", (Object) null);
842 }
843
844 @Test
845 public void testShortNullSwappedComparesGreater2() {
846 test("testShortSwappedCompareGreaterConstant2", (Object) null);
847 }
848
849 public static Object testShortCompareGreaterEqual(FieldObject f, short shortValue) {
850 if (f.shortValue >= shortValue) {
851 return f;
852 }
853 return null;
854 }
855
856 public static Object testShortCompareGreaterEqualConstant1(FieldObject f) {
857 if (f.shortValue >= shortTestValue1) {
858 return f;
859 }
860 return null;
861 }
862
863 public static Object testShortCompareGreaterEqualConstant2(FieldObject f) {
864 if (f.shortValue >= shortTestValue2) {
865 return f;
866 }
867 return null;
868 }
869
870 @Test
871 public void testShortComparesGreaterEqual() {
872 FieldObject f = new FieldObject();
873 test("testShortCompareGreaterEqual", f, shortTestValue1);
874 test("testShortCompareGreaterEqualConstant1", f);
875 test("testShortCompareGreaterEqualConstant2", f);
876 }
877
878 @Test
879 public void testShortNullComparesGreaterEqual() {
880 test("testShortCompareGreaterEqual", null, shortTestValue1);
881 }
882
883 @Test
884 public void testShortNullComparesGreaterEqual1() {
885 test("testShortCompareGreaterEqualConstant1", (Object) null);
886 }
887
888 @Test
889 public void testShortNullComparesGreaterEqual2() {
890 test("testShortCompareGreaterEqualConstant2", (Object) null);
891 }
892
893 public static Object testShortSwappedCompareGreaterEqual(FieldObject f, short shortValue) {
894 if (shortValue >= f.shortValue) {
895 return f;
896 }
897 return null;
898 }
899
900 public static Object testShortSwappedCompareGreaterEqualConstant1(FieldObject f) {
901 if (shortTestValue1 >= f.shortValue) {
902 return f;
903 }
904 return null;
905 }
906
907 public static Object testShortSwappedCompareGreaterEqualConstant2(FieldObject f) {
908 if (shortTestValue2 >= f.shortValue) {
909 return f;
910 }
911 return null;
912 }
913
914 @Test
915 public void testShortSwappedComparesGreaterEqual() {
916 FieldObject f = new FieldObject();
917 test("testShortSwappedCompareGreaterEqual", f, shortTestValue1);
918 test("testShortSwappedCompareGreaterEqualConstant1", f);
919 test("testShortSwappedCompareGreaterEqualConstant2", f);
920 }
921
922 @Test
923 public void testShortNullSwappedComparesGreaterEqual() {
924 test("testShortSwappedCompareGreaterEqual", null, shortTestValue1);
925 }
926
927 @Test
928 public void testShortNullSwappedComparesGreaterEqual1() {
929 test("testShortSwappedCompareGreaterEqualConstant1", (Object) null);
930 }
931
932 @Test
933 public void testShortNullSwappedComparesGreaterEqual2() {
934 test("testShortSwappedCompareGreaterEqualConstant2", (Object) null);
935 }
936
937 public static Object testCharCompare(FieldObject f, char charValue) {
938 if (f.charValue == charValue) {
939 return f;
940 }
941 return null;
942 }
943
944 public static Object testCharCompareConstant1(FieldObject f) {
945 if (f.charValue == charTestValue1) {
946 return f;
947 }
948 return null;
949 }
950
951 public static Object testCharCompareConstant2(FieldObject f) {
952 if (f.charValue == charTestValue2) {
953 return f;
954 }
955 return null;
956 }
957
958 @Test
959 public void testCharCompares() {
960 FieldObject f = new FieldObject();
961 test("testCharCompare", f, charTestValue1);
962 test("testCharCompareConstant1", f);
963 test("testCharCompareConstant2", f);
964 }
965
966 @Test
967 public void testCharNullCompares() {
968 test("testCharCompare", null, charTestValue1);
969 }
970
971 @Test
972 public void testCharNullCompares1() {
973 test("testCharCompareConstant1", (Object) null);
974 }
975
976 @Test
977 public void testCharNullCompares2() {
978 test("testCharCompareConstant2", (Object) null);
979 }
980
981 public static Object testCharCompareLess(FieldObject f, char charValue) {
982 if (f.charValue < charValue) {
983 return f;
984 }
985 return null;
986 }
987
988 public static Object testCharCompareLessConstant1(FieldObject f) {
989 if (f.charValue < charTestValue1) {
990 return f;
991 }
992 return null;
993 }
994
995 public static Object testCharCompareLessConstant2(FieldObject f) {
996 if (f.charValue < charTestValue2) {
997 return f;
998 }
999 return null;
1000 }
1001
1002 @Test
1003 public void testCharComparesLess() {
1004 FieldObject f = new FieldObject();
1005 test("testCharCompareLess", f, charTestValue1);
1006 test("testCharCompareLessConstant1", f);
1007 test("testCharCompareLessConstant2", f);
1008 }
1009
1010 @Test
1011 public void testCharNullComparesLess() {
1012 test("testCharCompareLess", null, charTestValue1);
1013 }
1014
1015 @Test
1016 public void testCharNullComparesLess1() {
1017 test("testCharCompareLessConstant1", (Object) null);
1018 }
1019
1020 @Test
1021 public void testCharNullComparesLess2() {
1022 test("testCharCompareLessConstant2", (Object) null);
1023 }
1024
1025 public static Object testCharSwappedCompareLess(FieldObject f, char charValue) {
1026 if (charValue < f.charValue) {
1027 return f;
1028 }
1029 return null;
1030 }
1031
1032 public static Object testCharSwappedCompareLessConstant1(FieldObject f) {
1033 if (charTestValue1 < f.charValue) {
1034 return f;
1035 }
1036 return null;
1037 }
1038
1039 public static Object testCharSwappedCompareLessConstant2(FieldObject f) {
1040 if (charTestValue2 < f.charValue) {
1041 return f;
1042 }
1043 return null;
1044 }
1045
1046 @Test
1047 public void testCharSwappedComparesLess() {
1048 FieldObject f = new FieldObject();
1049 test("testCharSwappedCompareLess", f, charTestValue1);
1050 test("testCharSwappedCompareLessConstant1", f);
1051 test("testCharSwappedCompareLessConstant2", f);
1052 }
1053
1054 @Test
1055 public void testCharNullSwappedComparesLess() {
1056 test("testCharSwappedCompareLess", null, charTestValue1);
1057 }
1058
1059 @Test
1060 public void testCharNullSwappedComparesLess1() {
1061 test("testCharSwappedCompareLessConstant1", (Object) null);
1062 }
1063
1064 @Test
1065 public void testCharNullSwappedComparesLess2() {
1066 test("testCharSwappedCompareLessConstant2", (Object) null);
1067 }
1068
1069 public static Object testCharCompareLessEqual(FieldObject f, char charValue) {
1070 if (f.charValue <= charValue) {
1071 return f;
1072 }
1073 return null;
1074 }
1075
1076 public static Object testCharCompareLessEqualConstant1(FieldObject f) {
1077 if (f.charValue <= charTestValue1) {
1078 return f;
1079 }
1080 return null;
1081 }
1082
1083 public static Object testCharCompareLessEqualConstant2(FieldObject f) {
1084 if (f.charValue <= charTestValue2) {
1085 return f;
1086 }
1087 return null;
1088 }
1089
1090 @Test
1091 public void testCharComparesLessEqual() {
1092 FieldObject f = new FieldObject();
1093 test("testCharCompareLessEqual", f, charTestValue1);
1094 test("testCharCompareLessEqualConstant1", f);
1095 test("testCharCompareLessEqualConstant2", f);
1096 }
1097
1098 @Test
1099 public void testCharNullComparesLessEqual() {
1100 test("testCharCompareLessEqual", null, charTestValue1);
1101 }
1102
1103 @Test
1104 public void testCharNullComparesLessEqual1() {
1105 test("testCharCompareLessEqualConstant1", (Object) null);
1106 }
1107
1108 @Test
1109 public void testCharNullComparesLessEqual2() {
1110 test("testCharCompareLessEqualConstant2", (Object) null);
1111 }
1112
1113 public static Object testCharSwappedCompareLessEqual(FieldObject f, char charValue) {
1114 if (charValue <= f.charValue) {
1115 return f;
1116 }
1117 return null;
1118 }
1119
1120 public static Object testCharSwappedCompareLessEqualConstant1(FieldObject f) {
1121 if (charTestValue1 <= f.charValue) {
1122 return f;
1123 }
1124 return null;
1125 }
1126
1127 public static Object testCharSwappedCompareLessEqualConstant2(FieldObject f) {
1128 if (charTestValue2 <= f.charValue) {
1129 return f;
1130 }
1131 return null;
1132 }
1133
1134 @Test
1135 public void testCharSwappedComparesLessEqual() {
1136 FieldObject f = new FieldObject();
1137 test("testCharSwappedCompareLessEqual", f, charTestValue1);
1138 test("testCharSwappedCompareLessEqualConstant1", f);
1139 test("testCharSwappedCompareLessEqualConstant2", f);
1140 }
1141
1142 @Test
1143 public void testCharNullSwappedComparesLessEqual() {
1144 test("testCharSwappedCompareLessEqual", null, charTestValue1);
1145 }
1146
1147 @Test
1148 public void testCharNullSwappedComparesLessEqual1() {
1149 test("testCharSwappedCompareLessEqualConstant1", (Object) null);
1150 }
1151
1152 @Test
1153 public void testCharNullSwappedComparesLessEqual2() {
1154 test("testCharSwappedCompareLessEqualConstant2", (Object) null);
1155 }
1156
1157 public static Object testCharCompareGreater(FieldObject f, char charValue) {
1158 if (f.charValue > charValue) {
1159 return f;
1160 }
1161 return null;
1162 }
1163
1164 public static Object testCharCompareGreaterConstant1(FieldObject f) {
1165 if (f.charValue > charTestValue1) {
1166 return f;
1167 }
1168 return null;
1169 }
1170
1171 public static Object testCharCompareGreaterConstant2(FieldObject f) {
1172 if (f.charValue > charTestValue2) {
1173 return f;
1174 }
1175 return null;
1176 }
1177
1178 @Test
1179 public void testCharComparesGreater() {
1180 FieldObject f = new FieldObject();
1181 test("testCharCompareGreater", f, charTestValue1);
1182 test("testCharCompareGreaterConstant1", f);
1183 test("testCharCompareGreaterConstant2", f);
1184 }
1185
1186 @Test
1187 public void testCharNullComparesGreater() {
1188 test("testCharCompareGreater", null, charTestValue1);
1189 }
1190
1191 @Test
1192 public void testCharNullComparesGreater1() {
1193 test("testCharCompareGreaterConstant1", (Object) null);
1194 }
1195
1196 @Test
1197 public void testCharNullComparesGreater2() {
1198 test("testCharCompareGreaterConstant2", (Object) null);
1199 }
1200
1201 public static Object testCharSwappedCompareGreater(FieldObject f, char charValue) {
1202 if (charValue > f.charValue) {
1203 return f;
1204 }
1205 return null;
1206 }
1207
1208 public static Object testCharSwappedCompareGreaterConstant1(FieldObject f) {
1209 if (charTestValue1 > f.charValue) {
1210 return f;
1211 }
1212 return null;
1213 }
1214
1215 public static Object testCharSwappedCompareGreaterConstant2(FieldObject f) {
1216 if (charTestValue2 > f.charValue) {
1217 return f;
1218 }
1219 return null;
1220 }
1221
1222 @Test
1223 public void testCharSwappedComparesGreater() {
1224 FieldObject f = new FieldObject();
1225 test("testCharSwappedCompareGreater", f, charTestValue1);
1226 test("testCharSwappedCompareGreaterConstant1", f);
1227 test("testCharSwappedCompareGreaterConstant2", f);
1228 }
1229
1230 @Test
1231 public void testCharNullSwappedComparesGreater() {
1232 test("testCharSwappedCompareGreater", null, charTestValue1);
1233 }
1234
1235 @Test
1236 public void testCharNullSwappedComparesGreater1() {
1237 test("testCharSwappedCompareGreaterConstant1", (Object) null);
1238 }
1239
1240 @Test
1241 public void testCharNullSwappedComparesGreater2() {
1242 test("testCharSwappedCompareGreaterConstant2", (Object) null);
1243 }
1244
1245 public static Object testCharCompareGreaterEqual(FieldObject f, char charValue) {
1246 if (f.charValue >= charValue) {
1247 return f;
1248 }
1249 return null;
1250 }
1251
1252 public static Object testCharCompareGreaterEqualConstant1(FieldObject f) {
1253 if (f.charValue >= charTestValue1) {
1254 return f;
1255 }
1256 return null;
1257 }
1258
1259 public static Object testCharCompareGreaterEqualConstant2(FieldObject f) {
1260 if (f.charValue >= charTestValue2) {
1261 return f;
1262 }
1263 return null;
1264 }
1265
1266 @Test
1267 public void testCharComparesGreaterEqual() {
1268 FieldObject f = new FieldObject();
1269 test("testCharCompareGreaterEqual", f, charTestValue1);
1270 test("testCharCompareGreaterEqualConstant1", f);
1271 test("testCharCompareGreaterEqualConstant2", f);
1272 }
1273
1274 @Test
1275 public void testCharNullComparesGreaterEqual() {
1276 test("testCharCompareGreaterEqual", null, charTestValue1);
1277 }
1278
1279 @Test
1280 public void testCharNullComparesGreaterEqual1() {
1281 test("testCharCompareGreaterEqualConstant1", (Object) null);
1282 }
1283
1284 @Test
1285 public void testCharNullComparesGreaterEqual2() {
1286 test("testCharCompareGreaterEqualConstant2", (Object) null);
1287 }
1288
1289 public static Object testCharSwappedCompareGreaterEqual(FieldObject f, char charValue) {
1290 if (charValue >= f.charValue) {
1291 return f;
1292 }
1293 return null;
1294 }
1295
1296 public static Object testCharSwappedCompareGreaterEqualConstant1(FieldObject f) {
1297 if (charTestValue1 >= f.charValue) {
1298 return f;
1299 }
1300 return null;
1301 }
1302
1303 public static Object testCharSwappedCompareGreaterEqualConstant2(FieldObject f) {
1304 if (charTestValue2 >= f.charValue) {
1305 return f;
1306 }
1307 return null;
1308 }
1309
1310 @Test
1311 public void testCharSwappedComparesGreaterEqual() {
1312 FieldObject f = new FieldObject();
1313 test("testCharSwappedCompareGreaterEqual", f, charTestValue1);
1314 test("testCharSwappedCompareGreaterEqualConstant1", f);
1315 test("testCharSwappedCompareGreaterEqualConstant2", f);
1316 }
1317
1318 @Test
1319 public void testCharNullSwappedComparesGreaterEqual() {
1320 test("testCharSwappedCompareGreaterEqual", null, charTestValue1);
1321 }
1322
1323 @Test
1324 public void testCharNullSwappedComparesGreaterEqual1() {
1325 test("testCharSwappedCompareGreaterEqualConstant1", (Object) null);
1326 }
1327
1328 @Test
1329 public void testCharNullSwappedComparesGreaterEqual2() {
1330 test("testCharSwappedCompareGreaterEqualConstant2", (Object) null);
1331 }
1332
1333 public static Object testIntCompare(FieldObject f, int intValue) {
1334 if (f.intValue == intValue) {
1335 return f;
1336 }
1337 return null;
1338 }
1339
1340 public static Object testIntCompareConstant1(FieldObject f) {
1341 if (f.intValue == intTestValue1) {
1342 return f;
1343 }
1344 return null;
1345 }
1346
1347 public static Object testIntCompareConstant2(FieldObject f) {
1348 if (f.intValue == intTestValue2) {
1349 return f;
1350 }
1351 return null;
1352 }
1353
1354 @Test
1355 public void testIntCompares() {
1356 FieldObject f = new FieldObject();
1357 test("testIntCompare", f, intTestValue1);
1358 test("testIntCompareConstant1", f);
1359 test("testIntCompareConstant2", f);
1360 }
1361
1362 @Test
1363 public void testIntNullCompares() {
1364 test("testIntCompare", null, intTestValue1);
1365 }
1366
1367 @Test
1368 public void testIntNullCompares1() {
1369 test("testIntCompareConstant1", (Object) null);
1370 }
1371
1372 @Test
1373 public void testIntNullCompares2() {
1374 test("testIntCompareConstant2", (Object) null);
1375 }
1376
1377 public static Object testIntCompareLess(FieldObject f, int intValue) {
1378 if (f.intValue < intValue) {
1379 return f;
1380 }
1381 return null;
1382 }
1383
1384 public static Object testIntCompareLessConstant1(FieldObject f) {
1385 if (f.intValue < intTestValue1) {
1386 return f;
1387 }
1388 return null;
1389 }
1390
1391 public static Object testIntCompareLessConstant2(FieldObject f) {
1392 if (f.intValue < intTestValue2) {
1393 return f;
1394 }
1395 return null;
1396 }
1397
1398 @Test
1399 public void testIntComparesLess() {
1400 FieldObject f = new FieldObject();
1401 test("testIntCompareLess", f, intTestValue1);
1402 test("testIntCompareLessConstant1", f);
1403 test("testIntCompareLessConstant2", f);
1404 }
1405
1406 @Test
1407 public void testIntNullComparesLess() {
1408 test("testIntCompareLess", null, intTestValue1);
1409 }
1410
1411 @Test
1412 public void testIntNullComparesLess1() {
1413 test("testIntCompareLessConstant1", (Object) null);
1414 }
1415
1416 @Test
1417 public void testIntNullComparesLess2() {
1418 test("testIntCompareLessConstant2", (Object) null);
1419 }
1420
1421 public static Object testIntSwappedCompareLess(FieldObject f, int intValue) {
1422 if (intValue < f.intValue) {
1423 return f;
1424 }
1425 return null;
1426 }
1427
1428 public static Object testIntSwappedCompareLessConstant1(FieldObject f) {
1429 if (intTestValue1 < f.intValue) {
1430 return f;
1431 }
1432 return null;
1433 }
1434
1435 public static Object testIntSwappedCompareLessConstant2(FieldObject f) {
1436 if (intTestValue2 < f.intValue) {
1437 return f;
1438 }
1439 return null;
1440 }
1441
1442 @Test
1443 public void testIntSwappedComparesLess() {
1444 FieldObject f = new FieldObject();
1445 test("testIntSwappedCompareLess", f, intTestValue1);
1446 test("testIntSwappedCompareLessConstant1", f);
1447 test("testIntSwappedCompareLessConstant2", f);
1448 }
1449
1450 @Test
1451 public void testIntNullSwappedComparesLess() {
1452 test("testIntSwappedCompareLess", null, intTestValue1);
1453 }
1454
1455 @Test
1456 public void testIntNullSwappedComparesLess1() {
1457 test("testIntSwappedCompareLessConstant1", (Object) null);
1458 }
1459
1460 @Test
1461 public void testIntNullSwappedComparesLess2() {
1462 test("testIntSwappedCompareLessConstant2", (Object) null);
1463 }
1464
1465 public static Object testIntCompareLessEqual(FieldObject f, int intValue) {
1466 if (f.intValue <= intValue) {
1467 return f;
1468 }
1469 return null;
1470 }
1471
1472 public static Object testIntCompareLessEqualConstant1(FieldObject f) {
1473 if (f.intValue <= intTestValue1) {
1474 return f;
1475 }
1476 return null;
1477 }
1478
1479 public static Object testIntCompareLessEqualConstant2(FieldObject f) {
1480 if (f.intValue <= intTestValue2) {
1481 return f;
1482 }
1483 return null;
1484 }
1485
1486 @Test
1487 public void testIntComparesLessEqual() {
1488 FieldObject f = new FieldObject();
1489 test("testIntCompareLessEqual", f, intTestValue1);
1490 test("testIntCompareLessEqualConstant1", f);
1491 test("testIntCompareLessEqualConstant2", f);
1492 }
1493
1494 @Test
1495 public void testIntNullComparesLessEqual() {
1496 test("testIntCompareLessEqual", null, intTestValue1);
1497 }
1498
1499 @Test
1500 public void testIntNullComparesLessEqual1() {
1501 test("testIntCompareLessEqualConstant1", (Object) null);
1502 }
1503
1504 @Test
1505 public void testIntNullComparesLessEqual2() {
1506 test("testIntCompareLessEqualConstant2", (Object) null);
1507 }
1508
1509 public static Object testIntSwappedCompareLessEqual(FieldObject f, int intValue) {
1510 if (intValue <= f.intValue) {
1511 return f;
1512 }
1513 return null;
1514 }
1515
1516 public static Object testIntSwappedCompareLessEqualConstant1(FieldObject f) {
1517 if (intTestValue1 <= f.intValue) {
1518 return f;
1519 }
1520 return null;
1521 }
1522
1523 public static Object testIntSwappedCompareLessEqualConstant2(FieldObject f) {
1524 if (intTestValue2 <= f.intValue) {
1525 return f;
1526 }
1527 return null;
1528 }
1529
1530 @Test
1531 public void testIntSwappedComparesLessEqual() {
1532 FieldObject f = new FieldObject();
1533 test("testIntSwappedCompareLessEqual", f, intTestValue1);
1534 test("testIntSwappedCompareLessEqualConstant1", f);
1535 test("testIntSwappedCompareLessEqualConstant2", f);
1536 }
1537
1538 @Test
1539 public void testIntNullSwappedComparesLessEqual() {
1540 test("testIntSwappedCompareLessEqual", null, intTestValue1);
1541 }
1542
1543 @Test
1544 public void testIntNullSwappedComparesLessEqual1() {
1545 test("testIntSwappedCompareLessEqualConstant1", (Object) null);
1546 }
1547
1548 @Test
1549 public void testIntNullSwappedComparesLessEqual2() {
1550 test("testIntSwappedCompareLessEqualConstant2", (Object) null);
1551 }
1552
1553 public static Object testIntCompareGreater(FieldObject f, int intValue) {
1554 if (f.intValue > intValue) {
1555 return f;
1556 }
1557 return null;
1558 }
1559
1560 public static Object testIntCompareGreaterConstant1(FieldObject f) {
1561 if (f.intValue > intTestValue1) {
1562 return f;
1563 }
1564 return null;
1565 }
1566
1567 public static Object testIntCompareGreaterConstant2(FieldObject f) {
1568 if (f.intValue > intTestValue2) {
1569 return f;
1570 }
1571 return null;
1572 }
1573
1574 @Test
1575 public void testIntComparesGreater() {
1576 FieldObject f = new FieldObject();
1577 test("testIntCompareGreater", f, intTestValue1);
1578 test("testIntCompareGreaterConstant1", f);
1579 test("testIntCompareGreaterConstant2", f);
1580 }
1581
1582 @Test
1583 public void testIntNullComparesGreater() {
1584 test("testIntCompareGreater", null, intTestValue1);
1585 }
1586
1587 @Test
1588 public void testIntNullComparesGreater1() {
1589 test("testIntCompareGreaterConstant1", (Object) null);
1590 }
1591
1592 @Test
1593 public void testIntNullComparesGreater2() {
1594 test("testIntCompareGreaterConstant2", (Object) null);
1595 }
1596
1597 public static Object testIntSwappedCompareGreater(FieldObject f, int intValue) {
1598 if (intValue > f.intValue) {
1599 return f;
1600 }
1601 return null;
1602 }
1603
1604 public static Object testIntSwappedCompareGreaterConstant1(FieldObject f) {
1605 if (intTestValue1 > f.intValue) {
1606 return f;
1607 }
1608 return null;
1609 }
1610
1611 public static Object testIntSwappedCompareGreaterConstant2(FieldObject f) {
1612 if (intTestValue2 > f.intValue) {
1613 return f;
1614 }
1615 return null;
1616 }
1617
1618 @Test
1619 public void testIntSwappedComparesGreater() {
1620 FieldObject f = new FieldObject();
1621 test("testIntSwappedCompareGreater", f, intTestValue1);
1622 test("testIntSwappedCompareGreaterConstant1", f);
1623 test("testIntSwappedCompareGreaterConstant2", f);
1624 }
1625
1626 @Test
1627 public void testIntNullSwappedComparesGreater() {
1628 test("testIntSwappedCompareGreater", null, intTestValue1);
1629 }
1630
1631 @Test
1632 public void testIntNullSwappedComparesGreater1() {
1633 test("testIntSwappedCompareGreaterConstant1", (Object) null);
1634 }
1635
1636 @Test
1637 public void testIntNullSwappedComparesGreater2() {
1638 test("testIntSwappedCompareGreaterConstant2", (Object) null);
1639 }
1640
1641 public static Object testIntCompareGreaterEqual(FieldObject f, int intValue) {
1642 if (f.intValue >= intValue) {
1643 return f;
1644 }
1645 return null;
1646 }
1647
1648 public static Object testIntCompareGreaterEqualConstant1(FieldObject f) {
1649 if (f.intValue >= intTestValue1) {
1650 return f;
1651 }
1652 return null;
1653 }
1654
1655 public static Object testIntCompareGreaterEqualConstant2(FieldObject f) {
1656 if (f.intValue >= intTestValue2) {
1657 return f;
1658 }
1659 return null;
1660 }
1661
1662 @Test
1663 public void testIntComparesGreaterEqual() {
1664 FieldObject f = new FieldObject();
1665 test("testIntCompareGreaterEqual", f, intTestValue1);
1666 test("testIntCompareGreaterEqualConstant1", f);
1667 test("testIntCompareGreaterEqualConstant2", f);
1668 }
1669
1670 @Test
1671 public void testIntNullComparesGreaterEqual() {
1672 test("testIntCompareGreaterEqual", null, intTestValue1);
1673 }
1674
1675 @Test
1676 public void testIntNullComparesGreaterEqual1() {
1677 test("testIntCompareGreaterEqualConstant1", (Object) null);
1678 }
1679
1680 @Test
1681 public void testIntNullComparesGreaterEqual2() {
1682 test("testIntCompareGreaterEqualConstant2", (Object) null);
1683 }
1684
1685 public static Object testIntSwappedCompareGreaterEqual(FieldObject f, int intValue) {
1686 if (intValue >= f.intValue) {
1687 return f;
1688 }
1689 return null;
1690 }
1691
1692 public static Object testIntSwappedCompareGreaterEqualConstant1(FieldObject f) {
1693 if (intTestValue1 >= f.intValue) {
1694 return f;
1695 }
1696 return null;
1697 }
1698
1699 public static Object testIntSwappedCompareGreaterEqualConstant2(FieldObject f) {
1700 if (intTestValue2 >= f.intValue) {
1701 return f;
1702 }
1703 return null;
1704 }
1705
1706 @Test
1707 public void testIntSwappedComparesGreaterEqual() {
1708 FieldObject f = new FieldObject();
1709 test("testIntSwappedCompareGreaterEqual", f, intTestValue1);
1710 test("testIntSwappedCompareGreaterEqualConstant1", f);
1711 test("testIntSwappedCompareGreaterEqualConstant2", f);
1712 }
1713
1714 @Test
1715 public void testIntNullSwappedComparesGreaterEqual() {
1716 test("testIntSwappedCompareGreaterEqual", null, intTestValue1);
1717 }
1718
1719 @Test
1720 public void testIntNullSwappedComparesGreaterEqual1() {
1721 test("testIntSwappedCompareGreaterEqualConstant1", (Object) null);
1722 }
1723
1724 @Test
1725 public void testIntNullSwappedComparesGreaterEqual2() {
1726 test("testIntSwappedCompareGreaterEqualConstant2", (Object) null);
1727 }
1728
1729 public static Object testFloatCompare(FieldObject f, float floatValue) {
1730 if (f.floatValue == floatValue) {
1731 return f;
1732 }
1733 return null;
1734 }
1735
1736 public static Object testFloatCompareConstant1(FieldObject f) {
1737 if (f.floatValue == floatTestValue1) {
1738 return f;
1739 }
1740 return null;
1741 }
1742
1743 public static Object testFloatCompareConstant2(FieldObject f) {
1744 if (f.floatValue == floatTestValue2) {
1745 return f;
1746 }
1747 return null;
1748 }
1749
1750 @Test
1751 public void testFloatCompares() {
1752 FieldObject f = new FieldObject();
1753 test("testFloatCompare", f, floatTestValue1);
1754 test("testFloatCompareConstant1", f);
1755 test("testFloatCompareConstant2", f);
1756 }
1757
1758 @Test
1759 public void testFloatNullCompares() {
1760 test("testFloatCompare", null, floatTestValue1);
1761 }
1762
1763 @Test
1764 public void testFloatNullCompares1() {
1765 test("testFloatCompareConstant1", (Object) null);
1766 }
1767
1768 @Test
1769 public void testFloatNullCompares2() {
1770 test("testFloatCompareConstant2", (Object) null);
1771 }
1772
1773 public static Object testFloatCompareLess(FieldObject f, float floatValue) {
1774 if (f.floatValue < floatValue) {
1775 return f;
1776 }
1777 return null;
1778 }
1779
1780 public static Object testFloatCompareLessConstant1(FieldObject f) {
1781 if (f.floatValue < floatTestValue1) {
1782 return f;
1783 }
1784 return null;
1785 }
1786
1787 public static Object testFloatCompareLessConstant2(FieldObject f) {
1788 if (f.floatValue < floatTestValue2) {
1789 return f;
1790 }
1791 return null;
1792 }
1793
1794 @Test
1795 public void testFloatComparesLess() {
1796 FieldObject f = new FieldObject();
1797 test("testFloatCompareLess", f, floatTestValue1);
1798 test("testFloatCompareLessConstant1", f);
1799 test("testFloatCompareLessConstant2", f);
1800 }
1801
1802 @Test
1803 public void testFloatNullComparesLess() {
1804 test("testFloatCompareLess", null, floatTestValue1);
1805 }
1806
1807 @Test
1808 public void testFloatNullComparesLess1() {
1809 test("testFloatCompareLessConstant1", (Object) null);
1810 }
1811
1812 @Test
1813 public void testFloatNullComparesLess2() {
1814 test("testFloatCompareLessConstant2", (Object) null);
1815 }
1816
1817 public static Object testFloatSwappedCompareLess(FieldObject f, float floatValue) {
1818 if (floatValue < f.floatValue) {
1819 return f;
1820 }
1821 return null;
1822 }
1823
1824 public static Object testFloatSwappedCompareLessConstant1(FieldObject f) {
1825 if (floatTestValue1 < f.floatValue) {
1826 return f;
1827 }
1828 return null;
1829 }
1830
1831 public static Object testFloatSwappedCompareLessConstant2(FieldObject f) {
1832 if (floatTestValue2 < f.floatValue) {
1833 return f;
1834 }
1835 return null;
1836 }
1837
1838 @Test
1839 public void testFloatSwappedComparesLess() {
1840 FieldObject f = new FieldObject();
1841 test("testFloatSwappedCompareLess", f, floatTestValue1);
1842 test("testFloatSwappedCompareLessConstant1", f);
1843 test("testFloatSwappedCompareLessConstant2", f);
1844 }
1845
1846 @Test
1847 public void testFloatNullSwappedComparesLess() {
1848 test("testFloatSwappedCompareLess", null, floatTestValue1);
1849 }
1850
1851 @Test
1852 public void testFloatNullSwappedComparesLess1() {
1853 test("testFloatSwappedCompareLessConstant1", (Object) null);
1854 }
1855
1856 @Test
1857 public void testFloatNullSwappedComparesLess2() {
1858 test("testFloatSwappedCompareLessConstant2", (Object) null);
1859 }
1860
1861 public static Object testFloatCompareLessEqual(FieldObject f, float floatValue) {
1862 if (f.floatValue <= floatValue) {
1863 return f;
1864 }
1865 return null;
1866 }
1867
1868 public static Object testFloatCompareLessEqualConstant1(FieldObject f) {
1869 if (f.floatValue <= floatTestValue1) {
1870 return f;
1871 }
1872 return null;
1873 }
1874
1875 public static Object testFloatCompareLessEqualConstant2(FieldObject f) {
1876 if (f.floatValue <= floatTestValue2) {
1877 return f;
1878 }
1879 return null;
1880 }
1881
1882 @Test
1883 public void testFloatComparesLessEqual() {
1884 FieldObject f = new FieldObject();
1885 test("testFloatCompareLessEqual", f, floatTestValue1);
1886 test("testFloatCompareLessEqualConstant1", f);
1887 test("testFloatCompareLessEqualConstant2", f);
1888 }
1889
1890 @Test
1891 public void testFloatNullComparesLessEqual() {
1892 test("testFloatCompareLessEqual", null, floatTestValue1);
1893 }
1894
1895 @Test
1896 public void testFloatNullComparesLessEqual1() {
1897 test("testFloatCompareLessEqualConstant1", (Object) null);
1898 }
1899
1900 @Test
1901 public void testFloatNullComparesLessEqual2() {
1902 test("testFloatCompareLessEqualConstant2", (Object) null);
1903 }
1904
1905 public static Object testFloatSwappedCompareLessEqual(FieldObject f, float floatValue) {
1906 if (floatValue <= f.floatValue) {
1907 return f;
1908 }
1909 return null;
1910 }
1911
1912 public static Object testFloatSwappedCompareLessEqualConstant1(FieldObject f) {
1913 if (floatTestValue1 <= f.floatValue) {
1914 return f;
1915 }
1916 return null;
1917 }
1918
1919 public static Object testFloatSwappedCompareLessEqualConstant2(FieldObject f) {
1920 if (floatTestValue2 <= f.floatValue) {
1921 return f;
1922 }
1923 return null;
1924 }
1925
1926 @Test
1927 public void testFloatSwappedComparesLessEqual() {
1928 FieldObject f = new FieldObject();
1929 test("testFloatSwappedCompareLessEqual", f, floatTestValue1);
1930 test("testFloatSwappedCompareLessEqualConstant1", f);
1931 test("testFloatSwappedCompareLessEqualConstant2", f);
1932 }
1933
1934 @Test
1935 public void testFloatNullSwappedComparesLessEqual() {
1936 test("testFloatSwappedCompareLessEqual", null, floatTestValue1);
1937 }
1938
1939 @Test
1940 public void testFloatNullSwappedComparesLessEqual1() {
1941 test("testFloatSwappedCompareLessEqualConstant1", (Object) null);
1942 }
1943
1944 @Test
1945 public void testFloatNullSwappedComparesLessEqual2() {
1946 test("testFloatSwappedCompareLessEqualConstant2", (Object) null);
1947 }
1948
1949 public static Object testFloatCompareGreater(FieldObject f, float floatValue) {
1950 if (f.floatValue > floatValue) {
1951 return f;
1952 }
1953 return null;
1954 }
1955
1956 public static Object testFloatCompareGreaterConstant1(FieldObject f) {
1957 if (f.floatValue > floatTestValue1) {
1958 return f;
1959 }
1960 return null;
1961 }
1962
1963 public static Object testFloatCompareGreaterConstant2(FieldObject f) {
1964 if (f.floatValue > floatTestValue2) {
1965 return f;
1966 }
1967 return null;
1968 }
1969
1970 @Test
1971 public void testFloatComparesGreater() {
1972 FieldObject f = new FieldObject();
1973 test("testFloatCompareGreater", f, floatTestValue1);
1974 test("testFloatCompareGreaterConstant1", f);
1975 test("testFloatCompareGreaterConstant2", f);
1976 }
1977
1978 @Test
1979 public void testFloatNullComparesGreater() {
1980 test("testFloatCompareGreater", null, floatTestValue1);
1981 }
1982
1983 @Test
1984 public void testFloatNullComparesGreater1() {
1985 test("testFloatCompareGreaterConstant1", (Object) null);
1986 }
1987
1988 @Test
1989 public void testFloatNullComparesGreater2() {
1990 test("testFloatCompareGreaterConstant2", (Object) null);
1991 }
1992
1993 public static Object testFloatSwappedCompareGreater(FieldObject f, float floatValue) {
1994 if (floatValue > f.floatValue) {
1995 return f;
1996 }
1997 return null;
1998 }
1999
2000 public static Object testFloatSwappedCompareGreaterConstant1(FieldObject f) {
2001 if (floatTestValue1 > f.floatValue) {
2002 return f;
2003 }
2004 return null;
2005 }
2006
2007 public static Object testFloatSwappedCompareGreaterConstant2(FieldObject f) {
2008 if (floatTestValue2 > f.floatValue) {
2009 return f;
2010 }
2011 return null;
2012 }
2013
2014 @Test
2015 public void testFloatSwappedComparesGreater() {
2016 FieldObject f = new FieldObject();
2017 test("testFloatSwappedCompareGreater", f, floatTestValue1);
2018 test("testFloatSwappedCompareGreaterConstant1", f);
2019 test("testFloatSwappedCompareGreaterConstant2", f);
2020 }
2021
2022 @Test
2023 public void testFloatNullSwappedComparesGreater() {
2024 test("testFloatSwappedCompareGreater", null, floatTestValue1);
2025 }
2026
2027 @Test
2028 public void testFloatNullSwappedComparesGreater1() {
2029 test("testFloatSwappedCompareGreaterConstant1", (Object) null);
2030 }
2031
2032 @Test
2033 public void testFloatNullSwappedComparesGreater2() {
2034 test("testFloatSwappedCompareGreaterConstant2", (Object) null);
2035 }
2036
2037 public static Object testFloatCompareGreaterEqual(FieldObject f, float floatValue) {
2038 if (f.floatValue >= floatValue) {
2039 return f;
2040 }
2041 return null;
2042 }
2043
2044 public static Object testFloatCompareGreaterEqualConstant1(FieldObject f) {
2045 if (f.floatValue >= floatTestValue1) {
2046 return f;
2047 }
2048 return null;
2049 }
2050
2051 public static Object testFloatCompareGreaterEqualConstant2(FieldObject f) {
2052 if (f.floatValue >= floatTestValue2) {
2053 return f;
2054 }
2055 return null;
2056 }
2057
2058 @Test
2059 public void testFloatComparesGreaterEqual() {
2060 FieldObject f = new FieldObject();
2061 test("testFloatCompareGreaterEqual", f, floatTestValue1);
2062 test("testFloatCompareGreaterEqualConstant1", f);
2063 test("testFloatCompareGreaterEqualConstant2", f);
2064 }
2065
2066 @Test
2067 public void testFloatNullComparesGreaterEqual() {
2068 test("testFloatCompareGreaterEqual", null, floatTestValue1);
2069 }
2070
2071 @Test
2072 public void testFloatNullComparesGreaterEqual1() {
2073 test("testFloatCompareGreaterEqualConstant1", (Object) null);
2074 }
2075
2076 @Test
2077 public void testFloatNullComparesGreaterEqual2() {
2078 test("testFloatCompareGreaterEqualConstant2", (Object) null);
2079 }
2080
2081 public static Object testFloatSwappedCompareGreaterEqual(FieldObject f, float floatValue) {
2082 if (floatValue >= f.floatValue) {
2083 return f;
2084 }
2085 return null;
2086 }
2087
2088 public static Object testFloatSwappedCompareGreaterEqualConstant1(FieldObject f) {
2089 if (floatTestValue1 >= f.floatValue) {
2090 return f;
2091 }
2092 return null;
2093 }
2094
2095 public static Object testFloatSwappedCompareGreaterEqualConstant2(FieldObject f) {
2096 if (floatTestValue2 >= f.floatValue) {
2097 return f;
2098 }
2099 return null;
2100 }
2101
2102 @Test
2103 public void testFloatSwappedComparesGreaterEqual() {
2104 FieldObject f = new FieldObject();
2105 test("testFloatSwappedCompareGreaterEqual", f, floatTestValue1);
2106 test("testFloatSwappedCompareGreaterEqualConstant1", f);
2107 test("testFloatSwappedCompareGreaterEqualConstant2", f);
2108 }
2109
2110 @Test
2111 public void testFloatNullSwappedComparesGreaterEqual() {
2112 test("testFloatSwappedCompareGreaterEqual", null, floatTestValue1);
2113 }
2114
2115 @Test
2116 public void testFloatNullSwappedComparesGreaterEqual1() {
2117 test("testFloatSwappedCompareGreaterEqualConstant1", (Object) null);
2118 }
2119
2120 @Test
2121 public void testFloatNullSwappedComparesGreaterEqual2() {
2122 test("testFloatSwappedCompareGreaterEqualConstant2", (Object) null);
2123 }
2124
2125 public static Object testLongCompare(FieldObject f, long longValue) {
2126 if (f.longValue == longValue) {
2127 return f;
2128 }
2129 return null;
2130 }
2131
2132 public static Object testLongCompareConstant1(FieldObject f) {
2133 if (f.longValue == longTestValue1) {
2134 return f;
2135 }
2136 return null;
2137 }
2138
2139 public static Object testLongCompareConstant2(FieldObject f) {
2140 if (f.longValue == longTestValue2) {
2141 return f;
2142 }
2143 return null;
2144 }
2145
2146 @Test
2147 public void testLongCompares() {
2148 FieldObject f = new FieldObject();
2149 test("testLongCompare", f, longTestValue1);
2150 test("testLongCompareConstant1", f);
2151 test("testLongCompareConstant2", f);
2152 }
2153
2154 @Test
2155 public void testLongNullCompares() {
2156 test("testLongCompare", null, longTestValue1);
2157 }
2158
2159 @Test
2160 public void testLongNullCompares1() {
2161 test("testLongCompareConstant1", (Object) null);
2162 }
2163
2164 @Test
2165 public void testLongNullCompares2() {
2166 test("testLongCompareConstant2", (Object) null);
2167 }
2168
2169 public static Object testLongCompareLess(FieldObject f, long longValue) {
2170 if (f.longValue < longValue) {
2171 return f;
2172 }
2173 return null;
2174 }
2175
2176 public static Object testLongCompareLessConstant1(FieldObject f) {
2177 if (f.longValue < longTestValue1) {
2178 return f;
2179 }
2180 return null;
2181 }
2182
2183 public static Object testLongCompareLessConstant2(FieldObject f) {
2184 if (f.longValue < longTestValue2) {
2185 return f;
2186 }
2187 return null;
2188 }
2189
2190 @Test
2191 public void testLongComparesLess() {
2192 FieldObject f = new FieldObject();
2193 test("testLongCompareLess", f, longTestValue1);
2194 test("testLongCompareLessConstant1", f);
2195 test("testLongCompareLessConstant2", f);
2196 }
2197
2198 @Test
2199 public void testLongNullComparesLess() {
2200 test("testLongCompareLess", null, longTestValue1);
2201 }
2202
2203 @Test
2204 public void testLongNullComparesLess1() {
2205 test("testLongCompareLessConstant1", (Object) null);
2206 }
2207
2208 @Test
2209 public void testLongNullComparesLess2() {
2210 test("testLongCompareLessConstant2", (Object) null);
2211 }
2212
2213 public static Object testLongSwappedCompareLess(FieldObject f, long longValue) {
2214 if (longValue < f.longValue) {
2215 return f;
2216 }
2217 return null;
2218 }
2219
2220 public static Object testLongSwappedCompareLessConstant1(FieldObject f) {
2221 if (longTestValue1 < f.longValue) {
2222 return f;
2223 }
2224 return null;
2225 }
2226
2227 public static Object testLongSwappedCompareLessConstant2(FieldObject f) {
2228 if (longTestValue2 < f.longValue) {
2229 return f;
2230 }
2231 return null;
2232 }
2233
2234 @Test
2235 public void testLongSwappedComparesLess() {
2236 FieldObject f = new FieldObject();
2237 test("testLongSwappedCompareLess", f, longTestValue1);
2238 test("testLongSwappedCompareLessConstant1", f);
2239 test("testLongSwappedCompareLessConstant2", f);
2240 }
2241
2242 @Test
2243 public void testLongNullSwappedComparesLess() {
2244 test("testLongSwappedCompareLess", null, longTestValue1);
2245 }
2246
2247 @Test
2248 public void testLongNullSwappedComparesLess1() {
2249 test("testLongSwappedCompareLessConstant1", (Object) null);
2250 }
2251
2252 @Test
2253 public void testLongNullSwappedComparesLess2() {
2254 test("testLongSwappedCompareLessConstant2", (Object) null);
2255 }
2256
2257 public static Object testLongCompareLessEqual(FieldObject f, long longValue) {
2258 if (f.longValue <= longValue) {
2259 return f;
2260 }
2261 return null;
2262 }
2263
2264 public static Object testLongCompareLessEqualConstant1(FieldObject f) {
2265 if (f.longValue <= longTestValue1) {
2266 return f;
2267 }
2268 return null;
2269 }
2270
2271 public static Object testLongCompareLessEqualConstant2(FieldObject f) {
2272 if (f.longValue <= longTestValue2) {
2273 return f;
2274 }
2275 return null;
2276 }
2277
2278 @Test
2279 public void testLongComparesLessEqual() {
2280 FieldObject f = new FieldObject();
2281 test("testLongCompareLessEqual", f, longTestValue1);
2282 test("testLongCompareLessEqualConstant1", f);
2283 test("testLongCompareLessEqualConstant2", f);
2284 }
2285
2286 @Test
2287 public void testLongNullComparesLessEqual() {
2288 test("testLongCompareLessEqual", null, longTestValue1);
2289 }
2290
2291 @Test
2292 public void testLongNullComparesLessEqual1() {
2293 test("testLongCompareLessEqualConstant1", (Object) null);
2294 }
2295
2296 @Test
2297 public void testLongNullComparesLessEqual2() {
2298 test("testLongCompareLessEqualConstant2", (Object) null);
2299 }
2300
2301 public static Object testLongSwappedCompareLessEqual(FieldObject f, long longValue) {
2302 if (longValue <= f.longValue) {
2303 return f;
2304 }
2305 return null;
2306 }
2307
2308 public static Object testLongSwappedCompareLessEqualConstant1(FieldObject f) {
2309 if (longTestValue1 <= f.longValue) {
2310 return f;
2311 }
2312 return null;
2313 }
2314
2315 public static Object testLongSwappedCompareLessEqualConstant2(FieldObject f) {
2316 if (longTestValue2 <= f.longValue) {
2317 return f;
2318 }
2319 return null;
2320 }
2321
2322 @Test
2323 public void testLongSwappedComparesLessEqual() {
2324 FieldObject f = new FieldObject();
2325 test("testLongSwappedCompareLessEqual", f, longTestValue1);
2326 test("testLongSwappedCompareLessEqualConstant1", f);
2327 test("testLongSwappedCompareLessEqualConstant2", f);
2328 }
2329
2330 @Test
2331 public void testLongNullSwappedComparesLessEqual() {
2332 test("testLongSwappedCompareLessEqual", null, longTestValue1);
2333 }
2334
2335 @Test
2336 public void testLongNullSwappedComparesLessEqual1() {
2337 test("testLongSwappedCompareLessEqualConstant1", (Object) null);
2338 }
2339
2340 @Test
2341 public void testLongNullSwappedComparesLessEqual2() {
2342 test("testLongSwappedCompareLessEqualConstant2", (Object) null);
2343 }
2344
2345 public static Object testLongCompareGreater(FieldObject f, long longValue) {
2346 if (f.longValue > longValue) {
2347 return f;
2348 }
2349 return null;
2350 }
2351
2352 public static Object testLongCompareGreaterConstant1(FieldObject f) {
2353 if (f.longValue > longTestValue1) {
2354 return f;
2355 }
2356 return null;
2357 }
2358
2359 public static Object testLongCompareGreaterConstant2(FieldObject f) {
2360 if (f.longValue > longTestValue2) {
2361 return f;
2362 }
2363 return null;
2364 }
2365
2366 @Test
2367 public void testLongComparesGreater() {
2368 FieldObject f = new FieldObject();
2369 test("testLongCompareGreater", f, longTestValue1);
2370 test("testLongCompareGreaterConstant1", f);
2371 test("testLongCompareGreaterConstant2", f);
2372 }
2373
2374 @Test
2375 public void testLongNullComparesGreater() {
2376 test("testLongCompareGreater", null, longTestValue1);
2377 }
2378
2379 @Test
2380 public void testLongNullComparesGreater1() {
2381 test("testLongCompareGreaterConstant1", (Object) null);
2382 }
2383
2384 @Test
2385 public void testLongNullComparesGreater2() {
2386 test("testLongCompareGreaterConstant2", (Object) null);
2387 }
2388
2389 public static Object testLongSwappedCompareGreater(FieldObject f, long longValue) {
2390 if (longValue > f.longValue) {
2391 return f;
2392 }
2393 return null;
2394 }
2395
2396 public static Object testLongSwappedCompareGreaterConstant1(FieldObject f) {
2397 if (longTestValue1 > f.longValue) {
2398 return f;
2399 }
2400 return null;
2401 }
2402
2403 public static Object testLongSwappedCompareGreaterConstant2(FieldObject f) {
2404 if (longTestValue2 > f.longValue) {
2405 return f;
2406 }
2407 return null;
2408 }
2409
2410 @Test
2411 public void testLongSwappedComparesGreater() {
2412 FieldObject f = new FieldObject();
2413 test("testLongSwappedCompareGreater", f, longTestValue1);
2414 test("testLongSwappedCompareGreaterConstant1", f);
2415 test("testLongSwappedCompareGreaterConstant2", f);
2416 }
2417
2418 @Test
2419 public void testLongNullSwappedComparesGreater() {
2420 test("testLongSwappedCompareGreater", null, longTestValue1);
2421 }
2422
2423 @Test
2424 public void testLongNullSwappedComparesGreater1() {
2425 test("testLongSwappedCompareGreaterConstant1", (Object) null);
2426 }
2427
2428 @Test
2429 public void testLongNullSwappedComparesGreater2() {
2430 test("testLongSwappedCompareGreaterConstant2", (Object) null);
2431 }
2432
2433 public static Object testLongCompareGreaterEqual(FieldObject f, long longValue) {
2434 if (f.longValue >= longValue) {
2435 return f;
2436 }
2437 return null;
2438 }
2439
2440 public static Object testLongCompareGreaterEqualConstant1(FieldObject f) {
2441 if (f.longValue >= longTestValue1) {
2442 return f;
2443 }
2444 return null;
2445 }
2446
2447 public static Object testLongCompareGreaterEqualConstant2(FieldObject f) {
2448 if (f.longValue >= longTestValue2) {
2449 return f;
2450 }
2451 return null;
2452 }
2453
2454 @Test
2455 public void testLongComparesGreaterEqual() {
2456 FieldObject f = new FieldObject();
2457 test("testLongCompareGreaterEqual", f, longTestValue1);
2458 test("testLongCompareGreaterEqualConstant1", f);
2459 test("testLongCompareGreaterEqualConstant2", f);
2460 }
2461
2462 @Test
2463 public void testLongNullComparesGreaterEqual() {
2464 test("testLongCompareGreaterEqual", null, longTestValue1);
2465 }
2466
2467 @Test
2468 public void testLongNullComparesGreaterEqual1() {
2469 test("testLongCompareGreaterEqualConstant1", (Object) null);
2470 }
2471
2472 @Test
2473 public void testLongNullComparesGreaterEqual2() {
2474 test("testLongCompareGreaterEqualConstant2", (Object) null);
2475 }
2476
2477 public static Object testLongSwappedCompareGreaterEqual(FieldObject f, long longValue) {
2478 if (longValue >= f.longValue) {
2479 return f;
2480 }
2481 return null;
2482 }
2483
2484 public static Object testLongSwappedCompareGreaterEqualConstant1(FieldObject f) {
2485 if (longTestValue1 >= f.longValue) {
2486 return f;
2487 }
2488 return null;
2489 }
2490
2491 public static Object testLongSwappedCompareGreaterEqualConstant2(FieldObject f) {
2492 if (longTestValue2 >= f.longValue) {
2493 return f;
2494 }
2495 return null;
2496 }
2497
2498 @Test
2499 public void testLongSwappedComparesGreaterEqual() {
2500 FieldObject f = new FieldObject();
2501 test("testLongSwappedCompareGreaterEqual", f, longTestValue1);
2502 test("testLongSwappedCompareGreaterEqualConstant1", f);
2503 test("testLongSwappedCompareGreaterEqualConstant2", f);
2504 }
2505
2506 @Test
2507 public void testLongNullSwappedComparesGreaterEqual() {
2508 test("testLongSwappedCompareGreaterEqual", null, longTestValue1);
2509 }
2510
2511 @Test
2512 public void testLongNullSwappedComparesGreaterEqual1() {
2513 test("testLongSwappedCompareGreaterEqualConstant1", (Object) null);
2514 }
2515
2516 @Test
2517 public void testLongNullSwappedComparesGreaterEqual2() {
2518 test("testLongSwappedCompareGreaterEqualConstant2", (Object) null);
2519 }
2520
2521 public static Object testDoubleCompare(FieldObject f, double doubleValue) {
2522 if (f.doubleValue == doubleValue) {
2523 return f;
2524 }
2525 return null;
2526 }
2527
2528 public static Object testDoubleCompareConstant1(FieldObject f) {
2529 if (f.doubleValue == doubleTestValue1) {
2530 return f;
2531 }
2532 return null;
2533 }
2534
2535 public static Object testDoubleCompareConstant2(FieldObject f) {
2536 if (f.doubleValue == doubleTestValue2) {
2537 return f;
2538 }
2539 return null;
2540 }
2541
2542 @Test
2543 public void testDoubleCompares() {
2544 FieldObject f = new FieldObject();
2545 test("testDoubleCompare", f, doubleTestValue1);
2546 test("testDoubleCompareConstant1", f);
2547 test("testDoubleCompareConstant2", f);
2548 }
2549
2550 @Test
2551 public void testDoubleNullCompares() {
2552 test("testDoubleCompare", null, doubleTestValue1);
2553 }
2554
2555 @Test
2556 public void testDoubleNullCompares1() {
2557 test("testDoubleCompareConstant1", (Object) null);
2558 }
2559
2560 @Test
2561 public void testDoubleNullCompares2() {
2562 test("testDoubleCompareConstant2", (Object) null);
2563 }
2564
2565 public static Object testDoubleCompareLess(FieldObject f, double doubleValue) {
2566 if (f.doubleValue < doubleValue) {
2567 return f;
2568 }
2569 return null;
2570 }
2571
2572 public static Object testDoubleCompareLessConstant1(FieldObject f) {
2573 if (f.doubleValue < doubleTestValue1) {
2574 return f;
2575 }
2576 return null;
2577 }
2578
2579 public static Object testDoubleCompareLessConstant2(FieldObject f) {
2580 if (f.doubleValue < doubleTestValue2) {
2581 return f;
2582 }
2583 return null;
2584 }
2585
2586 @Test
2587 public void testDoubleComparesLess() {
2588 FieldObject f = new FieldObject();
2589 test("testDoubleCompareLess", f, doubleTestValue1);
2590 test("testDoubleCompareLessConstant1", f);
2591 test("testDoubleCompareLessConstant2", f);
2592 }
2593
2594 @Test
2595 public void testDoubleNullComparesLess() {
2596 test("testDoubleCompareLess", null, doubleTestValue1);
2597 }
2598
2599 @Test
2600 public void testDoubleNullComparesLess1() {
2601 test("testDoubleCompareLessConstant1", (Object) null);
2602 }
2603
2604 @Test
2605 public void testDoubleNullComparesLess2() {
2606 test("testDoubleCompareLessConstant2", (Object) null);
2607 }
2608
2609 public static Object testDoubleSwappedCompareLess(FieldObject f, double doubleValue) {
2610 if (doubleValue < f.doubleValue) {
2611 return f;
2612 }
2613 return null;
2614 }
2615
2616 public static Object testDoubleSwappedCompareLessConstant1(FieldObject f) {
2617 if (doubleTestValue1 < f.doubleValue) {
2618 return f;
2619 }
2620 return null;
2621 }
2622
2623 public static Object testDoubleSwappedCompareLessConstant2(FieldObject f) {
2624 if (doubleTestValue2 < f.doubleValue) {
2625 return f;
2626 }
2627 return null;
2628 }
2629
2630 @Test
2631 public void testDoubleSwappedComparesLess() {
2632 FieldObject f = new FieldObject();
2633 test("testDoubleSwappedCompareLess", f, doubleTestValue1);
2634 test("testDoubleSwappedCompareLessConstant1", f);
2635 test("testDoubleSwappedCompareLessConstant2", f);
2636 }
2637
2638 @Test
2639 public void testDoubleNullSwappedComparesLess() {
2640 test("testDoubleSwappedCompareLess", null, doubleTestValue1);
2641 }
2642
2643 @Test
2644 public void testDoubleNullSwappedComparesLess1() {
2645 test("testDoubleSwappedCompareLessConstant1", (Object) null);
2646 }
2647
2648 @Test
2649 public void testDoubleNullSwappedComparesLess2() {
2650 test("testDoubleSwappedCompareLessConstant2", (Object) null);
2651 }
2652
2653 public static Object testDoubleCompareLessEqual(FieldObject f, double doubleValue) {
2654 if (f.doubleValue <= doubleValue) {
2655 return f;
2656 }
2657 return null;
2658 }
2659
2660 public static Object testDoubleCompareLessEqualConstant1(FieldObject f) {
2661 if (f.doubleValue <= doubleTestValue1) {
2662 return f;
2663 }
2664 return null;
2665 }
2666
2667 public static Object testDoubleCompareLessEqualConstant2(FieldObject f) {
2668 if (f.doubleValue <= doubleTestValue2) {
2669 return f;
2670 }
2671 return null;
2672 }
2673
2674 @Test
2675 public void testDoubleComparesLessEqual() {
2676 FieldObject f = new FieldObject();
2677 test("testDoubleCompareLessEqual", f, doubleTestValue1);
2678 test("testDoubleCompareLessEqualConstant1", f);
2679 test("testDoubleCompareLessEqualConstant2", f);
2680 }
2681
2682 @Test
2683 public void testDoubleNullComparesLessEqual() {
2684 test("testDoubleCompareLessEqual", null, doubleTestValue1);
2685 }
2686
2687 @Test
2688 public void testDoubleNullComparesLessEqual1() {
2689 test("testDoubleCompareLessEqualConstant1", (Object) null);
2690 }
2691
2692 @Test
2693 public void testDoubleNullComparesLessEqual2() {
2694 test("testDoubleCompareLessEqualConstant2", (Object) null);
2695 }
2696
2697 public static Object testDoubleSwappedCompareLessEqual(FieldObject f, double doubleValue) {
2698 if (doubleValue <= f.doubleValue) {
2699 return f;
2700 }
2701 return null;
2702 }
2703
2704 public static Object testDoubleSwappedCompareLessEqualConstant1(FieldObject f) {
2705 if (doubleTestValue1 <= f.doubleValue) {
2706 return f;
2707 }
2708 return null;
2709 }
2710
2711 public static Object testDoubleSwappedCompareLessEqualConstant2(FieldObject f) {
2712 if (doubleTestValue2 <= f.doubleValue) {
2713 return f;
2714 }
2715 return null;
2716 }
2717
2718 @Test
2719 public void testDoubleSwappedComparesLessEqual() {
2720 FieldObject f = new FieldObject();
2721 test("testDoubleSwappedCompareLessEqual", f, doubleTestValue1);
2722 test("testDoubleSwappedCompareLessEqualConstant1", f);
2723 test("testDoubleSwappedCompareLessEqualConstant2", f);
2724 }
2725
2726 @Test
2727 public void testDoubleNullSwappedComparesLessEqual() {
2728 test("testDoubleSwappedCompareLessEqual", null, doubleTestValue1);
2729 }
2730
2731 @Test
2732 public void testDoubleNullSwappedComparesLessEqual1() {
2733 test("testDoubleSwappedCompareLessEqualConstant1", (Object) null);
2734 }
2735
2736 @Test
2737 public void testDoubleNullSwappedComparesLessEqual2() {
2738 test("testDoubleSwappedCompareLessEqualConstant2", (Object) null);
2739 }
2740
2741 public static Object testDoubleCompareGreater(FieldObject f, double doubleValue) {
2742 if (f.doubleValue > doubleValue) {
2743 return f;
2744 }
2745 return null;
2746 }
2747
2748 public static Object testDoubleCompareGreaterConstant1(FieldObject f) {
2749 if (f.doubleValue > doubleTestValue1) {
2750 return f;
2751 }
2752 return null;
2753 }
2754
2755 public static Object testDoubleCompareGreaterConstant2(FieldObject f) {
2756 if (f.doubleValue > doubleTestValue2) {
2757 return f;
2758 }
2759 return null;
2760 }
2761
2762 @Test
2763 public void testDoubleComparesGreater() {
2764 FieldObject f = new FieldObject();
2765 test("testDoubleCompareGreater", f, doubleTestValue1);
2766 test("testDoubleCompareGreaterConstant1", f);
2767 test("testDoubleCompareGreaterConstant2", f);
2768 }
2769
2770 @Test
2771 public void testDoubleNullComparesGreater() {
2772 test("testDoubleCompareGreater", null, doubleTestValue1);
2773 }
2774
2775 @Test
2776 public void testDoubleNullComparesGreater1() {
2777 test("testDoubleCompareGreaterConstant1", (Object) null);
2778 }
2779
2780 @Test
2781 public void testDoubleNullComparesGreater2() {
2782 test("testDoubleCompareGreaterConstant2", (Object) null);
2783 }
2784
2785 public static Object testDoubleSwappedCompareGreater(FieldObject f, double doubleValue) {
2786 if (doubleValue > f.doubleValue) {
2787 return f;
2788 }
2789 return null;
2790 }
2791
2792 public static Object testDoubleSwappedCompareGreaterConstant1(FieldObject f) {
2793 if (doubleTestValue1 > f.doubleValue) {
2794 return f;
2795 }
2796 return null;
2797 }
2798
2799 public static Object testDoubleSwappedCompareGreaterConstant2(FieldObject f) {
2800 if (doubleTestValue2 > f.doubleValue) {
2801 return f;
2802 }
2803 return null;
2804 }
2805
2806 @Test
2807 public void testDoubleSwappedComparesGreater() {
2808 FieldObject f = new FieldObject();
2809 test("testDoubleSwappedCompareGreater", f, doubleTestValue1);
2810 test("testDoubleSwappedCompareGreaterConstant1", f);
2811 test("testDoubleSwappedCompareGreaterConstant2", f);
2812 }
2813
2814 @Test
2815 public void testDoubleNullSwappedComparesGreater() {
2816 test("testDoubleSwappedCompareGreater", null, doubleTestValue1);
2817 }
2818
2819 @Test
2820 public void testDoubleNullSwappedComparesGreater1() {
2821 test("testDoubleSwappedCompareGreaterConstant1", (Object) null);
2822 }
2823
2824 @Test
2825 public void testDoubleNullSwappedComparesGreater2() {
2826 test("testDoubleSwappedCompareGreaterConstant2", (Object) null);
2827 }
2828
2829 public static Object testDoubleCompareGreaterEqual(FieldObject f, double doubleValue) {
2830 if (f.doubleValue >= doubleValue) {
2831 return f;
2832 }
2833 return null;
2834 }
2835
2836 public static Object testDoubleCompareGreaterEqualConstant1(FieldObject f) {
2837 if (f.doubleValue >= doubleTestValue1) {
2838 return f;
2839 }
2840 return null;
2841 }
2842
2843 public static Object testDoubleCompareGreaterEqualConstant2(FieldObject f) {
2844 if (f.doubleValue >= doubleTestValue2) {
2845 return f;
2846 }
2847 return null;
2848 }
2849
2850 @Test
2851 public void testDoubleComparesGreaterEqual() {
2852 FieldObject f = new FieldObject();
2853 test("testDoubleCompareGreaterEqual", f, doubleTestValue1);
2854 test("testDoubleCompareGreaterEqualConstant1", f);
2855 test("testDoubleCompareGreaterEqualConstant2", f);
2856 }
2857
2858 @Test
2859 public void testDoubleNullComparesGreaterEqual() {
2860 test("testDoubleCompareGreaterEqual", null, doubleTestValue1);
2861 }
2862
2863 @Test
2864 public void testDoubleNullComparesGreaterEqual1() {
2865 test("testDoubleCompareGreaterEqualConstant1", (Object) null);
2866 }
2867
2868 @Test
2869 public void testDoubleNullComparesGreaterEqual2() {
2870 test("testDoubleCompareGreaterEqualConstant2", (Object) null);
2871 }
2872
2873 public static Object testDoubleSwappedCompareGreaterEqual(FieldObject f, double doubleValue) {
2874 if (doubleValue >= f.doubleValue) {
2875 return f;
2876 }
2877 return null;
2878 }
2879
2880 public static Object testDoubleSwappedCompareGreaterEqualConstant1(FieldObject f) {
2881 if (doubleTestValue1 >= f.doubleValue) {
2882 return f;
2883 }
2884 return null;
2885 }
2886
2887 public static Object testDoubleSwappedCompareGreaterEqualConstant2(FieldObject f) {
2888 if (doubleTestValue2 >= f.doubleValue) {
2889 return f;
2890 }
2891 return null;
2892 }
2893
2894 @Test
2895 public void testDoubleSwappedComparesGreaterEqual() {
2896 FieldObject f = new FieldObject();
2897 test("testDoubleSwappedCompareGreaterEqual", f, doubleTestValue1);
2898 test("testDoubleSwappedCompareGreaterEqualConstant1", f);
2899 test("testDoubleSwappedCompareGreaterEqualConstant2", f);
2900 }
2901
2902 @Test
2903 public void testDoubleNullSwappedComparesGreaterEqual() {
2904 test("testDoubleSwappedCompareGreaterEqual", null, doubleTestValue1);
2905 }
2906
2907 @Test
2908 public void testDoubleNullSwappedComparesGreaterEqual1() {
2909 test("testDoubleSwappedCompareGreaterEqualConstant1", (Object) null);
2910 }
2911
2912 @Test
2913 public void testDoubleNullSwappedComparesGreaterEqual2() {
2914 test("testDoubleSwappedCompareGreaterEqualConstant2", (Object) null);
2915 }
2916
2917 public static Object testObjectCompare(FieldObject f, Object objectValue) {
2918 if (f.objectValue == objectValue) {
2919 return f;
2920 }
2921 return null;
2922 }
2923
2924 public static Object testObjectCompareConstant1(FieldObject f) {
2925 if (f.objectValue == objectTestValue1) {
2926 return f;
2927 }
2928 return null;
2929 }
2930
2931 public static Object testObjectCompareConstant2(FieldObject f) {
2932 if (f.objectValue == objectTestValue2) {
2933 return f;
2934 }
2935 return null;
2936 }
2937
2938 @Test
2939 public void testObjectCompares() {
2940 FieldObject f = new FieldObject();
2941 test("testObjectCompare", f, objectTestValue1);
2942 test("testObjectCompareConstant1", f);
2943 test("testObjectCompareConstant2", f);
2944 }
2945
2946 @Test
2947 public void testObjectNullCompares() {
2948 test("testObjectCompare", null, objectTestValue1);
2949 }
2950
2951 @Test
2952 public void testObjectNullCompares1() {
2953 test("testObjectCompareConstant1", (Object) null);
2954 }
2955
2956 @Test
2957 public void testObjectNullCompares2() {
2958 test("testObjectCompareConstant2", (Object) null);
2959 }
2960
2961 public static int testByteAdd(FieldObject f, byte byteValue) {
2962 return f.byteValue + byteValue;
2963 }
2964
2965 public static int testByteAddConstant1(FieldObject f) {
2966 return f.byteValue + byteTestValue1;
2967 }
2968
2969 public static int testByteAddConstant2(FieldObject f) {
2970 return f.byteValue + byteTestValue2;
2971 }
2972
2973 @Test
2974 public void testByteAdds() {
2975 FieldObject f = new FieldObject();
2976 test("testByteAdd", f, byteTestValue1);
2977 test("testByteAddConstant1", f);
2978 test("testByteAddConstant2", f);
2979 }
2980
2981 @Test
2982 public void testByteNullAdd() {
2983 test("testByteAdd", null, byteTestValue1);
2984 }
2985
2986 public static int testShortAdd(FieldObject f, short shortValue) {
2987 return f.shortValue + shortValue;
2988 }
2989
2990 public static int testShortAddConstant1(FieldObject f) {
2991 return f.shortValue + shortTestValue1;
2992 }
2993
2994 public static int testShortAddConstant2(FieldObject f) {
2995 return f.shortValue + shortTestValue2;
2996 }
2997
2998 @Test
2999 public void testShortAdds() {
3000 FieldObject f = new FieldObject();
3001 test("testShortAdd", f, shortTestValue1);
3002 test("testShortAddConstant1", f);
3003 test("testShortAddConstant2", f);
3004 }
3005
3006 @Test
3007 public void testShortNullAdd() {
3008 test("testShortAdd", null, shortTestValue1);
3009 }
3010
3011 public static int testCharAdd(FieldObject f, char charValue) {
3012 return f.charValue + charValue;
3013 }
3014
3015 public static int testCharAddConstant1(FieldObject f) {
3016 return f.charValue + charTestValue1;
3017 }
3018
3019 public static int testCharAddConstant2(FieldObject f) {
3020 return f.charValue + charTestValue2;
3021 }
3022
3023 @Test
3024 public void testCharAdds() {
3025 FieldObject f = new FieldObject();
3026 test("testCharAdd", f, charTestValue1);
3027 test("testCharAddConstant1", f);
3028 test("testCharAddConstant2", f);
3029 }
3030
3031 @Test
3032 public void testCharNullAdd() {
3033 test("testCharAdd", null, charTestValue1);
3034 }
3035
3036 public static int testIntAdd(FieldObject f, int intValue) {
3037 return f.intValue + intValue;
3038 }
3039
3040 public static int testIntAddConstant1(FieldObject f) {
3041 return f.intValue + intTestValue1;
3042 }
3043
3044 public static int testIntAddConstant2(FieldObject f) {
3045 return f.intValue + intTestValue2;
3046 }
3047
3048 @Test
3049 public void testIntAdds() {
3050 FieldObject f = new FieldObject();
3051 test("testIntAdd", f, intTestValue1);
3052 test("testIntAddConstant1", f);
3053 test("testIntAddConstant2", f);
3054 }
3055
3056 @Test
3057 public void testIntNullAdd() {
3058 test("testIntAdd", null, intTestValue1);
3059 }
3060
3061 public static long testLongAdd(FieldObject f, long longValue) {
3062 return f.longValue + longValue;
3063 }
3064
3065 public static long testLongAddConstant1(FieldObject f) {
3066 return f.longValue + longTestValue1;
3067 }
3068
3069 public static long testLongAddConstant2(FieldObject f) {
3070 return f.longValue + longTestValue2;
3071 }
3072
3073 @Test
3074 public void testLongAdds() {
3075 FieldObject f = new FieldObject();
3076 test("testLongAdd", f, longTestValue1);
3077 test("testLongAddConstant1", f);
3078 test("testLongAddConstant2", f);
3079 }
3080
3081 @Test
3082 public void testLongNullAdd() {
3083 test("testLongAdd", null, longTestValue1);
3084 }
3085
3086 public static float testFloatAdd(FieldObject f, float floatValue) {
3087 return f.floatValue + floatValue;
3088 }
3089
3090 public static float testFloatAddConstant1(FieldObject f) {
3091 return f.floatValue + floatTestValue1;
3092 }
3093
3094 public static float testFloatAddConstant2(FieldObject f) {
3095 return f.floatValue + floatTestValue2;
3096 }
3097
3098 @Test
3099 public void testFloatAdds() {
3100 FieldObject f = new FieldObject();
3101 test("testFloatAdd", f, floatTestValue1);
3102 test("testFloatAddConstant1", f);
3103 test("testFloatAddConstant2", f);
3104 }
3105
3106 @Test
3107 public void testFloatNullAdd() {
3108 test("testFloatAdd", null, floatTestValue1);
3109 }
3110
3111 public static double testDoubleAdd(FieldObject f, double doubleValue) {
3112 return f.doubleValue + doubleValue;
3113 }
3114
3115 public static double testDoubleAddConstant1(FieldObject f) {
3116 return f.doubleValue + doubleTestValue1;
3117 }
3118
3119 public static double testDoubleAddConstant2(FieldObject f) {
3120 return f.doubleValue + doubleTestValue2;
3121 }
3122
3123 @Test
3124 public void testDoubleAdds() {
3125 FieldObject f = new FieldObject();
3126 test("testDoubleAdd", f, doubleTestValue1);
3127 test("testDoubleAddConstant1", f);
3128 test("testDoubleAddConstant2", f);
3129 }
3130
3131 @Test
3132 public void testDoubleNullAdd() {
3133 test("testDoubleAdd", null, doubleTestValue1);
3134 }
3135
3136 public static int testByteSub(FieldObject f, byte byteValue) {
3137 return f.byteValue - byteValue;
3138 }
3139
3140 public static int testByteSubConstant1(FieldObject f) {
3141 return f.byteValue - byteTestValue1;
3142 }
3143
3144 public static int testByteSubConstant2(FieldObject f) {
3145 return f.byteValue - byteTestValue2;
3146 }
3147
3148 @Test
3149 public void testByteSubs() {
3150 FieldObject f = new FieldObject();
3151 test("testByteSub", f, byteTestValue1);
3152 test("testByteSubConstant1", f);
3153 test("testByteSubConstant2", f);
3154 }
3155
3156 @Test
3157 public void testByteNullSub() {
3158 test("testByteSub", null, byteTestValue1);
3159 }
3160
3161 public static int testShortSub(FieldObject f, short shortValue) {
3162 return f.shortValue - shortValue;
3163 }
3164
3165 public static int testShortSubConstant1(FieldObject f) {
3166 return f.shortValue - shortTestValue1;
3167 }
3168
3169 public static int testShortSubConstant2(FieldObject f) {
3170 return f.shortValue - shortTestValue2;
3171 }
3172
3173 @Test
3174 public void testShortSubs() {
3175 FieldObject f = new FieldObject();
3176 test("testShortSub", f, shortTestValue1);
3177 test("testShortSubConstant1", f);
3178 test("testShortSubConstant2", f);
3179 }
3180
3181 @Test
3182 public void testShortNullSub() {
3183 test("testShortSub", null, shortTestValue1);
3184 }
3185
3186 public static int testCharSub(FieldObject f, char charValue) {
3187 return f.charValue - charValue;
3188 }
3189
3190 public static int testCharSubConstant1(FieldObject f) {
3191 return f.charValue - charTestValue1;
3192 }
3193
3194 public static int testCharSubConstant2(FieldObject f) {
3195 return f.charValue - charTestValue2;
3196 }
3197
3198 @Test
3199 public void testCharSubs() {
3200 FieldObject f = new FieldObject();
3201 test("testCharSub", f, charTestValue1);
3202 test("testCharSubConstant1", f);
3203 test("testCharSubConstant2", f);
3204 }
3205
3206 @Test
3207 public void testCharNullSub() {
3208 test("testCharSub", null, charTestValue1);
3209 }
3210
3211 public static int testIntSub(FieldObject f, int intValue) {
3212 return f.intValue - intValue;
3213 }
3214
3215 public static int testIntSubConstant1(FieldObject f) {
3216 return f.intValue - intTestValue1;
3217 }
3218
3219 public static int testIntSubConstant2(FieldObject f) {
3220 return f.intValue - intTestValue2;
3221 }
3222
3223 @Test
3224 public void testIntSubs() {
3225 FieldObject f = new FieldObject();
3226 test("testIntSub", f, intTestValue1);
3227 test("testIntSubConstant1", f);
3228 test("testIntSubConstant2", f);
3229 }
3230
3231 @Test
3232 public void testIntNullSub() {
3233 test("testIntSub", null, intTestValue1);
3234 }
3235
3236 public static long testLongSub(FieldObject f, long longValue) {
3237 return f.longValue - longValue;
3238 }
3239
3240 public static long testLongSubConstant1(FieldObject f) {
3241 return f.longValue - longTestValue1;
3242 }
3243
3244 public static long testLongSubConstant2(FieldObject f) {
3245 return f.longValue - longTestValue2;
3246 }
3247
3248 @Test
3249 public void testLongSubs() {
3250 FieldObject f = new FieldObject();
3251 test("testLongSub", f, longTestValue1);
3252 test("testLongSubConstant1", f);
3253 test("testLongSubConstant2", f);
3254 }
3255
3256 @Test
3257 public void testLongNullSub() {
3258 test("testLongSub", null, longTestValue1);
3259 }
3260
3261 public static float testFloatSub(FieldObject f, float floatValue) {
3262 return f.floatValue - floatValue;
3263 }
3264
3265 public static float testFloatSubConstant1(FieldObject f) {
3266 return f.floatValue - floatTestValue1;
3267 }
3268
3269 public static float testFloatSubConstant2(FieldObject f) {
3270 return f.floatValue - floatTestValue2;
3271 }
3272
3273 @Test
3274 public void testFloatSubs() {
3275 FieldObject f = new FieldObject();
3276 test("testFloatSub", f, floatTestValue1);
3277 test("testFloatSubConstant1", f);
3278 test("testFloatSubConstant2", f);
3279 }
3280
3281 @Test
3282 public void testFloatNullSub() {
3283 test("testFloatSub", null, floatTestValue1);
3284 }
3285
3286 public static double testDoubleSub(FieldObject f, double doubleValue) {
3287 return f.doubleValue - doubleValue;
3288 }
3289
3290 public static double testDoubleSubConstant1(FieldObject f) {
3291 return f.doubleValue - doubleTestValue1;
3292 }
3293
3294 public static double testDoubleSubConstant2(FieldObject f) {
3295 return f.doubleValue - doubleTestValue2;
3296 }
3297
3298 @Test
3299 public void testDoubleSubs() {
3300 FieldObject f = new FieldObject();
3301 test("testDoubleSub", f, doubleTestValue1);
3302 test("testDoubleSubConstant1", f);
3303 test("testDoubleSubConstant2", f);
3304 }
3305
3306 @Test
3307 public void testDoubleNullSub() {
3308 test("testDoubleSub", null, doubleTestValue1);
3309 }
3310
3311 public static int testByteMul(FieldObject f, byte byteValue) {
3312 return f.byteValue * byteValue;
3313 }
3314
3315 public static int testByteMulConstant1(FieldObject f) {
3316 return f.byteValue * byteTestValue1;
3317 }
3318
3319 public static int testByteMulConstant2(FieldObject f) {
3320 return f.byteValue * byteTestValue2;
3321 }
3322
3323 @Test
3324 public void testByteMuls() {
3325 FieldObject f = new FieldObject();
3326 test("testByteMul", f, byteTestValue1);
3327 test("testByteMulConstant1", f);
3328 test("testByteMulConstant2", f);
3329 }
3330
3331 @Test
3332 public void testByteNullMul() {
3333 test("testByteMul", null, byteTestValue1);
3334 }
3335
3336 public static int testShortMul(FieldObject f, short shortValue) {
3337 return f.shortValue * shortValue;
3338 }
3339
3340 public static int testShortMulConstant1(FieldObject f) {
3341 return f.shortValue * shortTestValue1;
3342 }
3343
3344 public static int testShortMulConstant2(FieldObject f) {
3345 return f.shortValue * shortTestValue2;
3346 }
3347
3348 @Test
3349 public void testShortMuls() {
3350 FieldObject f = new FieldObject();
3351 test("testShortMul", f, shortTestValue1);
3352 test("testShortMulConstant1", f);
3353 test("testShortMulConstant2", f);
3354 }
3355
3356 @Test
3357 public void testShortNullMul() {
3358 test("testShortMul", null, shortTestValue1);
3359 }
3360
3361 public static int testCharMul(FieldObject f, char charValue) {
3362 return f.charValue * charValue;
3363 }
3364
3365 public static int testCharMulConstant1(FieldObject f) {
3366 return f.charValue * charTestValue1;
3367 }
3368
3369 public static int testCharMulConstant2(FieldObject f) {
3370 return f.charValue * charTestValue2;
3371 }
3372
3373 @Test
3374 public void testCharMuls() {
3375 FieldObject f = new FieldObject();
3376 test("testCharMul", f, charTestValue1);
3377 test("testCharMulConstant1", f);
3378 test("testCharMulConstant2", f);
3379 }
3380
3381 @Test
3382 public void testCharNullMul() {
3383 test("testCharMul", null, charTestValue1);
3384 }
3385
3386 public static int testIntMul(FieldObject f, int intValue) {
3387 return f.intValue * intValue;
3388 }
3389
3390 public static int testIntMulConstant1(FieldObject f) {
3391 return f.intValue * intTestValue1;
3392 }
3393
3394 public static int testIntMulConstant2(FieldObject f) {
3395 return f.intValue * intTestValue2;
3396 }
3397
3398 @Test
3399 public void testIntMuls() {
3400 FieldObject f = new FieldObject();
3401 test("testIntMul", f, intTestValue1);
3402 test("testIntMulConstant1", f);
3403 test("testIntMulConstant2", f);
3404 }
3405
3406 @Test
3407 public void testIntNullMul() {
3408 test("testIntMul", null, intTestValue1);
3409 }
3410
3411 public static long testLongMul(FieldObject f, long longValue) {
3412 return f.longValue * longValue;
3413 }
3414
3415 public static long testLongMulConstant1(FieldObject f) {
3416 return f.longValue * longTestValue1;
3417 }
3418
3419 public static long testLongMulConstant2(FieldObject f) {
3420 return f.longValue * longTestValue2;
3421 }
3422
3423 @Test
3424 public void testLongMuls() {
3425 FieldObject f = new FieldObject();
3426 test("testLongMul", f, longTestValue1);
3427 test("testLongMulConstant1", f);
3428 test("testLongMulConstant2", f);
3429 }
3430
3431 @Test
3432 public void testLongNullMul() {
3433 test("testLongMul", null, longTestValue1);
3434 }
3435
3436 public static float testFloatMul(FieldObject f, float floatValue) {
3437 return f.floatValue * floatValue;
3438 }
3439
3440 public static float testFloatMulConstant1(FieldObject f) {
3441 return f.floatValue * floatTestValue1;
3442 }
3443
3444 public static float testFloatMulConstant2(FieldObject f) {
3445 return f.floatValue * floatTestValue2;
3446 }
3447
3448 @Test
3449 public void testFloatMuls() {
3450 FieldObject f = new FieldObject();
3451 test("testFloatMul", f, floatTestValue1);
3452 test("testFloatMulConstant1", f);
3453 test("testFloatMulConstant2", f);
3454 }
3455
3456 @Test
3457 public void testFloatNullMul() {
3458 test("testFloatMul", null, floatTestValue1);
3459 }
3460
3461 public static double testDoubleMul(FieldObject f, double doubleValue) {
3462 return f.doubleValue * doubleValue;
3463 }
3464
3465 public static double testDoubleMulConstant1(FieldObject f) {
3466 return f.doubleValue * doubleTestValue1;
3467 }
3468
3469 public static double testDoubleMulConstant2(FieldObject f) {
3470 return f.doubleValue * doubleTestValue2;
3471 }
3472
3473 @Test
3474 public void testDoubleMuls() {
3475 FieldObject f = new FieldObject();
3476 test("testDoubleMul", f, doubleTestValue1);
3477 test("testDoubleMulConstant1", f);
3478 test("testDoubleMulConstant2", f);
3479 }
3480
3481 @Test
3482 public void testDoubleNullMul() {
3483 test("testDoubleMul", null, doubleTestValue1);
3484 }
3485
3486 public static int testByteDiv(FieldObject f, byte byteValue) {
3487 return f.byteValue / byteValue;
3488 }
3489
3490 @SuppressWarnings("divzero")
3491 public static int testByteDivConstant1(FieldObject f) {
3492 return f.byteValue / byteTestValue1;
3493 }
3494
3495 public static int testByteDivConstant2(FieldObject f) {
3496 return f.byteValue / byteTestValue2;
3497 }
3498
3499 @Test
3500 public void testByteDivs() {
3501 FieldObject f = new FieldObject();
3502 test("testByteDiv", f, byteTestValue1);
3503 test("testByteDivConstant1", f);
3504 test("testByteDivConstant2", f);
3505 }
3506
3507 @Test
3508 public void testByteNullDiv() {
3509 test("testByteDiv", null, byteTestValue1);
3510 }
3511
3512 public static int testShortDiv(FieldObject f, short shortValue) {
3513 return f.shortValue / shortValue;
3514 }
3515
3516 @SuppressWarnings("divzero")
3517 public static int testShortDivConstant1(FieldObject f) {
3518 return f.shortValue / shortTestValue1;
3519 }
3520
3521 public static int testShortDivConstant2(FieldObject f) {
3522 return f.shortValue / shortTestValue2;
3523 }
3524
3525 @Test
3526 public void testShortDivs() {
3527 FieldObject f = new FieldObject();
3528 test("testShortDiv", f, shortTestValue1);
3529 test("testShortDivConstant1", f);
3530 test("testShortDivConstant2", f);
3531 }
3532
3533 @Test
3534 public void testShortNullDiv() {
3535 test("testShortDiv", null, shortTestValue1);
3536 }
3537
3538 public static int testCharDiv(FieldObject f, char charValue) {
3539 return f.charValue / charValue;
3540 }
3541
3542 @SuppressWarnings("divzero")
3543 public static int testCharDivConstant1(FieldObject f) {
3544 return f.charValue / charTestValue1;
3545 }
3546
3547 public static int testCharDivConstant2(FieldObject f) {
3548 return f.charValue / charTestValue2;
3549 }
3550
3551 @Test
3552 public void testCharDivs() {
3553 FieldObject f = new FieldObject();
3554 test("testCharDiv", f, charTestValue1);
3555 test("testCharDivConstant1", f);
3556 test("testCharDivConstant2", f);
3557 }
3558
3559 @Test
3560 public void testCharNullDiv() {
3561 test("testCharDiv", null, charTestValue1);
3562 }
3563
3564 public static int testIntDiv(FieldObject f, int intValue) {
3565 return f.intValue / intValue;
3566 }
3567
3568 @SuppressWarnings("divzero")
3569 public static int testIntDivConstant1(FieldObject f) {
3570 return f.intValue / intTestValue1;
3571 }
3572
3573 public static int testIntDivConstant2(FieldObject f) {
3574 return f.intValue / intTestValue2;
3575 }
3576
3577 @Test
3578 public void testIntDivs() {
3579 FieldObject f = new FieldObject();
3580 test("testIntDiv", f, intTestValue1);
3581 test("testIntDivConstant1", f);
3582 test("testIntDivConstant2", f);
3583 }
3584
3585 @Test
3586 public void testIntNullDiv() {
3587 test("testIntDiv", null, intTestValue1);
3588 }
3589
3590 public static long testLongDiv(FieldObject f, long longValue) {
3591 return f.longValue / longValue;
3592 }
3593
3594 @SuppressWarnings("divzero")
3595 public static long testLongDivConstant1(FieldObject f) {
3596 return f.longValue / longTestValue1;
3597 }
3598
3599 public static long testLongDivConstant2(FieldObject f) {
3600 return f.longValue / longTestValue2;
3601 }
3602
3603 @Test
3604 public void testLongDivs() {
3605 FieldObject f = new FieldObject();
3606 test("testLongDiv", f, longTestValue1);
3607 test("testLongDivConstant1", f);
3608 test("testLongDivConstant2", f);
3609 }
3610
3611 @Test
3612 public void testLongNullDiv() {
3613 test("testLongDiv", null, longTestValue1);
3614 }
3615
3616 public static float testFloatDiv(FieldObject f, float floatValue) {
3617 return f.floatValue / floatValue;
3618 }
3619
3620 public static float testFloatDivConstant1(FieldObject f) {
3621 return f.floatValue / floatTestValue1;
3622 }
3623
3624 public static float testFloatDivConstant2(FieldObject f) {
3625 return f.floatValue / floatTestValue2;
3626 }
3627
3628 @Test
3629 public void testFloatDivs() {
3630 FieldObject f = new FieldObject();
3631 test("testFloatDiv", f, floatTestValue1);
3632 test("testFloatDivConstant1", f);
3633 test("testFloatDivConstant2", f);
3634 }
3635
3636 @Test
3637 public void testFloatNullDiv() {
3638 test("testFloatDiv", null, floatTestValue1);
3639 }
3640
3641 public static double testDoubleDiv(FieldObject f, double doubleValue) {
3642 return f.doubleValue / doubleValue;
3643 }
3644
3645 public static double testDoubleDivConstant1(FieldObject f) {
3646 return f.doubleValue / doubleTestValue1;
3647 }
3648
3649 public static double testDoubleDivConstant2(FieldObject f) {
3650 return f.doubleValue / doubleTestValue2;
3651 }
3652
3653 @Test
3654 public void testDoubleDivs() {
3655 FieldObject f = new FieldObject();
3656 test("testDoubleDiv", f, doubleTestValue1);
3657 test("testDoubleDivConstant1", f);
3658 test("testDoubleDivConstant2", f);
3659 }
3660
3661 @Test
3662 public void testDoubleNullDiv() {
3663 test("testDoubleDiv", null, doubleTestValue1);
3664 }
3665
3666 public static int testByteOr(FieldObject f, byte byteValue) {
3667 return f.byteValue | byteValue;
3668 }
3669
3670 public static int testByteOrConstant1(FieldObject f) {
3671 return f.byteValue | byteTestValue1;
3672 }
3673
3674 public static int testByteOrConstant2(FieldObject f) {
3675 return f.byteValue | byteTestValue2;
3676 }
3677
3678 @Test
3679 public void testByteOrs() {
3680 FieldObject f = new FieldObject();
3681 test("testByteOr", f, byteTestValue1);
3682 test("testByteOrConstant1", f);
3683 test("testByteOrConstant2", f);
3684 }
3685
3686 @Test
3687 public void testByteNullOr() {
3688 test("testByteOr", null, byteTestValue1);
3689 }
3690
3691 public static int testShortOr(FieldObject f, short shortValue) {
3692 return f.shortValue | shortValue;
3693 }
3694
3695 public static int testShortOrConstant1(FieldObject f) {
3696 return f.shortValue | shortTestValue1;
3697 }
3698
3699 public static int testShortOrConstant2(FieldObject f) {
3700 return f.shortValue | shortTestValue2;
3701 }
3702
3703 @Test
3704 public void testShortOrs() {
3705 FieldObject f = new FieldObject();
3706 test("testShortOr", f, shortTestValue1);
3707 test("testShortOrConstant1", f);
3708 test("testShortOrConstant2", f);
3709 }
3710
3711 @Test
3712 public void testShortNullOr() {
3713 test("testShortOr", null, shortTestValue1);
3714 }
3715
3716 public static int testCharOr(FieldObject f, char charValue) {
3717 return f.charValue | charValue;
3718 }
3719
3720 public static int testCharOrConstant1(FieldObject f) {
3721 return f.charValue | charTestValue1;
3722 }
3723
3724 public static int testCharOrConstant2(FieldObject f) {
3725 return f.charValue | charTestValue2;
3726 }
3727
3728 @Test
3729 public void testCharOrs() {
3730 FieldObject f = new FieldObject();
3731 test("testCharOr", f, charTestValue1);
3732 test("testCharOrConstant1", f);
3733 test("testCharOrConstant2", f);
3734 }
3735
3736 @Test
3737 public void testCharNullOr() {
3738 test("testCharOr", null, charTestValue1);
3739 }
3740
3741 public static int testIntOr(FieldObject f, int intValue) {
3742 return f.intValue | intValue;
3743 }
3744
3745 public static int testIntOrConstant1(FieldObject f) {
3746 return f.intValue | intTestValue1;
3747 }
3748
3749 public static int testIntOrConstant2(FieldObject f) {
3750 return f.intValue | intTestValue2;
3751 }
3752
3753 @Test
3754 public void testIntOrs() {
3755 FieldObject f = new FieldObject();
3756 test("testIntOr", f, intTestValue1);
3757 test("testIntOrConstant1", f);
3758 test("testIntOrConstant2", f);
3759 }
3760
3761 @Test
3762 public void testIntNullOr() {
3763 test("testIntOr", null, intTestValue1);
3764 }
3765
3766 public static long testLongOr(FieldObject f, long longValue) {
3767 return f.longValue | longValue;
3768 }
3769
3770 public static long testLongOrConstant1(FieldObject f) {
3771 return f.longValue | longTestValue1;
3772 }
3773
3774 public static long testLongOrConstant2(FieldObject f) {
3775 return f.longValue | longTestValue2;
3776 }
3777
3778 @Test
3779 public void testLongOrs() {
3780 FieldObject f = new FieldObject();
3781 test("testLongOr", f, longTestValue1);
3782 test("testLongOrConstant1", f);
3783 test("testLongOrConstant2", f);
3784 }
3785
3786 @Test
3787 public void testLongNullOr() {
3788 test("testLongOr", null, longTestValue1);
3789 }
3790
3791 public static int testByteXor(FieldObject f, byte byteValue) {
3792 return f.byteValue ^ byteValue;
3793 }
3794
3795 public static int testByteXorConstant1(FieldObject f) {
3796 return f.byteValue ^ byteTestValue1;
3797 }
3798
3799 public static int testByteXorConstant2(FieldObject f) {
3800 return f.byteValue ^ byteTestValue2;
3801 }
3802
3803 @Test
3804 public void testByteXors() {
3805 FieldObject f = new FieldObject();
3806 test("testByteXor", f, byteTestValue1);
3807 test("testByteXorConstant1", f);
3808 test("testByteXorConstant2", f);
3809 }
3810
3811 @Test
3812 public void testByteNullXor() {
3813 test("testByteXor", null, byteTestValue1);
3814 }
3815
3816 public static int testShortXor(FieldObject f, short shortValue) {
3817 return f.shortValue ^ shortValue;
3818 }
3819
3820 public static int testShortXorConstant1(FieldObject f) {
3821 return f.shortValue ^ shortTestValue1;
3822 }
3823
3824 public static int testShortXorConstant2(FieldObject f) {
3825 return f.shortValue ^ shortTestValue2;
3826 }
3827
3828 @Test
3829 public void testShortXors() {
3830 FieldObject f = new FieldObject();
3831 test("testShortXor", f, shortTestValue1);
3832 test("testShortXorConstant1", f);
3833 test("testShortXorConstant2", f);
3834 }
3835
3836 @Test
3837 public void testShortNullXor() {
3838 test("testShortXor", null, shortTestValue1);
3839 }
3840
3841 public static int testCharXor(FieldObject f, char charValue) {
3842 return f.charValue ^ charValue;
3843 }
3844
3845 public static int testCharXorConstant1(FieldObject f) {
3846 return f.charValue ^ charTestValue1;
3847 }
3848
3849 public static int testCharXorConstant2(FieldObject f) {
3850 return f.charValue ^ charTestValue2;
3851 }
3852
3853 @Test
3854 public void testCharXors() {
3855 FieldObject f = new FieldObject();
3856 test("testCharXor", f, charTestValue1);
3857 test("testCharXorConstant1", f);
3858 test("testCharXorConstant2", f);
3859 }
3860
3861 @Test
3862 public void testCharNullXor() {
3863 test("testCharXor", null, charTestValue1);
3864 }
3865
3866 public static int testIntXor(FieldObject f, int intValue) {
3867 return f.intValue ^ intValue;
3868 }
3869
3870 public static int testIntXorConstant1(FieldObject f) {
3871 return f.intValue ^ intTestValue1;
3872 }
3873
3874 public static int testIntXorConstant2(FieldObject f) {
3875 return f.intValue ^ intTestValue2;
3876 }
3877
3878 @Test
3879 public void testIntXors() {
3880 FieldObject f = new FieldObject();
3881 test("testIntXor", f, intTestValue1);
3882 test("testIntXorConstant1", f);
3883 test("testIntXorConstant2", f);
3884 }
3885
3886 @Test
3887 public void testIntNullXor() {
3888 test("testIntXor", null, intTestValue1);
3889 }
3890
3891 public static long testLongXor(FieldObject f, long longValue) {
3892 return f.longValue ^ longValue;
3893 }
3894
3895 public static long testLongXorConstant1(FieldObject f) {
3896 return f.longValue ^ longTestValue1;
3897 }
3898
3899 public static long testLongXorConstant2(FieldObject f) {
3900 return f.longValue ^ longTestValue2;
3901 }
3902
3903 @Test
3904 public void testLongXors() {
3905 FieldObject f = new FieldObject();
3906 test("testLongXor", f, longTestValue1);
3907 test("testLongXorConstant1", f);
3908 test("testLongXorConstant2", f);
3909 }
3910
3911 @Test
3912 public void testLongNullXor() {
3913 test("testLongXor", null, longTestValue1);
3914 }
3915
3916 public static int testByteAnd(FieldObject f, byte byteValue) {
3917 return f.byteValue & byteValue;
3918 }
3919
3920 public static int testByteAndConstant1(FieldObject f) {
3921 return f.byteValue & byteTestValue1;
3922 }
3923
3924 public static int testByteAndConstant2(FieldObject f) {
3925 return f.byteValue & byteTestValue2;
3926 }
3927
3928 @Test
3929 public void testByteAnds() {
3930 FieldObject f = new FieldObject();
3931 test("testByteAnd", f, byteTestValue1);
3932 test("testByteAndConstant1", f);
3933 test("testByteAndConstant2", f);
3934 }
3935
3936 @Test
3937 public void testByteNullAnd() {
3938 test("testByteAnd", null, byteTestValue1);
3939 }
3940
3941 public static int testShortAnd(FieldObject f, short shortValue) {
3942 return f.shortValue & shortValue;
3943 }
3944
3945 public static int testShortAndConstant1(FieldObject f) {
3946 return f.shortValue & shortTestValue1;
3947 }
3948
3949 public static int testShortAndConstant2(FieldObject f) {
3950 return f.shortValue & shortTestValue2;
3951 }
3952
3953 @Test
3954 public void testShortAnds() {
3955 FieldObject f = new FieldObject();
3956 test("testShortAnd", f, shortTestValue1);
3957 test("testShortAndConstant1", f);
3958 test("testShortAndConstant2", f);
3959 }
3960
3961 @Test
3962 public void testShortNullAnd() {
3963 test("testShortAnd", null, shortTestValue1);
3964 }
3965
3966 public static int testCharAnd(FieldObject f, char charValue) {
3967 return f.charValue & charValue;
3968 }
3969
3970 public static int testCharAndConstant1(FieldObject f) {
3971 return f.charValue & charTestValue1;
3972 }
3973
3974 public static int testCharAndConstant2(FieldObject f) {
3975 return f.charValue & charTestValue2;
3976 }
3977
3978 @Test
3979 public void testCharAnds() {
3980 FieldObject f = new FieldObject();
3981 test("testCharAnd", f, charTestValue1);
3982 test("testCharAndConstant1", f);
3983 test("testCharAndConstant2", f);
3984 }
3985
3986 @Test
3987 public void testCharNullAnd() {
3988 test("testCharAnd", null, charTestValue1);
3989 }
3990
3991 public static int testIntAnd(FieldObject f, int intValue) {
3992 return f.intValue & intValue;
3993 }
3994
3995 public static int testIntAndConstant1(FieldObject f) {
3996 return f.intValue & intTestValue1;
3997 }
3998
3999 public static int testIntAndConstant2(FieldObject f) {
4000 return f.intValue & intTestValue2;
4001 }
4002
4003 @Test
4004 public void testIntAnds() {
4005 FieldObject f = new FieldObject();
4006 test("testIntAnd", f, intTestValue1);
4007 test("testIntAndConstant1", f);
4008 test("testIntAndConstant2", f);
4009 }
4010
4011 @Test
4012 public void testIntNullAnd() {
4013 test("testIntAnd", null, intTestValue1);
4014 }
4015
4016 public static long testLongAnd(FieldObject f, long longValue) {
4017 return f.longValue & longValue;
4018 }
4019
4020 public static long testLongAndConstant1(FieldObject f) {
4021 return f.longValue & longTestValue1;
4022 }
4023
4024 public static long testLongAndConstant2(FieldObject f) {
4025 return f.longValue & longTestValue2;
4026 }
4027
4028 @Test
4029 public void testLongAnds() {
4030 FieldObject f = new FieldObject();
4031 test("testLongAnd", f, longTestValue1);
4032 test("testLongAndConstant1", f);
4033 test("testLongAndConstant2", f);
4034 }
4035
4036 @Test
4037 public void testLongNullAnd() {
4038 test("testLongAnd", null, longTestValue1);
4039 }
4040
4041 public static boolean testIntMask(FieldObject f, int intValue) {
4042 if ((f.intValue & intValue) != 0) {
4043 count++;
4044 return false;
4045 }
4046 return true;
4047 }
4048
4049 public static boolean testIntMaskConstant1(FieldObject f) {
4050 return (f.intValue & intTestValue1) != 0;
4051 }
4052
4053 public static boolean testIntMaskConstant2(FieldObject f) {
4054 return (f.intValue & intTestValue2) != 0;
4055 }
4056
4057 @Test
4058 public void testIntMasks() {
4059 FieldObject f = new FieldObject();
4060 test("testIntMask", f, intTestValue1);
4061 test("testIntMaskConstant1", f);
4062 test("testIntMaskConstant2", f);
4063 }
4064
4065 @Test
4066 public void testIntNullMask() {
4067 test("testIntMask", null, intTestValue1);
4068 }
4069
4070 public static boolean testLongMask(FieldObject f, long longValue) {
4071 if ((f.longValue & longValue) != 0) {
4072 count++;
4073 return false;
4074 }
4075 return true;
4076 }
4077
4078 public static boolean testLongMaskConstant1(FieldObject f) {
4079 return (f.longValue & longTestValue1) != 0;
4080 }
4081
4082 public static boolean testLongMaskConstant2(FieldObject f) {
4083 return (f.longValue & longTestValue2) != 0;
4084 }
4085
4086 @Test
4087 public void testLongMasks() {
4088 FieldObject f = new FieldObject();
4089 test("testLongMask", f, longTestValue1);
4090 test("testLongMaskConstant1", f);
4091 test("testLongMaskConstant2", f);
4092 }
4093
4094 @Test
4095 public void testLongNullMask() {
4096 test("testLongMask", null, longTestValue1);
4097 }
4098
4099 public static int doConvertByteInt(FieldObject f) {
4100 return f.byteValue;
4101 }
4102
4103 @Test
4104 public void testConvertByteInt() {
4105 test("doConvertByteInt", maxObject);
4106 test("doConvertByteInt", (FieldObject) null);
4107 }
4108
4109 public static int doConvertShortInt(FieldObject f) {
4110 return f.shortValue;
4111 }
4112
4113 @Test
4114 public void testConvertShortInt() {
4115 test("doConvertShortInt", maxObject);
4116 test("doConvertShortInt", (FieldObject) null);
4117 }
4118
4119 public static int doConvertCharInt(FieldObject f) {
4120 return f.charValue;
4121 }
4122
4123 @Test
4124 public void testConvertCharInt() {
4125 test("doConvertCharInt", maxObject);
4126 test("doConvertCharInt", (FieldObject) null);
4127 }
4128
4129 public static int doConvertLongInt(FieldObject f) {
4130 return (int) f.longValue;
4131 }
4132
4133 @Test
4134 public void testConvertLongInt() {
4135 test("doConvertLongInt", maxObject);
4136 test("doConvertLongInt", (FieldObject) null);
4137 }
4138
4139 public static int doConvertFloatInt(FieldObject f) {
4140 return (int) f.floatValue;
4141 }
4142
4143 @Test
4144 public void testConvertFloatInt() {
4145 test("doConvertFloatInt", maxObject);
4146 test("doConvertFloatInt", (FieldObject) null);
4147 }
4148
4149 public static int doConvertDoubleInt(FieldObject f) {
4150 return (int) f.doubleValue;
4151 }
4152
4153 @Test
4154 public void testConvertDoubleInt() {
4155 test("doConvertDoubleInt", maxObject);
4156 test("doConvertDoubleInt", (FieldObject) null);
4157 }
4158
4159 public static long doConvertByteLong(FieldObject f) {
4160 return f.byteValue;
4161 }
4162
4163 @Test
4164 public void testConvertByteLong() {
4165 test("doConvertByteLong", maxObject);
4166 test("doConvertByteLong", (FieldObject) null);
4167 }
4168
4169 public static long doConvertShortLong(FieldObject f) {
4170 return f.shortValue;
4171 }
4172
4173 @Test
4174 public void testConvertShortLong() {
4175 test("doConvertShortLong", maxObject);
4176 test("doConvertShortLong", (FieldObject) null);
4177 }
4178
4179 public static long doConvertCharLong(FieldObject f) {
4180 return f.charValue;
4181 }
4182
4183 @Test
4184 public void testConvertCharLong() {
4185 test("doConvertCharLong", maxObject);
4186 test("doConvertCharLong", (FieldObject) null);
4187 }
4188
4189 public static long doConvertIntLong(FieldObject f) {
4190 return f.intValue;
4191 }
4192
4193 @Test
4194 public void testConvertIntLong() {
4195 test("doConvertIntLong", maxObject);
4196 test("doConvertIntLong", (FieldObject) null);
4197 }
4198
4199 public static long doConvertFloatLong(FieldObject f) {
4200 return (long) f.floatValue;
4201 }
4202
4203 @Test
4204 public void testConvertFloatLong() {
4205 test("doConvertFloatLong", maxObject);
4206 test("doConvertFloatLong", (FieldObject) null);
4207 }
4208
4209 public static long doConvertDoubleLong(FieldObject f) {
4210 return (long) f.doubleValue;
4211 }
4212
4213 @Test
4214 public void testConvertDoubleLong() {
4215 test("doConvertDoubleLong", maxObject);
4216 test("doConvertDoubleLong", (FieldObject) null);
4217 }
4218
4219 public static float doConvertByteFloat(FieldObject f) {
4220 return f.byteValue;
4221 }
4222
4223 @Test
4224 public void testConvertByteFloat() {
4225 test("doConvertByteFloat", maxObject);
4226 test("doConvertByteFloat", (FieldObject) null);
4227 }
4228
4229 public static float doConvertShortFloat(FieldObject f) {
4230 return f.shortValue;
4231 }
4232
4233 @Test
4234 public void testConvertShortFloat() {
4235 test("doConvertShortFloat", maxObject);
4236 test("doConvertShortFloat", (FieldObject) null);
4237 }
4238
4239 public static float doConvertCharFloat(FieldObject f) {
4240 return f.charValue;
4241 }
4242
4243 @Test
4244 public void testConvertCharFloat() {
4245 test("doConvertCharFloat", maxObject);
4246 test("doConvertCharFloat", (FieldObject) null);
4247 }
4248
4249 public static float doConvertIntFloat(FieldObject f) {
4250 return f.intValue;
4251 }
4252
4253 @Test
4254 public void testConvertIntFloat() {
4255 test("doConvertIntFloat", maxObject);
4256 test("doConvertIntFloat", (FieldObject) null);
4257 }
4258
4259 public static float doConvertLongFloat(FieldObject f) {
4260 return f.longValue;
4261 }
4262
4263 @Test
4264 public void testConvertLongFloat() {
4265 test("doConvertLongFloat", maxObject);
4266 test("doConvertLongFloat", (FieldObject) null);
4267 }
4268
4269 public static float doConvertDoubleFloat(FieldObject f) {
4270 return (float) f.doubleValue;
4271 }
4272
4273 @Test
4274 public void testConvertDoubleFloat() {
4275 test("doConvertDoubleFloat", maxObject);
4276 test("doConvertDoubleFloat", (FieldObject) null);
4277 }
4278
4279 public static double doConvertByteDouble(FieldObject f) {
4280 return f.byteValue;
4281 }
4282
4283 @Test
4284 public void testConvertByteDouble() {
4285 test("doConvertByteDouble", maxObject);
4286 test("doConvertByteDouble", (FieldObject) null);
4287 }
4288
4289 public static double doConvertShortDouble(FieldObject f) {
4290 return f.shortValue;
4291 }
4292
4293 @Test
4294 public void testConvertShortDouble() {
4295 test("doConvertShortDouble", maxObject);
4296 test("doConvertShortDouble", (FieldObject) null);
4297 }
4298
4299 public static double doConvertCharDouble(FieldObject f) {
4300 return f.charValue;
4301 }
4302
4303 @Test
4304 public void testConvertCharDouble() {
4305 test("doConvertCharDouble", maxObject);
4306 test("doConvertCharDouble", (FieldObject) null);
4307 }
4308
4309 public static double doConvertIntDouble(FieldObject f) {
4310 return f.intValue;
4311 }
4312
4313 @Test
4314 public void testConvertIntDouble() {
4315 test("doConvertIntDouble", maxObject);
4316 test("doConvertIntDouble", (FieldObject) null);
4317 }
4318
4319 public static double doConvertLongDouble(FieldObject f) {
4320 return f.longValue;
4321 }
4322
4323 @Test
4324 public void testConvertLongDouble() {
4325 test("doConvertLongDouble", maxObject);
4326 test("doConvertLongDouble", (FieldObject) null);
4327 }
4328
4329 public static double doConvertFloatDouble(FieldObject f) {
4330 return f.floatValue;
4331 }
4332
4333 @Test
4334 public void testConvertFloatDouble() {
4335 test("doConvertFloatDouble", maxObject);
4336 test("doConvertFloatDouble", (FieldObject) null);
4337 }
4338 }