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