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