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