/*
 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.oracle.graal.compiler.test;

import jdk.internal.jvmci.code.*;
import jdk.internal.jvmci.meta.*;

import org.junit.*;

import com.oracle.graal.nodes.*;

public class MemoryArithmeticTest extends GraalCompilerTest {

    @Override
    protected InstalledCode getCode(ResolvedJavaMethod method, StructuredGraph graph) {
        return getCode(method, graph, true);
    }

    /**
     * Called before a test is executed.
     */
    @Override
    protected void before(ResolvedJavaMethod method) {
        // don't let any null exception tracking change the generated code.
        method.reprofile();
    }

    /**
     * A dummy field used by some tests to create side effects.
     */
    protected static int count;

    static class FieldObject {
        boolean booleanValue;
        byte byteValue;
        short shortValue;
        char charValue;
        int intValue;
        float floatValue;
        long longValue;
        double doubleValue;
        Object objectValue;
    }

    static FieldObject maxObject = new FieldObject();
    static FieldObject minObject;

    static final boolean booleanTestValue1 = false;
    static final byte byteTestValue1 = 0;
    static final short shortTestValue1 = 0;
    static final char charTestValue1 = 0;
    static final int intTestValue1 = 0;
    static final float floatTestValue1 = 0;
    static final long longTestValue1 = 0;
    static final double doubleTestValue1 = 0;
    static final Object objectTestValue1 = null;

    static final boolean booleanTestValue2 = true;
    static final byte byteTestValue2 = Byte.MAX_VALUE;
    static final short shortTestValue2 = Short.MAX_VALUE;
    static final char charTestValue2 = Character.MAX_VALUE;
    static final int intTestValue2 = Integer.MAX_VALUE;
    static final float floatTestValue2 = Float.MAX_VALUE;
    static final long longTestValue2 = Long.MAX_VALUE;
    static final double doubleTestValue2 = Double.MAX_VALUE;
    static final Object objectTestValue2 = "String";

    static {
        maxObject.booleanValue = true;
        maxObject.byteValue = Byte.MAX_VALUE;
        maxObject.shortValue = Short.MAX_VALUE;
        maxObject.charValue = Character.MAX_VALUE;
        maxObject.intValue = Integer.MAX_VALUE;
        maxObject.floatValue = Float.MAX_VALUE;
        maxObject.longValue = Long.MAX_VALUE;
        maxObject.doubleValue = Double.MAX_VALUE;
        maxObject.objectValue = "String";
    }

    public static Object testBooleanCompare(FieldObject f, boolean booleanValue) {
        if (f.booleanValue == booleanValue) {
            return f;
        }
        return null;
    }

    public static Object testBooleanCompareConstant1(FieldObject f) {
        if (f.booleanValue == booleanTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testBooleanCompareConstant2(FieldObject f) {
        if (f.booleanValue == booleanTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testBooleanCompares() {
        FieldObject f = new FieldObject();
        test("testBooleanCompare", f, booleanTestValue1);
        test("testBooleanCompareConstant1", f);
        test("testBooleanCompareConstant2", f);
    }

    @Test
    public void testBooleanNullCompares() {
        test("testBooleanCompare", null, booleanTestValue1);
    }

    @Test
    public void testBooleanNullCompares1() {
        test("testBooleanCompareConstant1", (Object) null);
    }

    @Test
    public void testBooleanNullCompares2() {
        test("testBooleanCompareConstant2", (Object) null);
    }

    public static Object testByteCompare(FieldObject f, byte byteValue) {
        if (f.byteValue == byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareConstant1(FieldObject f) {
        if (f.byteValue == byteTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareConstant2(FieldObject f) {
        if (f.byteValue == byteTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteCompares() {
        FieldObject f = new FieldObject();
        test("testByteCompare", f, byteTestValue1);
        test("testByteCompareConstant1", f);
        test("testByteCompareConstant2", f);
    }

    @Test
    public void testByteNullCompares() {
        test("testByteCompare", null, byteTestValue1);
    }

    @Test
    public void testByteNullCompares1() {
        test("testByteCompareConstant1", (Object) null);
    }

    @Test
    public void testByteNullCompares2() {
        test("testByteCompareConstant2", (Object) null);
    }

    public static Object testByteCompareLess(FieldObject f, byte byteValue) {
        if (f.byteValue < byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareLessConstant1(FieldObject f) {
        if (f.byteValue < byteTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareLessConstant2(FieldObject f) {
        if (f.byteValue < byteTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteComparesLess() {
        FieldObject f = new FieldObject();
        test("testByteCompareLess", f, byteTestValue1);
        test("testByteCompareLessConstant1", f);
        test("testByteCompareLessConstant2", f);
    }

    @Test
    public void testByteNullComparesLess() {
        test("testByteCompareLess", null, byteTestValue1);
    }

    @Test
    public void testByteNullComparesLess1() {
        test("testByteCompareLessConstant1", (Object) null);
    }

    @Test
    public void testByteNullComparesLess2() {
        test("testByteCompareLessConstant2", (Object) null);
    }

    public static Object testByteSwappedCompareLess(FieldObject f, byte byteValue) {
        if (byteValue < f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareLessConstant1(FieldObject f) {
        if (byteTestValue1 < f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareLessConstant2(FieldObject f) {
        if (byteTestValue2 < f.byteValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testByteSwappedCompareLess", f, byteTestValue1);
        test("testByteSwappedCompareLessConstant1", f);
        test("testByteSwappedCompareLessConstant2", f);
    }

    @Test
    public void testByteNullSwappedComparesLess() {
        test("testByteSwappedCompareLess", null, byteTestValue1);
    }

    @Test
    public void testByteNullSwappedComparesLess1() {
        test("testByteSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testByteNullSwappedComparesLess2() {
        test("testByteSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testByteCompareLessEqual(FieldObject f, byte byteValue) {
        if (f.byteValue <= byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareLessEqualConstant1(FieldObject f) {
        if (f.byteValue <= byteTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareLessEqualConstant2(FieldObject f) {
        if (f.byteValue <= byteTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testByteCompareLessEqual", f, byteTestValue1);
        test("testByteCompareLessEqualConstant1", f);
        test("testByteCompareLessEqualConstant2", f);
    }

    @Test
    public void testByteNullComparesLessEqual() {
        test("testByteCompareLessEqual", null, byteTestValue1);
    }

    @Test
    public void testByteNullComparesLessEqual1() {
        test("testByteCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testByteNullComparesLessEqual2() {
        test("testByteCompareLessEqualConstant2", (Object) null);
    }

    public static Object testByteSwappedCompareLessEqual(FieldObject f, byte byteValue) {
        if (byteValue <= f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareLessEqualConstant1(FieldObject f) {
        if (byteTestValue1 <= f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareLessEqualConstant2(FieldObject f) {
        if (byteTestValue2 <= f.byteValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testByteSwappedCompareLessEqual", f, byteTestValue1);
        test("testByteSwappedCompareLessEqualConstant1", f);
        test("testByteSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testByteNullSwappedComparesLessEqual() {
        test("testByteSwappedCompareLessEqual", null, byteTestValue1);
    }

    @Test
    public void testByteNullSwappedComparesLessEqual1() {
        test("testByteSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testByteNullSwappedComparesLessEqual2() {
        test("testByteSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testByteCompareGreater(FieldObject f, byte byteValue) {
        if (f.byteValue > byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareGreaterConstant1(FieldObject f) {
        if (f.byteValue > byteTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareGreaterConstant2(FieldObject f) {
        if (f.byteValue > byteTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteComparesGreater() {
        FieldObject f = new FieldObject();
        test("testByteCompareGreater", f, byteTestValue1);
        test("testByteCompareGreaterConstant1", f);
        test("testByteCompareGreaterConstant2", f);
    }

    @Test
    public void testByteNullComparesGreater() {
        test("testByteCompareGreater", null, byteTestValue1);
    }

    @Test
    public void testByteNullComparesGreater1() {
        test("testByteCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testByteNullComparesGreater2() {
        test("testByteCompareGreaterConstant2", (Object) null);
    }

    public static Object testByteSwappedCompareGreater(FieldObject f, byte byteValue) {
        if (byteValue > f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareGreaterConstant1(FieldObject f) {
        if (byteTestValue1 > f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareGreaterConstant2(FieldObject f) {
        if (byteTestValue2 > f.byteValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testByteSwappedCompareGreater", f, byteTestValue1);
        test("testByteSwappedCompareGreaterConstant1", f);
        test("testByteSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testByteNullSwappedComparesGreater() {
        test("testByteSwappedCompareGreater", null, byteTestValue1);
    }

    @Test
    public void testByteNullSwappedComparesGreater1() {
        test("testByteSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testByteNullSwappedComparesGreater2() {
        test("testByteSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testByteCompareGreaterEqual(FieldObject f, byte byteValue) {
        if (f.byteValue >= byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareGreaterEqualConstant1(FieldObject f) {
        if (f.byteValue >= byteTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testByteCompareGreaterEqualConstant2(FieldObject f) {
        if (f.byteValue >= byteTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testByteCompareGreaterEqual", f, byteTestValue1);
        test("testByteCompareGreaterEqualConstant1", f);
        test("testByteCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testByteNullComparesGreaterEqual() {
        test("testByteCompareGreaterEqual", null, byteTestValue1);
    }

    @Test
    public void testByteNullComparesGreaterEqual1() {
        test("testByteCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testByteNullComparesGreaterEqual2() {
        test("testByteCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testByteSwappedCompareGreaterEqual(FieldObject f, byte byteValue) {
        if (byteValue >= f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (byteTestValue1 >= f.byteValue) {
            return f;
        }
        return null;
    }

    public static Object testByteSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (byteTestValue2 >= f.byteValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testByteSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testByteSwappedCompareGreaterEqual", f, byteTestValue1);
        test("testByteSwappedCompareGreaterEqualConstant1", f);
        test("testByteSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testByteNullSwappedComparesGreaterEqual() {
        test("testByteSwappedCompareGreaterEqual", null, byteTestValue1);
    }

    @Test
    public void testByteNullSwappedComparesGreaterEqual1() {
        test("testByteSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testByteNullSwappedComparesGreaterEqual2() {
        test("testByteSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testShortCompare(FieldObject f, short shortValue) {
        if (f.shortValue == shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareConstant1(FieldObject f) {
        if (f.shortValue == shortTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareConstant2(FieldObject f) {
        if (f.shortValue == shortTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortCompares() {
        FieldObject f = new FieldObject();
        test("testShortCompare", f, shortTestValue1);
        test("testShortCompareConstant1", f);
        test("testShortCompareConstant2", f);
    }

    @Test
    public void testShortNullCompares() {
        test("testShortCompare", null, shortTestValue1);
    }

    @Test
    public void testShortNullCompares1() {
        test("testShortCompareConstant1", (Object) null);
    }

    @Test
    public void testShortNullCompares2() {
        test("testShortCompareConstant2", (Object) null);
    }

    public static Object testShortCompareLess(FieldObject f, short shortValue) {
        if (f.shortValue < shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareLessConstant1(FieldObject f) {
        if (f.shortValue < shortTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareLessConstant2(FieldObject f) {
        if (f.shortValue < shortTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortComparesLess() {
        FieldObject f = new FieldObject();
        test("testShortCompareLess", f, shortTestValue1);
        test("testShortCompareLessConstant1", f);
        test("testShortCompareLessConstant2", f);
    }

    @Test
    public void testShortNullComparesLess() {
        test("testShortCompareLess", null, shortTestValue1);
    }

    @Test
    public void testShortNullComparesLess1() {
        test("testShortCompareLessConstant1", (Object) null);
    }

    @Test
    public void testShortNullComparesLess2() {
        test("testShortCompareLessConstant2", (Object) null);
    }

    public static Object testShortSwappedCompareLess(FieldObject f, short shortValue) {
        if (shortValue < f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareLessConstant1(FieldObject f) {
        if (shortTestValue1 < f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareLessConstant2(FieldObject f) {
        if (shortTestValue2 < f.shortValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testShortSwappedCompareLess", f, shortTestValue1);
        test("testShortSwappedCompareLessConstant1", f);
        test("testShortSwappedCompareLessConstant2", f);
    }

    @Test
    public void testShortNullSwappedComparesLess() {
        test("testShortSwappedCompareLess", null, shortTestValue1);
    }

    @Test
    public void testShortNullSwappedComparesLess1() {
        test("testShortSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testShortNullSwappedComparesLess2() {
        test("testShortSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testShortCompareLessEqual(FieldObject f, short shortValue) {
        if (f.shortValue <= shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareLessEqualConstant1(FieldObject f) {
        if (f.shortValue <= shortTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareLessEqualConstant2(FieldObject f) {
        if (f.shortValue <= shortTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testShortCompareLessEqual", f, shortTestValue1);
        test("testShortCompareLessEqualConstant1", f);
        test("testShortCompareLessEqualConstant2", f);
    }

    @Test
    public void testShortNullComparesLessEqual() {
        test("testShortCompareLessEqual", null, shortTestValue1);
    }

    @Test
    public void testShortNullComparesLessEqual1() {
        test("testShortCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testShortNullComparesLessEqual2() {
        test("testShortCompareLessEqualConstant2", (Object) null);
    }

    public static Object testShortSwappedCompareLessEqual(FieldObject f, short shortValue) {
        if (shortValue <= f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareLessEqualConstant1(FieldObject f) {
        if (shortTestValue1 <= f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareLessEqualConstant2(FieldObject f) {
        if (shortTestValue2 <= f.shortValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testShortSwappedCompareLessEqual", f, shortTestValue1);
        test("testShortSwappedCompareLessEqualConstant1", f);
        test("testShortSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testShortNullSwappedComparesLessEqual() {
        test("testShortSwappedCompareLessEqual", null, shortTestValue1);
    }

    @Test
    public void testShortNullSwappedComparesLessEqual1() {
        test("testShortSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testShortNullSwappedComparesLessEqual2() {
        test("testShortSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testShortCompareGreater(FieldObject f, short shortValue) {
        if (f.shortValue > shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareGreaterConstant1(FieldObject f) {
        if (f.shortValue > shortTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareGreaterConstant2(FieldObject f) {
        if (f.shortValue > shortTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortComparesGreater() {
        FieldObject f = new FieldObject();
        test("testShortCompareGreater", f, shortTestValue1);
        test("testShortCompareGreaterConstant1", f);
        test("testShortCompareGreaterConstant2", f);
    }

    @Test
    public void testShortNullComparesGreater() {
        test("testShortCompareGreater", null, shortTestValue1);
    }

    @Test
    public void testShortNullComparesGreater1() {
        test("testShortCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testShortNullComparesGreater2() {
        test("testShortCompareGreaterConstant2", (Object) null);
    }

    public static Object testShortSwappedCompareGreater(FieldObject f, short shortValue) {
        if (shortValue > f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareGreaterConstant1(FieldObject f) {
        if (shortTestValue1 > f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareGreaterConstant2(FieldObject f) {
        if (shortTestValue2 > f.shortValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testShortSwappedCompareGreater", f, shortTestValue1);
        test("testShortSwappedCompareGreaterConstant1", f);
        test("testShortSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testShortNullSwappedComparesGreater() {
        test("testShortSwappedCompareGreater", null, shortTestValue1);
    }

    @Test
    public void testShortNullSwappedComparesGreater1() {
        test("testShortSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testShortNullSwappedComparesGreater2() {
        test("testShortSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testShortCompareGreaterEqual(FieldObject f, short shortValue) {
        if (f.shortValue >= shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareGreaterEqualConstant1(FieldObject f) {
        if (f.shortValue >= shortTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testShortCompareGreaterEqualConstant2(FieldObject f) {
        if (f.shortValue >= shortTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testShortCompareGreaterEqual", f, shortTestValue1);
        test("testShortCompareGreaterEqualConstant1", f);
        test("testShortCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testShortNullComparesGreaterEqual() {
        test("testShortCompareGreaterEqual", null, shortTestValue1);
    }

    @Test
    public void testShortNullComparesGreaterEqual1() {
        test("testShortCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testShortNullComparesGreaterEqual2() {
        test("testShortCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testShortSwappedCompareGreaterEqual(FieldObject f, short shortValue) {
        if (shortValue >= f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (shortTestValue1 >= f.shortValue) {
            return f;
        }
        return null;
    }

    public static Object testShortSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (shortTestValue2 >= f.shortValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testShortSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testShortSwappedCompareGreaterEqual", f, shortTestValue1);
        test("testShortSwappedCompareGreaterEqualConstant1", f);
        test("testShortSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testShortNullSwappedComparesGreaterEqual() {
        test("testShortSwappedCompareGreaterEqual", null, shortTestValue1);
    }

    @Test
    public void testShortNullSwappedComparesGreaterEqual1() {
        test("testShortSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testShortNullSwappedComparesGreaterEqual2() {
        test("testShortSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testCharCompare(FieldObject f, char charValue) {
        if (f.charValue == charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareConstant1(FieldObject f) {
        if (f.charValue == charTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareConstant2(FieldObject f) {
        if (f.charValue == charTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharCompares() {
        FieldObject f = new FieldObject();
        test("testCharCompare", f, charTestValue1);
        test("testCharCompareConstant1", f);
        test("testCharCompareConstant2", f);
    }

    @Test
    public void testCharNullCompares() {
        test("testCharCompare", null, charTestValue1);
    }

    @Test
    public void testCharNullCompares1() {
        test("testCharCompareConstant1", (Object) null);
    }

    @Test
    public void testCharNullCompares2() {
        test("testCharCompareConstant2", (Object) null);
    }

    public static Object testCharCompareLess(FieldObject f, char charValue) {
        if (f.charValue < charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareLessConstant1(FieldObject f) {
        if (f.charValue < charTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareLessConstant2(FieldObject f) {
        if (f.charValue < charTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharComparesLess() {
        FieldObject f = new FieldObject();
        test("testCharCompareLess", f, charTestValue1);
        test("testCharCompareLessConstant1", f);
        test("testCharCompareLessConstant2", f);
    }

    @Test
    public void testCharNullComparesLess() {
        test("testCharCompareLess", null, charTestValue1);
    }

    @Test
    public void testCharNullComparesLess1() {
        test("testCharCompareLessConstant1", (Object) null);
    }

    @Test
    public void testCharNullComparesLess2() {
        test("testCharCompareLessConstant2", (Object) null);
    }

    public static Object testCharSwappedCompareLess(FieldObject f, char charValue) {
        if (charValue < f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareLessConstant1(FieldObject f) {
        if (charTestValue1 < f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareLessConstant2(FieldObject f) {
        if (charTestValue2 < f.charValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testCharSwappedCompareLess", f, charTestValue1);
        test("testCharSwappedCompareLessConstant1", f);
        test("testCharSwappedCompareLessConstant2", f);
    }

    @Test
    public void testCharNullSwappedComparesLess() {
        test("testCharSwappedCompareLess", null, charTestValue1);
    }

    @Test
    public void testCharNullSwappedComparesLess1() {
        test("testCharSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testCharNullSwappedComparesLess2() {
        test("testCharSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testCharCompareLessEqual(FieldObject f, char charValue) {
        if (f.charValue <= charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareLessEqualConstant1(FieldObject f) {
        if (f.charValue <= charTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareLessEqualConstant2(FieldObject f) {
        if (f.charValue <= charTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testCharCompareLessEqual", f, charTestValue1);
        test("testCharCompareLessEqualConstant1", f);
        test("testCharCompareLessEqualConstant2", f);
    }

    @Test
    public void testCharNullComparesLessEqual() {
        test("testCharCompareLessEqual", null, charTestValue1);
    }

    @Test
    public void testCharNullComparesLessEqual1() {
        test("testCharCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testCharNullComparesLessEqual2() {
        test("testCharCompareLessEqualConstant2", (Object) null);
    }

    public static Object testCharSwappedCompareLessEqual(FieldObject f, char charValue) {
        if (charValue <= f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareLessEqualConstant1(FieldObject f) {
        if (charTestValue1 <= f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareLessEqualConstant2(FieldObject f) {
        if (charTestValue2 <= f.charValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testCharSwappedCompareLessEqual", f, charTestValue1);
        test("testCharSwappedCompareLessEqualConstant1", f);
        test("testCharSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testCharNullSwappedComparesLessEqual() {
        test("testCharSwappedCompareLessEqual", null, charTestValue1);
    }

    @Test
    public void testCharNullSwappedComparesLessEqual1() {
        test("testCharSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testCharNullSwappedComparesLessEqual2() {
        test("testCharSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testCharCompareGreater(FieldObject f, char charValue) {
        if (f.charValue > charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareGreaterConstant1(FieldObject f) {
        if (f.charValue > charTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareGreaterConstant2(FieldObject f) {
        if (f.charValue > charTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharComparesGreater() {
        FieldObject f = new FieldObject();
        test("testCharCompareGreater", f, charTestValue1);
        test("testCharCompareGreaterConstant1", f);
        test("testCharCompareGreaterConstant2", f);
    }

    @Test
    public void testCharNullComparesGreater() {
        test("testCharCompareGreater", null, charTestValue1);
    }

    @Test
    public void testCharNullComparesGreater1() {
        test("testCharCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testCharNullComparesGreater2() {
        test("testCharCompareGreaterConstant2", (Object) null);
    }

    public static Object testCharSwappedCompareGreater(FieldObject f, char charValue) {
        if (charValue > f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareGreaterConstant1(FieldObject f) {
        if (charTestValue1 > f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareGreaterConstant2(FieldObject f) {
        if (charTestValue2 > f.charValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testCharSwappedCompareGreater", f, charTestValue1);
        test("testCharSwappedCompareGreaterConstant1", f);
        test("testCharSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testCharNullSwappedComparesGreater() {
        test("testCharSwappedCompareGreater", null, charTestValue1);
    }

    @Test
    public void testCharNullSwappedComparesGreater1() {
        test("testCharSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testCharNullSwappedComparesGreater2() {
        test("testCharSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testCharCompareGreaterEqual(FieldObject f, char charValue) {
        if (f.charValue >= charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareGreaterEqualConstant1(FieldObject f) {
        if (f.charValue >= charTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testCharCompareGreaterEqualConstant2(FieldObject f) {
        if (f.charValue >= charTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testCharCompareGreaterEqual", f, charTestValue1);
        test("testCharCompareGreaterEqualConstant1", f);
        test("testCharCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testCharNullComparesGreaterEqual() {
        test("testCharCompareGreaterEqual", null, charTestValue1);
    }

    @Test
    public void testCharNullComparesGreaterEqual1() {
        test("testCharCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testCharNullComparesGreaterEqual2() {
        test("testCharCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testCharSwappedCompareGreaterEqual(FieldObject f, char charValue) {
        if (charValue >= f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (charTestValue1 >= f.charValue) {
            return f;
        }
        return null;
    }

    public static Object testCharSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (charTestValue2 >= f.charValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testCharSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testCharSwappedCompareGreaterEqual", f, charTestValue1);
        test("testCharSwappedCompareGreaterEqualConstant1", f);
        test("testCharSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testCharNullSwappedComparesGreaterEqual() {
        test("testCharSwappedCompareGreaterEqual", null, charTestValue1);
    }

    @Test
    public void testCharNullSwappedComparesGreaterEqual1() {
        test("testCharSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testCharNullSwappedComparesGreaterEqual2() {
        test("testCharSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testIntCompare(FieldObject f, int intValue) {
        if (f.intValue == intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareConstant1(FieldObject f) {
        if (f.intValue == intTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareConstant2(FieldObject f) {
        if (f.intValue == intTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntCompares() {
        FieldObject f = new FieldObject();
        test("testIntCompare", f, intTestValue1);
        test("testIntCompareConstant1", f);
        test("testIntCompareConstant2", f);
    }

    @Test
    public void testIntNullCompares() {
        test("testIntCompare", null, intTestValue1);
    }

    @Test
    public void testIntNullCompares1() {
        test("testIntCompareConstant1", (Object) null);
    }

    @Test
    public void testIntNullCompares2() {
        test("testIntCompareConstant2", (Object) null);
    }

    public static Object testIntCompareLess(FieldObject f, int intValue) {
        if (f.intValue < intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareLessConstant1(FieldObject f) {
        if (f.intValue < intTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareLessConstant2(FieldObject f) {
        if (f.intValue < intTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntComparesLess() {
        FieldObject f = new FieldObject();
        test("testIntCompareLess", f, intTestValue1);
        test("testIntCompareLessConstant1", f);
        test("testIntCompareLessConstant2", f);
    }

    @Test
    public void testIntNullComparesLess() {
        test("testIntCompareLess", null, intTestValue1);
    }

    @Test
    public void testIntNullComparesLess1() {
        test("testIntCompareLessConstant1", (Object) null);
    }

    @Test
    public void testIntNullComparesLess2() {
        test("testIntCompareLessConstant2", (Object) null);
    }

    public static Object testIntSwappedCompareLess(FieldObject f, int intValue) {
        if (intValue < f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareLessConstant1(FieldObject f) {
        if (intTestValue1 < f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareLessConstant2(FieldObject f) {
        if (intTestValue2 < f.intValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testIntSwappedCompareLess", f, intTestValue1);
        test("testIntSwappedCompareLessConstant1", f);
        test("testIntSwappedCompareLessConstant2", f);
    }

    @Test
    public void testIntNullSwappedComparesLess() {
        test("testIntSwappedCompareLess", null, intTestValue1);
    }

    @Test
    public void testIntNullSwappedComparesLess1() {
        test("testIntSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testIntNullSwappedComparesLess2() {
        test("testIntSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testIntCompareLessEqual(FieldObject f, int intValue) {
        if (f.intValue <= intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareLessEqualConstant1(FieldObject f) {
        if (f.intValue <= intTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareLessEqualConstant2(FieldObject f) {
        if (f.intValue <= intTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testIntCompareLessEqual", f, intTestValue1);
        test("testIntCompareLessEqualConstant1", f);
        test("testIntCompareLessEqualConstant2", f);
    }

    @Test
    public void testIntNullComparesLessEqual() {
        test("testIntCompareLessEqual", null, intTestValue1);
    }

    @Test
    public void testIntNullComparesLessEqual1() {
        test("testIntCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testIntNullComparesLessEqual2() {
        test("testIntCompareLessEqualConstant2", (Object) null);
    }

    public static Object testIntSwappedCompareLessEqual(FieldObject f, int intValue) {
        if (intValue <= f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareLessEqualConstant1(FieldObject f) {
        if (intTestValue1 <= f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareLessEqualConstant2(FieldObject f) {
        if (intTestValue2 <= f.intValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testIntSwappedCompareLessEqual", f, intTestValue1);
        test("testIntSwappedCompareLessEqualConstant1", f);
        test("testIntSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testIntNullSwappedComparesLessEqual() {
        test("testIntSwappedCompareLessEqual", null, intTestValue1);
    }

    @Test
    public void testIntNullSwappedComparesLessEqual1() {
        test("testIntSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testIntNullSwappedComparesLessEqual2() {
        test("testIntSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testIntCompareGreater(FieldObject f, int intValue) {
        if (f.intValue > intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareGreaterConstant1(FieldObject f) {
        if (f.intValue > intTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareGreaterConstant2(FieldObject f) {
        if (f.intValue > intTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntComparesGreater() {
        FieldObject f = new FieldObject();
        test("testIntCompareGreater", f, intTestValue1);
        test("testIntCompareGreaterConstant1", f);
        test("testIntCompareGreaterConstant2", f);
    }

    @Test
    public void testIntNullComparesGreater() {
        test("testIntCompareGreater", null, intTestValue1);
    }

    @Test
    public void testIntNullComparesGreater1() {
        test("testIntCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testIntNullComparesGreater2() {
        test("testIntCompareGreaterConstant2", (Object) null);
    }

    public static Object testIntSwappedCompareGreater(FieldObject f, int intValue) {
        if (intValue > f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareGreaterConstant1(FieldObject f) {
        if (intTestValue1 > f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareGreaterConstant2(FieldObject f) {
        if (intTestValue2 > f.intValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testIntSwappedCompareGreater", f, intTestValue1);
        test("testIntSwappedCompareGreaterConstant1", f);
        test("testIntSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testIntNullSwappedComparesGreater() {
        test("testIntSwappedCompareGreater", null, intTestValue1);
    }

    @Test
    public void testIntNullSwappedComparesGreater1() {
        test("testIntSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testIntNullSwappedComparesGreater2() {
        test("testIntSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testIntCompareGreaterEqual(FieldObject f, int intValue) {
        if (f.intValue >= intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareGreaterEqualConstant1(FieldObject f) {
        if (f.intValue >= intTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testIntCompareGreaterEqualConstant2(FieldObject f) {
        if (f.intValue >= intTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testIntCompareGreaterEqual", f, intTestValue1);
        test("testIntCompareGreaterEqualConstant1", f);
        test("testIntCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testIntNullComparesGreaterEqual() {
        test("testIntCompareGreaterEqual", null, intTestValue1);
    }

    @Test
    public void testIntNullComparesGreaterEqual1() {
        test("testIntCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testIntNullComparesGreaterEqual2() {
        test("testIntCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testIntSwappedCompareGreaterEqual(FieldObject f, int intValue) {
        if (intValue >= f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (intTestValue1 >= f.intValue) {
            return f;
        }
        return null;
    }

    public static Object testIntSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (intTestValue2 >= f.intValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testIntSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testIntSwappedCompareGreaterEqual", f, intTestValue1);
        test("testIntSwappedCompareGreaterEqualConstant1", f);
        test("testIntSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testIntNullSwappedComparesGreaterEqual() {
        test("testIntSwappedCompareGreaterEqual", null, intTestValue1);
    }

    @Test
    public void testIntNullSwappedComparesGreaterEqual1() {
        test("testIntSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testIntNullSwappedComparesGreaterEqual2() {
        test("testIntSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testFloatCompare(FieldObject f, float floatValue) {
        if (f.floatValue == floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareConstant1(FieldObject f) {
        if (f.floatValue == floatTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareConstant2(FieldObject f) {
        if (f.floatValue == floatTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatCompares() {
        FieldObject f = new FieldObject();
        test("testFloatCompare", f, floatTestValue1);
        test("testFloatCompareConstant1", f);
        test("testFloatCompareConstant2", f);
    }

    @Test
    public void testFloatNullCompares() {
        test("testFloatCompare", null, floatTestValue1);
    }

    @Test
    public void testFloatNullCompares1() {
        test("testFloatCompareConstant1", (Object) null);
    }

    @Test
    public void testFloatNullCompares2() {
        test("testFloatCompareConstant2", (Object) null);
    }

    public static Object testFloatCompareLess(FieldObject f, float floatValue) {
        if (f.floatValue < floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareLessConstant1(FieldObject f) {
        if (f.floatValue < floatTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareLessConstant2(FieldObject f) {
        if (f.floatValue < floatTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatComparesLess() {
        FieldObject f = new FieldObject();
        test("testFloatCompareLess", f, floatTestValue1);
        test("testFloatCompareLessConstant1", f);
        test("testFloatCompareLessConstant2", f);
    }

    @Test
    public void testFloatNullComparesLess() {
        test("testFloatCompareLess", null, floatTestValue1);
    }

    @Test
    public void testFloatNullComparesLess1() {
        test("testFloatCompareLessConstant1", (Object) null);
    }

    @Test
    public void testFloatNullComparesLess2() {
        test("testFloatCompareLessConstant2", (Object) null);
    }

    public static Object testFloatSwappedCompareLess(FieldObject f, float floatValue) {
        if (floatValue < f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareLessConstant1(FieldObject f) {
        if (floatTestValue1 < f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareLessConstant2(FieldObject f) {
        if (floatTestValue2 < f.floatValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testFloatSwappedCompareLess", f, floatTestValue1);
        test("testFloatSwappedCompareLessConstant1", f);
        test("testFloatSwappedCompareLessConstant2", f);
    }

    @Test
    public void testFloatNullSwappedComparesLess() {
        test("testFloatSwappedCompareLess", null, floatTestValue1);
    }

    @Test
    public void testFloatNullSwappedComparesLess1() {
        test("testFloatSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testFloatNullSwappedComparesLess2() {
        test("testFloatSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testFloatCompareLessEqual(FieldObject f, float floatValue) {
        if (f.floatValue <= floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareLessEqualConstant1(FieldObject f) {
        if (f.floatValue <= floatTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareLessEqualConstant2(FieldObject f) {
        if (f.floatValue <= floatTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testFloatCompareLessEqual", f, floatTestValue1);
        test("testFloatCompareLessEqualConstant1", f);
        test("testFloatCompareLessEqualConstant2", f);
    }

    @Test
    public void testFloatNullComparesLessEqual() {
        test("testFloatCompareLessEqual", null, floatTestValue1);
    }

    @Test
    public void testFloatNullComparesLessEqual1() {
        test("testFloatCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testFloatNullComparesLessEqual2() {
        test("testFloatCompareLessEqualConstant2", (Object) null);
    }

    public static Object testFloatSwappedCompareLessEqual(FieldObject f, float floatValue) {
        if (floatValue <= f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareLessEqualConstant1(FieldObject f) {
        if (floatTestValue1 <= f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareLessEqualConstant2(FieldObject f) {
        if (floatTestValue2 <= f.floatValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testFloatSwappedCompareLessEqual", f, floatTestValue1);
        test("testFloatSwappedCompareLessEqualConstant1", f);
        test("testFloatSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testFloatNullSwappedComparesLessEqual() {
        test("testFloatSwappedCompareLessEqual", null, floatTestValue1);
    }

    @Test
    public void testFloatNullSwappedComparesLessEqual1() {
        test("testFloatSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testFloatNullSwappedComparesLessEqual2() {
        test("testFloatSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testFloatCompareGreater(FieldObject f, float floatValue) {
        if (f.floatValue > floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareGreaterConstant1(FieldObject f) {
        if (f.floatValue > floatTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareGreaterConstant2(FieldObject f) {
        if (f.floatValue > floatTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatComparesGreater() {
        FieldObject f = new FieldObject();
        test("testFloatCompareGreater", f, floatTestValue1);
        test("testFloatCompareGreaterConstant1", f);
        test("testFloatCompareGreaterConstant2", f);
    }

    @Test
    public void testFloatNullComparesGreater() {
        test("testFloatCompareGreater", null, floatTestValue1);
    }

    @Test
    public void testFloatNullComparesGreater1() {
        test("testFloatCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testFloatNullComparesGreater2() {
        test("testFloatCompareGreaterConstant2", (Object) null);
    }

    public static Object testFloatSwappedCompareGreater(FieldObject f, float floatValue) {
        if (floatValue > f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareGreaterConstant1(FieldObject f) {
        if (floatTestValue1 > f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareGreaterConstant2(FieldObject f) {
        if (floatTestValue2 > f.floatValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testFloatSwappedCompareGreater", f, floatTestValue1);
        test("testFloatSwappedCompareGreaterConstant1", f);
        test("testFloatSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testFloatNullSwappedComparesGreater() {
        test("testFloatSwappedCompareGreater", null, floatTestValue1);
    }

    @Test
    public void testFloatNullSwappedComparesGreater1() {
        test("testFloatSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testFloatNullSwappedComparesGreater2() {
        test("testFloatSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testFloatCompareGreaterEqual(FieldObject f, float floatValue) {
        if (f.floatValue >= floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareGreaterEqualConstant1(FieldObject f) {
        if (f.floatValue >= floatTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testFloatCompareGreaterEqualConstant2(FieldObject f) {
        if (f.floatValue >= floatTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testFloatCompareGreaterEqual", f, floatTestValue1);
        test("testFloatCompareGreaterEqualConstant1", f);
        test("testFloatCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testFloatNullComparesGreaterEqual() {
        test("testFloatCompareGreaterEqual", null, floatTestValue1);
    }

    @Test
    public void testFloatNullComparesGreaterEqual1() {
        test("testFloatCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testFloatNullComparesGreaterEqual2() {
        test("testFloatCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testFloatSwappedCompareGreaterEqual(FieldObject f, float floatValue) {
        if (floatValue >= f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (floatTestValue1 >= f.floatValue) {
            return f;
        }
        return null;
    }

    public static Object testFloatSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (floatTestValue2 >= f.floatValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testFloatSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testFloatSwappedCompareGreaterEqual", f, floatTestValue1);
        test("testFloatSwappedCompareGreaterEqualConstant1", f);
        test("testFloatSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testFloatNullSwappedComparesGreaterEqual() {
        test("testFloatSwappedCompareGreaterEqual", null, floatTestValue1);
    }

    @Test
    public void testFloatNullSwappedComparesGreaterEqual1() {
        test("testFloatSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testFloatNullSwappedComparesGreaterEqual2() {
        test("testFloatSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testLongCompare(FieldObject f, long longValue) {
        if (f.longValue == longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareConstant1(FieldObject f) {
        if (f.longValue == longTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareConstant2(FieldObject f) {
        if (f.longValue == longTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongCompares() {
        FieldObject f = new FieldObject();
        test("testLongCompare", f, longTestValue1);
        test("testLongCompareConstant1", f);
        test("testLongCompareConstant2", f);
    }

    @Test
    public void testLongNullCompares() {
        test("testLongCompare", null, longTestValue1);
    }

    @Test
    public void testLongNullCompares1() {
        test("testLongCompareConstant1", (Object) null);
    }

    @Test
    public void testLongNullCompares2() {
        test("testLongCompareConstant2", (Object) null);
    }

    public static Object testLongCompareLess(FieldObject f, long longValue) {
        if (f.longValue < longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareLessConstant1(FieldObject f) {
        if (f.longValue < longTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareLessConstant2(FieldObject f) {
        if (f.longValue < longTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongComparesLess() {
        FieldObject f = new FieldObject();
        test("testLongCompareLess", f, longTestValue1);
        test("testLongCompareLessConstant1", f);
        test("testLongCompareLessConstant2", f);
    }

    @Test
    public void testLongNullComparesLess() {
        test("testLongCompareLess", null, longTestValue1);
    }

    @Test
    public void testLongNullComparesLess1() {
        test("testLongCompareLessConstant1", (Object) null);
    }

    @Test
    public void testLongNullComparesLess2() {
        test("testLongCompareLessConstant2", (Object) null);
    }

    public static Object testLongSwappedCompareLess(FieldObject f, long longValue) {
        if (longValue < f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareLessConstant1(FieldObject f) {
        if (longTestValue1 < f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareLessConstant2(FieldObject f) {
        if (longTestValue2 < f.longValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testLongSwappedCompareLess", f, longTestValue1);
        test("testLongSwappedCompareLessConstant1", f);
        test("testLongSwappedCompareLessConstant2", f);
    }

    @Test
    public void testLongNullSwappedComparesLess() {
        test("testLongSwappedCompareLess", null, longTestValue1);
    }

    @Test
    public void testLongNullSwappedComparesLess1() {
        test("testLongSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testLongNullSwappedComparesLess2() {
        test("testLongSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testLongCompareLessEqual(FieldObject f, long longValue) {
        if (f.longValue <= longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareLessEqualConstant1(FieldObject f) {
        if (f.longValue <= longTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareLessEqualConstant2(FieldObject f) {
        if (f.longValue <= longTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testLongCompareLessEqual", f, longTestValue1);
        test("testLongCompareLessEqualConstant1", f);
        test("testLongCompareLessEqualConstant2", f);
    }

    @Test
    public void testLongNullComparesLessEqual() {
        test("testLongCompareLessEqual", null, longTestValue1);
    }

    @Test
    public void testLongNullComparesLessEqual1() {
        test("testLongCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testLongNullComparesLessEqual2() {
        test("testLongCompareLessEqualConstant2", (Object) null);
    }

    public static Object testLongSwappedCompareLessEqual(FieldObject f, long longValue) {
        if (longValue <= f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareLessEqualConstant1(FieldObject f) {
        if (longTestValue1 <= f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareLessEqualConstant2(FieldObject f) {
        if (longTestValue2 <= f.longValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testLongSwappedCompareLessEqual", f, longTestValue1);
        test("testLongSwappedCompareLessEqualConstant1", f);
        test("testLongSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testLongNullSwappedComparesLessEqual() {
        test("testLongSwappedCompareLessEqual", null, longTestValue1);
    }

    @Test
    public void testLongNullSwappedComparesLessEqual1() {
        test("testLongSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testLongNullSwappedComparesLessEqual2() {
        test("testLongSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testLongCompareGreater(FieldObject f, long longValue) {
        if (f.longValue > longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareGreaterConstant1(FieldObject f) {
        if (f.longValue > longTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareGreaterConstant2(FieldObject f) {
        if (f.longValue > longTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongComparesGreater() {
        FieldObject f = new FieldObject();
        test("testLongCompareGreater", f, longTestValue1);
        test("testLongCompareGreaterConstant1", f);
        test("testLongCompareGreaterConstant2", f);
    }

    @Test
    public void testLongNullComparesGreater() {
        test("testLongCompareGreater", null, longTestValue1);
    }

    @Test
    public void testLongNullComparesGreater1() {
        test("testLongCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testLongNullComparesGreater2() {
        test("testLongCompareGreaterConstant2", (Object) null);
    }

    public static Object testLongSwappedCompareGreater(FieldObject f, long longValue) {
        if (longValue > f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareGreaterConstant1(FieldObject f) {
        if (longTestValue1 > f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareGreaterConstant2(FieldObject f) {
        if (longTestValue2 > f.longValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testLongSwappedCompareGreater", f, longTestValue1);
        test("testLongSwappedCompareGreaterConstant1", f);
        test("testLongSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testLongNullSwappedComparesGreater() {
        test("testLongSwappedCompareGreater", null, longTestValue1);
    }

    @Test
    public void testLongNullSwappedComparesGreater1() {
        test("testLongSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testLongNullSwappedComparesGreater2() {
        test("testLongSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testLongCompareGreaterEqual(FieldObject f, long longValue) {
        if (f.longValue >= longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareGreaterEqualConstant1(FieldObject f) {
        if (f.longValue >= longTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testLongCompareGreaterEqualConstant2(FieldObject f) {
        if (f.longValue >= longTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testLongCompareGreaterEqual", f, longTestValue1);
        test("testLongCompareGreaterEqualConstant1", f);
        test("testLongCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testLongNullComparesGreaterEqual() {
        test("testLongCompareGreaterEqual", null, longTestValue1);
    }

    @Test
    public void testLongNullComparesGreaterEqual1() {
        test("testLongCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testLongNullComparesGreaterEqual2() {
        test("testLongCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testLongSwappedCompareGreaterEqual(FieldObject f, long longValue) {
        if (longValue >= f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (longTestValue1 >= f.longValue) {
            return f;
        }
        return null;
    }

    public static Object testLongSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (longTestValue2 >= f.longValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testLongSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testLongSwappedCompareGreaterEqual", f, longTestValue1);
        test("testLongSwappedCompareGreaterEqualConstant1", f);
        test("testLongSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testLongNullSwappedComparesGreaterEqual() {
        test("testLongSwappedCompareGreaterEqual", null, longTestValue1);
    }

    @Test
    public void testLongNullSwappedComparesGreaterEqual1() {
        test("testLongSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testLongNullSwappedComparesGreaterEqual2() {
        test("testLongSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testDoubleCompare(FieldObject f, double doubleValue) {
        if (f.doubleValue == doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareConstant1(FieldObject f) {
        if (f.doubleValue == doubleTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareConstant2(FieldObject f) {
        if (f.doubleValue == doubleTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleCompares() {
        FieldObject f = new FieldObject();
        test("testDoubleCompare", f, doubleTestValue1);
        test("testDoubleCompareConstant1", f);
        test("testDoubleCompareConstant2", f);
    }

    @Test
    public void testDoubleNullCompares() {
        test("testDoubleCompare", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullCompares1() {
        test("testDoubleCompareConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullCompares2() {
        test("testDoubleCompareConstant2", (Object) null);
    }

    public static Object testDoubleCompareLess(FieldObject f, double doubleValue) {
        if (f.doubleValue < doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareLessConstant1(FieldObject f) {
        if (f.doubleValue < doubleTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareLessConstant2(FieldObject f) {
        if (f.doubleValue < doubleTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleComparesLess() {
        FieldObject f = new FieldObject();
        test("testDoubleCompareLess", f, doubleTestValue1);
        test("testDoubleCompareLessConstant1", f);
        test("testDoubleCompareLessConstant2", f);
    }

    @Test
    public void testDoubleNullComparesLess() {
        test("testDoubleCompareLess", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullComparesLess1() {
        test("testDoubleCompareLessConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullComparesLess2() {
        test("testDoubleCompareLessConstant2", (Object) null);
    }

    public static Object testDoubleSwappedCompareLess(FieldObject f, double doubleValue) {
        if (doubleValue < f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareLessConstant1(FieldObject f) {
        if (doubleTestValue1 < f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareLessConstant2(FieldObject f) {
        if (doubleTestValue2 < f.doubleValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleSwappedComparesLess() {
        FieldObject f = new FieldObject();
        test("testDoubleSwappedCompareLess", f, doubleTestValue1);
        test("testDoubleSwappedCompareLessConstant1", f);
        test("testDoubleSwappedCompareLessConstant2", f);
    }

    @Test
    public void testDoubleNullSwappedComparesLess() {
        test("testDoubleSwappedCompareLess", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullSwappedComparesLess1() {
        test("testDoubleSwappedCompareLessConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullSwappedComparesLess2() {
        test("testDoubleSwappedCompareLessConstant2", (Object) null);
    }

    public static Object testDoubleCompareLessEqual(FieldObject f, double doubleValue) {
        if (f.doubleValue <= doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareLessEqualConstant1(FieldObject f) {
        if (f.doubleValue <= doubleTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareLessEqualConstant2(FieldObject f) {
        if (f.doubleValue <= doubleTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testDoubleCompareLessEqual", f, doubleTestValue1);
        test("testDoubleCompareLessEqualConstant1", f);
        test("testDoubleCompareLessEqualConstant2", f);
    }

    @Test
    public void testDoubleNullComparesLessEqual() {
        test("testDoubleCompareLessEqual", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullComparesLessEqual1() {
        test("testDoubleCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullComparesLessEqual2() {
        test("testDoubleCompareLessEqualConstant2", (Object) null);
    }

    public static Object testDoubleSwappedCompareLessEqual(FieldObject f, double doubleValue) {
        if (doubleValue <= f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareLessEqualConstant1(FieldObject f) {
        if (doubleTestValue1 <= f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareLessEqualConstant2(FieldObject f) {
        if (doubleTestValue2 <= f.doubleValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleSwappedComparesLessEqual() {
        FieldObject f = new FieldObject();
        test("testDoubleSwappedCompareLessEqual", f, doubleTestValue1);
        test("testDoubleSwappedCompareLessEqualConstant1", f);
        test("testDoubleSwappedCompareLessEqualConstant2", f);
    }

    @Test
    public void testDoubleNullSwappedComparesLessEqual() {
        test("testDoubleSwappedCompareLessEqual", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullSwappedComparesLessEqual1() {
        test("testDoubleSwappedCompareLessEqualConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullSwappedComparesLessEqual2() {
        test("testDoubleSwappedCompareLessEqualConstant2", (Object) null);
    }

    public static Object testDoubleCompareGreater(FieldObject f, double doubleValue) {
        if (f.doubleValue > doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareGreaterConstant1(FieldObject f) {
        if (f.doubleValue > doubleTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareGreaterConstant2(FieldObject f) {
        if (f.doubleValue > doubleTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleComparesGreater() {
        FieldObject f = new FieldObject();
        test("testDoubleCompareGreater", f, doubleTestValue1);
        test("testDoubleCompareGreaterConstant1", f);
        test("testDoubleCompareGreaterConstant2", f);
    }

    @Test
    public void testDoubleNullComparesGreater() {
        test("testDoubleCompareGreater", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullComparesGreater1() {
        test("testDoubleCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullComparesGreater2() {
        test("testDoubleCompareGreaterConstant2", (Object) null);
    }

    public static Object testDoubleSwappedCompareGreater(FieldObject f, double doubleValue) {
        if (doubleValue > f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareGreaterConstant1(FieldObject f) {
        if (doubleTestValue1 > f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareGreaterConstant2(FieldObject f) {
        if (doubleTestValue2 > f.doubleValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleSwappedComparesGreater() {
        FieldObject f = new FieldObject();
        test("testDoubleSwappedCompareGreater", f, doubleTestValue1);
        test("testDoubleSwappedCompareGreaterConstant1", f);
        test("testDoubleSwappedCompareGreaterConstant2", f);
    }

    @Test
    public void testDoubleNullSwappedComparesGreater() {
        test("testDoubleSwappedCompareGreater", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullSwappedComparesGreater1() {
        test("testDoubleSwappedCompareGreaterConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullSwappedComparesGreater2() {
        test("testDoubleSwappedCompareGreaterConstant2", (Object) null);
    }

    public static Object testDoubleCompareGreaterEqual(FieldObject f, double doubleValue) {
        if (f.doubleValue >= doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareGreaterEqualConstant1(FieldObject f) {
        if (f.doubleValue >= doubleTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testDoubleCompareGreaterEqualConstant2(FieldObject f) {
        if (f.doubleValue >= doubleTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testDoubleCompareGreaterEqual", f, doubleTestValue1);
        test("testDoubleCompareGreaterEqualConstant1", f);
        test("testDoubleCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testDoubleNullComparesGreaterEqual() {
        test("testDoubleCompareGreaterEqual", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullComparesGreaterEqual1() {
        test("testDoubleCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullComparesGreaterEqual2() {
        test("testDoubleCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testDoubleSwappedCompareGreaterEqual(FieldObject f, double doubleValue) {
        if (doubleValue >= f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareGreaterEqualConstant1(FieldObject f) {
        if (doubleTestValue1 >= f.doubleValue) {
            return f;
        }
        return null;
    }

    public static Object testDoubleSwappedCompareGreaterEqualConstant2(FieldObject f) {
        if (doubleTestValue2 >= f.doubleValue) {
            return f;
        }
        return null;
    }

    @Test
    public void testDoubleSwappedComparesGreaterEqual() {
        FieldObject f = new FieldObject();
        test("testDoubleSwappedCompareGreaterEqual", f, doubleTestValue1);
        test("testDoubleSwappedCompareGreaterEqualConstant1", f);
        test("testDoubleSwappedCompareGreaterEqualConstant2", f);
    }

    @Test
    public void testDoubleNullSwappedComparesGreaterEqual() {
        test("testDoubleSwappedCompareGreaterEqual", null, doubleTestValue1);
    }

    @Test
    public void testDoubleNullSwappedComparesGreaterEqual1() {
        test("testDoubleSwappedCompareGreaterEqualConstant1", (Object) null);
    }

    @Test
    public void testDoubleNullSwappedComparesGreaterEqual2() {
        test("testDoubleSwappedCompareGreaterEqualConstant2", (Object) null);
    }

    public static Object testObjectCompare(FieldObject f, Object objectValue) {
        if (f.objectValue == objectValue) {
            return f;
        }
        return null;
    }

    public static Object testObjectCompareConstant1(FieldObject f) {
        if (f.objectValue == objectTestValue1) {
            return f;
        }
        return null;
    }

    public static Object testObjectCompareConstant2(FieldObject f) {
        if (f.objectValue == objectTestValue2) {
            return f;
        }
        return null;
    }

    @Test
    public void testObjectCompares() {
        FieldObject f = new FieldObject();
        test("testObjectCompare", f, objectTestValue1);
        test("testObjectCompareConstant1", f);
        test("testObjectCompareConstant2", f);
    }

    @Test
    public void testObjectNullCompares() {
        test("testObjectCompare", null, objectTestValue1);
    }

    @Test
    public void testObjectNullCompares1() {
        test("testObjectCompareConstant1", (Object) null);
    }

    @Test
    public void testObjectNullCompares2() {
        test("testObjectCompareConstant2", (Object) null);
    }

    public static int testByteAdd(FieldObject f, byte byteValue) {
        return f.byteValue + byteValue;
    }

    public static int testByteAddConstant1(FieldObject f) {
        return f.byteValue + byteTestValue1;
    }

    public static int testByteAddConstant2(FieldObject f) {
        return f.byteValue + byteTestValue2;
    }

    @Test
    public void testByteAdds() {
        FieldObject f = new FieldObject();
        test("testByteAdd", f, byteTestValue1);
        test("testByteAddConstant1", f);
        test("testByteAddConstant2", f);
    }

    @Test
    public void testByteNullAdd() {
        test("testByteAdd", null, byteTestValue1);
    }

    public static int testShortAdd(FieldObject f, short shortValue) {
        return f.shortValue + shortValue;
    }

    public static int testShortAddConstant1(FieldObject f) {
        return f.shortValue + shortTestValue1;
    }

    public static int testShortAddConstant2(FieldObject f) {
        return f.shortValue + shortTestValue2;
    }

    @Test
    public void testShortAdds() {
        FieldObject f = new FieldObject();
        test("testShortAdd", f, shortTestValue1);
        test("testShortAddConstant1", f);
        test("testShortAddConstant2", f);
    }

    @Test
    public void testShortNullAdd() {
        test("testShortAdd", null, shortTestValue1);
    }

    public static int testCharAdd(FieldObject f, char charValue) {
        return f.charValue + charValue;
    }

    public static int testCharAddConstant1(FieldObject f) {
        return f.charValue + charTestValue1;
    }

    public static int testCharAddConstant2(FieldObject f) {
        return f.charValue + charTestValue2;
    }

    @Test
    public void testCharAdds() {
        FieldObject f = new FieldObject();
        test("testCharAdd", f, charTestValue1);
        test("testCharAddConstant1", f);
        test("testCharAddConstant2", f);
    }

    @Test
    public void testCharNullAdd() {
        test("testCharAdd", null, charTestValue1);
    }

    public static int testIntAdd(FieldObject f, int intValue) {
        return f.intValue + intValue;
    }

    public static int testIntAddConstant1(FieldObject f) {
        return f.intValue + intTestValue1;
    }

    public static int testIntAddConstant2(FieldObject f) {
        return f.intValue + intTestValue2;
    }

    @Test
    public void testIntAdds() {
        FieldObject f = new FieldObject();
        test("testIntAdd", f, intTestValue1);
        test("testIntAddConstant1", f);
        test("testIntAddConstant2", f);
    }

    @Test
    public void testIntNullAdd() {
        test("testIntAdd", null, intTestValue1);
    }

    public static long testLongAdd(FieldObject f, long longValue) {
        return f.longValue + longValue;
    }

    public static long testLongAddConstant1(FieldObject f) {
        return f.longValue + longTestValue1;
    }

    public static long testLongAddConstant2(FieldObject f) {
        return f.longValue + longTestValue2;
    }

    @Test
    public void testLongAdds() {
        FieldObject f = new FieldObject();
        test("testLongAdd", f, longTestValue1);
        test("testLongAddConstant1", f);
        test("testLongAddConstant2", f);
    }

    @Test
    public void testLongNullAdd() {
        test("testLongAdd", null, longTestValue1);
    }

    public static float testFloatAdd(FieldObject f, float floatValue) {
        return f.floatValue + floatValue;
    }

    public static float testFloatAddConstant1(FieldObject f) {
        return f.floatValue + floatTestValue1;
    }

    public static float testFloatAddConstant2(FieldObject f) {
        return f.floatValue + floatTestValue2;
    }

    @Test
    public void testFloatAdds() {
        FieldObject f = new FieldObject();
        test("testFloatAdd", f, floatTestValue1);
        test("testFloatAddConstant1", f);
        test("testFloatAddConstant2", f);
    }

    @Test
    public void testFloatNullAdd() {
        test("testFloatAdd", null, floatTestValue1);
    }

    public static double testDoubleAdd(FieldObject f, double doubleValue) {
        return f.doubleValue + doubleValue;
    }

    public static double testDoubleAddConstant1(FieldObject f) {
        return f.doubleValue + doubleTestValue1;
    }

    public static double testDoubleAddConstant2(FieldObject f) {
        return f.doubleValue + doubleTestValue2;
    }

    @Test
    public void testDoubleAdds() {
        FieldObject f = new FieldObject();
        test("testDoubleAdd", f, doubleTestValue1);
        test("testDoubleAddConstant1", f);
        test("testDoubleAddConstant2", f);
    }

    @Test
    public void testDoubleNullAdd() {
        test("testDoubleAdd", null, doubleTestValue1);
    }

    public static int testByteSub(FieldObject f, byte byteValue) {
        return f.byteValue - byteValue;
    }

    public static int testByteSubConstant1(FieldObject f) {
        return f.byteValue - byteTestValue1;
    }

    public static int testByteSubConstant2(FieldObject f) {
        return f.byteValue - byteTestValue2;
    }

    @Test
    public void testByteSubs() {
        FieldObject f = new FieldObject();
        test("testByteSub", f, byteTestValue1);
        test("testByteSubConstant1", f);
        test("testByteSubConstant2", f);
    }

    @Test
    public void testByteNullSub() {
        test("testByteSub", null, byteTestValue1);
    }

    public static int testShortSub(FieldObject f, short shortValue) {
        return f.shortValue - shortValue;
    }

    public static int testShortSubConstant1(FieldObject f) {
        return f.shortValue - shortTestValue1;
    }

    public static int testShortSubConstant2(FieldObject f) {
        return f.shortValue - shortTestValue2;
    }

    @Test
    public void testShortSubs() {
        FieldObject f = new FieldObject();
        test("testShortSub", f, shortTestValue1);
        test("testShortSubConstant1", f);
        test("testShortSubConstant2", f);
    }

    @Test
    public void testShortNullSub() {
        test("testShortSub", null, shortTestValue1);
    }

    public static int testCharSub(FieldObject f, char charValue) {
        return f.charValue - charValue;
    }

    public static int testCharSubConstant1(FieldObject f) {
        return f.charValue - charTestValue1;
    }

    public static int testCharSubConstant2(FieldObject f) {
        return f.charValue - charTestValue2;
    }

    @Test
    public void testCharSubs() {
        FieldObject f = new FieldObject();
        test("testCharSub", f, charTestValue1);
        test("testCharSubConstant1", f);
        test("testCharSubConstant2", f);
    }

    @Test
    public void testCharNullSub() {
        test("testCharSub", null, charTestValue1);
    }

    public static int testIntSub(FieldObject f, int intValue) {
        return f.intValue - intValue;
    }

    public static int testIntSubConstant1(FieldObject f) {
        return f.intValue - intTestValue1;
    }

    public static int testIntSubConstant2(FieldObject f) {
        return f.intValue - intTestValue2;
    }

    @Test
    public void testIntSubs() {
        FieldObject f = new FieldObject();
        test("testIntSub", f, intTestValue1);
        test("testIntSubConstant1", f);
        test("testIntSubConstant2", f);
    }

    @Test
    public void testIntNullSub() {
        test("testIntSub", null, intTestValue1);
    }

    public static long testLongSub(FieldObject f, long longValue) {
        return f.longValue - longValue;
    }

    public static long testLongSubConstant1(FieldObject f) {
        return f.longValue - longTestValue1;
    }

    public static long testLongSubConstant2(FieldObject f) {
        return f.longValue - longTestValue2;
    }

    @Test
    public void testLongSubs() {
        FieldObject f = new FieldObject();
        test("testLongSub", f, longTestValue1);
        test("testLongSubConstant1", f);
        test("testLongSubConstant2", f);
    }

    @Test
    public void testLongNullSub() {
        test("testLongSub", null, longTestValue1);
    }

    public static float testFloatSub(FieldObject f, float floatValue) {
        return f.floatValue - floatValue;
    }

    public static float testFloatSubConstant1(FieldObject f) {
        return f.floatValue - floatTestValue1;
    }

    public static float testFloatSubConstant2(FieldObject f) {
        return f.floatValue - floatTestValue2;
    }

    @Test
    public void testFloatSubs() {
        FieldObject f = new FieldObject();
        test("testFloatSub", f, floatTestValue1);
        test("testFloatSubConstant1", f);
        test("testFloatSubConstant2", f);
    }

    @Test
    public void testFloatNullSub() {
        test("testFloatSub", null, floatTestValue1);
    }

    public static double testDoubleSub(FieldObject f, double doubleValue) {
        return f.doubleValue - doubleValue;
    }

    public static double testDoubleSubConstant1(FieldObject f) {
        return f.doubleValue - doubleTestValue1;
    }

    public static double testDoubleSubConstant2(FieldObject f) {
        return f.doubleValue - doubleTestValue2;
    }

    @Test
    public void testDoubleSubs() {
        FieldObject f = new FieldObject();
        test("testDoubleSub", f, doubleTestValue1);
        test("testDoubleSubConstant1", f);
        test("testDoubleSubConstant2", f);
    }

    @Test
    public void testDoubleNullSub() {
        test("testDoubleSub", null, doubleTestValue1);
    }

    public static int testByteMul(FieldObject f, byte byteValue) {
        return f.byteValue * byteValue;
    }

    public static int testByteMulConstant1(FieldObject f) {
        return f.byteValue * byteTestValue1;
    }

    public static int testByteMulConstant2(FieldObject f) {
        return f.byteValue * byteTestValue2;
    }

    @Test
    public void testByteMuls() {
        FieldObject f = new FieldObject();
        test("testByteMul", f, byteTestValue1);
        test("testByteMulConstant1", f);
        test("testByteMulConstant2", f);
    }

    @Test
    public void testByteNullMul() {
        test("testByteMul", null, byteTestValue1);
    }

    public static int testShortMul(FieldObject f, short shortValue) {
        return f.shortValue * shortValue;
    }

    public static int testShortMulConstant1(FieldObject f) {
        return f.shortValue * shortTestValue1;
    }

    public static int testShortMulConstant2(FieldObject f) {
        return f.shortValue * shortTestValue2;
    }

    @Test
    public void testShortMuls() {
        FieldObject f = new FieldObject();
        test("testShortMul", f, shortTestValue1);
        test("testShortMulConstant1", f);
        test("testShortMulConstant2", f);
    }

    @Test
    public void testShortNullMul() {
        test("testShortMul", null, shortTestValue1);
    }

    public static int testCharMul(FieldObject f, char charValue) {
        return f.charValue * charValue;
    }

    public static int testCharMulConstant1(FieldObject f) {
        return f.charValue * charTestValue1;
    }

    public static int testCharMulConstant2(FieldObject f) {
        return f.charValue * charTestValue2;
    }

    @Test
    public void testCharMuls() {
        FieldObject f = new FieldObject();
        test("testCharMul", f, charTestValue1);
        test("testCharMulConstant1", f);
        test("testCharMulConstant2", f);
    }

    @Test
    public void testCharNullMul() {
        test("testCharMul", null, charTestValue1);
    }

    public static int testIntMul(FieldObject f, int intValue) {
        return f.intValue * intValue;
    }

    public static int testIntMulConstant1(FieldObject f) {
        return f.intValue * intTestValue1;
    }

    public static int testIntMulConstant2(FieldObject f) {
        return f.intValue * intTestValue2;
    }

    @Test
    public void testIntMuls() {
        FieldObject f = new FieldObject();
        test("testIntMul", f, intTestValue1);
        test("testIntMulConstant1", f);
        test("testIntMulConstant2", f);
    }

    @Test
    public void testIntNullMul() {
        test("testIntMul", null, intTestValue1);
    }

    public static long testLongMul(FieldObject f, long longValue) {
        return f.longValue * longValue;
    }

    public static long testLongMulConstant1(FieldObject f) {
        return f.longValue * longTestValue1;
    }

    public static long testLongMulConstant2(FieldObject f) {
        return f.longValue * longTestValue2;
    }

    @Test
    public void testLongMuls() {
        FieldObject f = new FieldObject();
        test("testLongMul", f, longTestValue1);
        test("testLongMulConstant1", f);
        test("testLongMulConstant2", f);
    }

    @Test
    public void testLongNullMul() {
        test("testLongMul", null, longTestValue1);
    }

    public static float testFloatMul(FieldObject f, float floatValue) {
        return f.floatValue * floatValue;
    }

    public static float testFloatMulConstant1(FieldObject f) {
        return f.floatValue * floatTestValue1;
    }

    public static float testFloatMulConstant2(FieldObject f) {
        return f.floatValue * floatTestValue2;
    }

    @Test
    public void testFloatMuls() {
        FieldObject f = new FieldObject();
        test("testFloatMul", f, floatTestValue1);
        test("testFloatMulConstant1", f);
        test("testFloatMulConstant2", f);
    }

    @Test
    public void testFloatNullMul() {
        test("testFloatMul", null, floatTestValue1);
    }

    public static double testDoubleMul(FieldObject f, double doubleValue) {
        return f.doubleValue * doubleValue;
    }

    public static double testDoubleMulConstant1(FieldObject f) {
        return f.doubleValue * doubleTestValue1;
    }

    public static double testDoubleMulConstant2(FieldObject f) {
        return f.doubleValue * doubleTestValue2;
    }

    @Test
    public void testDoubleMuls() {
        FieldObject f = new FieldObject();
        test("testDoubleMul", f, doubleTestValue1);
        test("testDoubleMulConstant1", f);
        test("testDoubleMulConstant2", f);
    }

    @Test
    public void testDoubleNullMul() {
        test("testDoubleMul", null, doubleTestValue1);
    }

    public static int testByteDiv(FieldObject f, byte byteValue) {
        return f.byteValue / byteValue;
    }

    public static int testByteDivConstant1(FieldObject f) {
        return f.byteValue / byteTestValue1;
    }

    public static int testByteDivConstant2(FieldObject f) {
        return f.byteValue / byteTestValue2;
    }

    @Test
    public void testByteDivs() {
        FieldObject f = new FieldObject();
        test("testByteDiv", f, byteTestValue1);
        test("testByteDivConstant1", f);
        test("testByteDivConstant2", f);
    }

    @Test
    public void testByteNullDiv() {
        test("testByteDiv", null, byteTestValue1);
    }

    public static int testShortDiv(FieldObject f, short shortValue) {
        return f.shortValue / shortValue;
    }

    public static int testShortDivConstant1(FieldObject f) {
        return f.shortValue / shortTestValue1;
    }

    public static int testShortDivConstant2(FieldObject f) {
        return f.shortValue / shortTestValue2;
    }

    @Test
    public void testShortDivs() {
        FieldObject f = new FieldObject();
        test("testShortDiv", f, shortTestValue1);
        test("testShortDivConstant1", f);
        test("testShortDivConstant2", f);
    }

    @Test
    public void testShortNullDiv() {
        test("testShortDiv", null, shortTestValue1);
    }

    public static int testCharDiv(FieldObject f, char charValue) {
        return f.charValue / charValue;
    }

    public static int testCharDivConstant1(FieldObject f) {
        return f.charValue / charTestValue1;
    }

    public static int testCharDivConstant2(FieldObject f) {
        return f.charValue / charTestValue2;
    }

    @Test
    public void testCharDivs() {
        FieldObject f = new FieldObject();
        test("testCharDiv", f, charTestValue1);
        test("testCharDivConstant1", f);
        test("testCharDivConstant2", f);
    }

    @Test
    public void testCharNullDiv() {
        test("testCharDiv", null, charTestValue1);
    }

    public static int testIntDiv(FieldObject f, int intValue) {
        return f.intValue / intValue;
    }

    public static int testIntDivConstant1(FieldObject f) {
        return f.intValue / intTestValue1;
    }

    public static int testIntDivConstant2(FieldObject f) {
        return f.intValue / intTestValue2;
    }

    @Test
    public void testIntDivs() {
        FieldObject f = new FieldObject();
        test("testIntDiv", f, intTestValue1);
        test("testIntDivConstant1", f);
        test("testIntDivConstant2", f);
    }

    @Test
    public void testIntNullDiv() {
        test("testIntDiv", null, intTestValue1);
    }

    public static long testLongDiv(FieldObject f, long longValue) {
        return f.longValue / longValue;
    }

    public static long testLongDivConstant1(FieldObject f) {
        return f.longValue / longTestValue1;
    }

    public static long testLongDivConstant2(FieldObject f) {
        return f.longValue / longTestValue2;
    }

    @Test
    public void testLongDivs() {
        FieldObject f = new FieldObject();
        test("testLongDiv", f, longTestValue1);
        test("testLongDivConstant1", f);
        test("testLongDivConstant2", f);
    }

    @Test
    public void testLongNullDiv() {
        test("testLongDiv", null, longTestValue1);
    }

    public static float testFloatDiv(FieldObject f, float floatValue) {
        return f.floatValue / floatValue;
    }

    public static float testFloatDivConstant1(FieldObject f) {
        return f.floatValue / floatTestValue1;
    }

    public static float testFloatDivConstant2(FieldObject f) {
        return f.floatValue / floatTestValue2;
    }

    @Test
    public void testFloatDivs() {
        FieldObject f = new FieldObject();
        test("testFloatDiv", f, floatTestValue1);
        test("testFloatDivConstant1", f);
        test("testFloatDivConstant2", f);
    }

    @Test
    public void testFloatNullDiv() {
        test("testFloatDiv", null, floatTestValue1);
    }

    public static double testDoubleDiv(FieldObject f, double doubleValue) {
        return f.doubleValue / doubleValue;
    }

    public static double testDoubleDivConstant1(FieldObject f) {
        return f.doubleValue / doubleTestValue1;
    }

    public static double testDoubleDivConstant2(FieldObject f) {
        return f.doubleValue / doubleTestValue2;
    }

    @Test
    public void testDoubleDivs() {
        FieldObject f = new FieldObject();
        test("testDoubleDiv", f, doubleTestValue1);
        test("testDoubleDivConstant1", f);
        test("testDoubleDivConstant2", f);
    }

    @Test
    public void testDoubleNullDiv() {
        test("testDoubleDiv", null, doubleTestValue1);
    }

    public static int testByteOr(FieldObject f, byte byteValue) {
        return f.byteValue | byteValue;
    }

    public static int testByteOrConstant1(FieldObject f) {
        return f.byteValue | byteTestValue1;
    }

    public static int testByteOrConstant2(FieldObject f) {
        return f.byteValue | byteTestValue2;
    }

    @Test
    public void testByteOrs() {
        FieldObject f = new FieldObject();
        test("testByteOr", f, byteTestValue1);
        test("testByteOrConstant1", f);
        test("testByteOrConstant2", f);
    }

    @Test
    public void testByteNullOr() {
        test("testByteOr", null, byteTestValue1);
    }

    public static int testShortOr(FieldObject f, short shortValue) {
        return f.shortValue | shortValue;
    }

    public static int testShortOrConstant1(FieldObject f) {
        return f.shortValue | shortTestValue1;
    }

    public static int testShortOrConstant2(FieldObject f) {
        return f.shortValue | shortTestValue2;
    }

    @Test
    public void testShortOrs() {
        FieldObject f = new FieldObject();
        test("testShortOr", f, shortTestValue1);
        test("testShortOrConstant1", f);
        test("testShortOrConstant2", f);
    }

    @Test
    public void testShortNullOr() {
        test("testShortOr", null, shortTestValue1);
    }

    public static int testCharOr(FieldObject f, char charValue) {
        return f.charValue | charValue;
    }

    public static int testCharOrConstant1(FieldObject f) {
        return f.charValue | charTestValue1;
    }

    public static int testCharOrConstant2(FieldObject f) {
        return f.charValue | charTestValue2;
    }

    @Test
    public void testCharOrs() {
        FieldObject f = new FieldObject();
        test("testCharOr", f, charTestValue1);
        test("testCharOrConstant1", f);
        test("testCharOrConstant2", f);
    }

    @Test
    public void testCharNullOr() {
        test("testCharOr", null, charTestValue1);
    }

    public static int testIntOr(FieldObject f, int intValue) {
        return f.intValue | intValue;
    }

    public static int testIntOrConstant1(FieldObject f) {
        return f.intValue | intTestValue1;
    }

    public static int testIntOrConstant2(FieldObject f) {
        return f.intValue | intTestValue2;
    }

    @Test
    public void testIntOrs() {
        FieldObject f = new FieldObject();
        test("testIntOr", f, intTestValue1);
        test("testIntOrConstant1", f);
        test("testIntOrConstant2", f);
    }

    @Test
    public void testIntNullOr() {
        test("testIntOr", null, intTestValue1);
    }

    public static long testLongOr(FieldObject f, long longValue) {
        return f.longValue | longValue;
    }

    public static long testLongOrConstant1(FieldObject f) {
        return f.longValue | longTestValue1;
    }

    public static long testLongOrConstant2(FieldObject f) {
        return f.longValue | longTestValue2;
    }

    @Test
    public void testLongOrs() {
        FieldObject f = new FieldObject();
        test("testLongOr", f, longTestValue1);
        test("testLongOrConstant1", f);
        test("testLongOrConstant2", f);
    }

    @Test
    public void testLongNullOr() {
        test("testLongOr", null, longTestValue1);
    }

    public static int testByteXor(FieldObject f, byte byteValue) {
        return f.byteValue ^ byteValue;
    }

    public static int testByteXorConstant1(FieldObject f) {
        return f.byteValue ^ byteTestValue1;
    }

    public static int testByteXorConstant2(FieldObject f) {
        return f.byteValue ^ byteTestValue2;
    }

    @Test
    public void testByteXors() {
        FieldObject f = new FieldObject();
        test("testByteXor", f, byteTestValue1);
        test("testByteXorConstant1", f);
        test("testByteXorConstant2", f);
    }

    @Test
    public void testByteNullXor() {
        test("testByteXor", null, byteTestValue1);
    }

    public static int testShortXor(FieldObject f, short shortValue) {
        return f.shortValue ^ shortValue;
    }

    public static int testShortXorConstant1(FieldObject f) {
        return f.shortValue ^ shortTestValue1;
    }

    public static int testShortXorConstant2(FieldObject f) {
        return f.shortValue ^ shortTestValue2;
    }

    @Test
    public void testShortXors() {
        FieldObject f = new FieldObject();
        test("testShortXor", f, shortTestValue1);
        test("testShortXorConstant1", f);
        test("testShortXorConstant2", f);
    }

    @Test
    public void testShortNullXor() {
        test("testShortXor", null, shortTestValue1);
    }

    public static int testCharXor(FieldObject f, char charValue) {
        return f.charValue ^ charValue;
    }

    public static int testCharXorConstant1(FieldObject f) {
        return f.charValue ^ charTestValue1;
    }

    public static int testCharXorConstant2(FieldObject f) {
        return f.charValue ^ charTestValue2;
    }

    @Test
    public void testCharXors() {
        FieldObject f = new FieldObject();
        test("testCharXor", f, charTestValue1);
        test("testCharXorConstant1", f);
        test("testCharXorConstant2", f);
    }

    @Test
    public void testCharNullXor() {
        test("testCharXor", null, charTestValue1);
    }

    public static int testIntXor(FieldObject f, int intValue) {
        return f.intValue ^ intValue;
    }

    public static int testIntXorConstant1(FieldObject f) {
        return f.intValue ^ intTestValue1;
    }

    public static int testIntXorConstant2(FieldObject f) {
        return f.intValue ^ intTestValue2;
    }

    @Test
    public void testIntXors() {
        FieldObject f = new FieldObject();
        test("testIntXor", f, intTestValue1);
        test("testIntXorConstant1", f);
        test("testIntXorConstant2", f);
    }

    @Test
    public void testIntNullXor() {
        test("testIntXor", null, intTestValue1);
    }

    public static long testLongXor(FieldObject f, long longValue) {
        return f.longValue ^ longValue;
    }

    public static long testLongXorConstant1(FieldObject f) {
        return f.longValue ^ longTestValue1;
    }

    public static long testLongXorConstant2(FieldObject f) {
        return f.longValue ^ longTestValue2;
    }

    @Test
    public void testLongXors() {
        FieldObject f = new FieldObject();
        test("testLongXor", f, longTestValue1);
        test("testLongXorConstant1", f);
        test("testLongXorConstant2", f);
    }

    @Test
    public void testLongNullXor() {
        test("testLongXor", null, longTestValue1);
    }

    public static int testByteAnd(FieldObject f, byte byteValue) {
        return f.byteValue & byteValue;
    }

    public static int testByteAndConstant1(FieldObject f) {
        return f.byteValue & byteTestValue1;
    }

    public static int testByteAndConstant2(FieldObject f) {
        return f.byteValue & byteTestValue2;
    }

    @Test
    public void testByteAnds() {
        FieldObject f = new FieldObject();
        test("testByteAnd", f, byteTestValue1);
        test("testByteAndConstant1", f);
        test("testByteAndConstant2", f);
    }

    @Test
    public void testByteNullAnd() {
        test("testByteAnd", null, byteTestValue1);
    }

    public static int testShortAnd(FieldObject f, short shortValue) {
        return f.shortValue & shortValue;
    }

    public static int testShortAndConstant1(FieldObject f) {
        return f.shortValue & shortTestValue1;
    }

    public static int testShortAndConstant2(FieldObject f) {
        return f.shortValue & shortTestValue2;
    }

    @Test
    public void testShortAnds() {
        FieldObject f = new FieldObject();
        test("testShortAnd", f, shortTestValue1);
        test("testShortAndConstant1", f);
        test("testShortAndConstant2", f);
    }

    @Test
    public void testShortNullAnd() {
        test("testShortAnd", null, shortTestValue1);
    }

    public static int testCharAnd(FieldObject f, char charValue) {
        return f.charValue & charValue;
    }

    public static int testCharAndConstant1(FieldObject f) {
        return f.charValue & charTestValue1;
    }

    public static int testCharAndConstant2(FieldObject f) {
        return f.charValue & charTestValue2;
    }

    @Test
    public void testCharAnds() {
        FieldObject f = new FieldObject();
        test("testCharAnd", f, charTestValue1);
        test("testCharAndConstant1", f);
        test("testCharAndConstant2", f);
    }

    @Test
    public void testCharNullAnd() {
        test("testCharAnd", null, charTestValue1);
    }

    public static int testIntAnd(FieldObject f, int intValue) {
        return f.intValue & intValue;
    }

    public static int testIntAndConstant1(FieldObject f) {
        return f.intValue & intTestValue1;
    }

    public static int testIntAndConstant2(FieldObject f) {
        return f.intValue & intTestValue2;
    }

    @Test
    public void testIntAnds() {
        FieldObject f = new FieldObject();
        test("testIntAnd", f, intTestValue1);
        test("testIntAndConstant1", f);
        test("testIntAndConstant2", f);
    }

    @Test
    public void testIntNullAnd() {
        test("testIntAnd", null, intTestValue1);
    }

    public static long testLongAnd(FieldObject f, long longValue) {
        return f.longValue & longValue;
    }

    public static long testLongAndConstant1(FieldObject f) {
        return f.longValue & longTestValue1;
    }

    public static long testLongAndConstant2(FieldObject f) {
        return f.longValue & longTestValue2;
    }

    @Test
    public void testLongAnds() {
        FieldObject f = new FieldObject();
        test("testLongAnd", f, longTestValue1);
        test("testLongAndConstant1", f);
        test("testLongAndConstant2", f);
    }

    @Test
    public void testLongNullAnd() {
        test("testLongAnd", null, longTestValue1);
    }

    public static boolean testIntMask(FieldObject f, int intValue) {
        if ((f.intValue & intValue) != 0) {
            count++;
            return false;
        }
        return true;
    }

    public static boolean testIntMaskConstant1(FieldObject f) {
        return (f.intValue & intTestValue1) != 0;
    }

    public static boolean testIntMaskConstant2(FieldObject f) {
        return (f.intValue & intTestValue2) != 0;
    }

    @Test
    public void testIntMasks() {
        FieldObject f = new FieldObject();
        test("testIntMask", f, intTestValue1);
        test("testIntMaskConstant1", f);
        test("testIntMaskConstant2", f);
    }

    @Test
    public void testIntNullMask() {
        test("testIntMask", null, intTestValue1);
    }

    public static boolean testLongMask(FieldObject f, long longValue) {
        if ((f.longValue & longValue) != 0) {
            count++;
            return false;
        }
        return true;
    }

    public static boolean testLongMaskConstant1(FieldObject f) {
        return (f.longValue & longTestValue1) != 0;
    }

    public static boolean testLongMaskConstant2(FieldObject f) {
        return (f.longValue & longTestValue2) != 0;
    }

    @Test
    public void testLongMasks() {
        FieldObject f = new FieldObject();
        test("testLongMask", f, longTestValue1);
        test("testLongMaskConstant1", f);
        test("testLongMaskConstant2", f);
    }

    @Test
    public void testLongNullMask() {
        test("testLongMask", null, longTestValue1);
    }

    public static int doConvertByteInt(FieldObject f) {
        return f.byteValue;
    }

    @Test
    public void testConvertByteInt() {
        test("doConvertByteInt", maxObject);
        test("doConvertByteInt", (FieldObject) null);
    }

    public static int doConvertShortInt(FieldObject f) {
        return f.shortValue;
    }

    @Test
    public void testConvertShortInt() {
        test("doConvertShortInt", maxObject);
        test("doConvertShortInt", (FieldObject) null);
    }

    public static int doConvertCharInt(FieldObject f) {
        return f.charValue;
    }

    @Test
    public void testConvertCharInt() {
        test("doConvertCharInt", maxObject);
        test("doConvertCharInt", (FieldObject) null);
    }

    public static int doConvertLongInt(FieldObject f) {
        return (int) f.longValue;
    }

    @Test
    public void testConvertLongInt() {
        test("doConvertLongInt", maxObject);
        test("doConvertLongInt", (FieldObject) null);
    }

    public static int doConvertFloatInt(FieldObject f) {
        return (int) f.floatValue;
    }

    @Test
    public void testConvertFloatInt() {
        test("doConvertFloatInt", maxObject);
        test("doConvertFloatInt", (FieldObject) null);
    }

    public static int doConvertDoubleInt(FieldObject f) {
        return (int) f.doubleValue;
    }

    @Test
    public void testConvertDoubleInt() {
        test("doConvertDoubleInt", maxObject);
        test("doConvertDoubleInt", (FieldObject) null);
    }

    public static long doConvertByteLong(FieldObject f) {
        return f.byteValue;
    }

    @Test
    public void testConvertByteLong() {
        test("doConvertByteLong", maxObject);
        test("doConvertByteLong", (FieldObject) null);
    }

    public static long doConvertShortLong(FieldObject f) {
        return f.shortValue;
    }

    @Test
    public void testConvertShortLong() {
        test("doConvertShortLong", maxObject);
        test("doConvertShortLong", (FieldObject) null);
    }

    public static long doConvertCharLong(FieldObject f) {
        return f.charValue;
    }

    @Test
    public void testConvertCharLong() {
        test("doConvertCharLong", maxObject);
        test("doConvertCharLong", (FieldObject) null);
    }

    public static long doConvertIntLong(FieldObject f) {
        return f.intValue;
    }

    @Test
    public void testConvertIntLong() {
        test("doConvertIntLong", maxObject);
        test("doConvertIntLong", (FieldObject) null);
    }

    public static long doConvertFloatLong(FieldObject f) {
        return (long) f.floatValue;
    }

    @Test
    public void testConvertFloatLong() {
        test("doConvertFloatLong", maxObject);
        test("doConvertFloatLong", (FieldObject) null);
    }

    public static long doConvertDoubleLong(FieldObject f) {
        return (long) f.doubleValue;
    }

    @Test
    public void testConvertDoubleLong() {
        test("doConvertDoubleLong", maxObject);
        test("doConvertDoubleLong", (FieldObject) null);
    }

    public static float doConvertByteFloat(FieldObject f) {
        return f.byteValue;
    }

    @Test
    public void testConvertByteFloat() {
        test("doConvertByteFloat", maxObject);
        test("doConvertByteFloat", (FieldObject) null);
    }

    public static float doConvertShortFloat(FieldObject f) {
        return f.shortValue;
    }

    @Test
    public void testConvertShortFloat() {
        test("doConvertShortFloat", maxObject);
        test("doConvertShortFloat", (FieldObject) null);
    }

    public static float doConvertCharFloat(FieldObject f) {
        return f.charValue;
    }

    @Test
    public void testConvertCharFloat() {
        test("doConvertCharFloat", maxObject);
        test("doConvertCharFloat", (FieldObject) null);
    }

    public static float doConvertIntFloat(FieldObject f) {
        return f.intValue;
    }

    @Test
    public void testConvertIntFloat() {
        test("doConvertIntFloat", maxObject);
        test("doConvertIntFloat", (FieldObject) null);
    }

    public static float doConvertLongFloat(FieldObject f) {
        return f.longValue;
    }

    @Test
    public void testConvertLongFloat() {
        test("doConvertLongFloat", maxObject);
        test("doConvertLongFloat", (FieldObject) null);
    }

    public static float doConvertDoubleFloat(FieldObject f) {
        return (float) f.doubleValue;
    }

    @Test
    public void testConvertDoubleFloat() {
        test("doConvertDoubleFloat", maxObject);
        test("doConvertDoubleFloat", (FieldObject) null);
    }

    public static double doConvertByteDouble(FieldObject f) {
        return f.byteValue;
    }

    @Test
    public void testConvertByteDouble() {
        test("doConvertByteDouble", maxObject);
        test("doConvertByteDouble", (FieldObject) null);
    }

    public static double doConvertShortDouble(FieldObject f) {
        return f.shortValue;
    }

    @Test
    public void testConvertShortDouble() {
        test("doConvertShortDouble", maxObject);
        test("doConvertShortDouble", (FieldObject) null);
    }

    public static double doConvertCharDouble(FieldObject f) {
        return f.charValue;
    }

    @Test
    public void testConvertCharDouble() {
        test("doConvertCharDouble", maxObject);
        test("doConvertCharDouble", (FieldObject) null);
    }

    public static double doConvertIntDouble(FieldObject f) {
        return f.intValue;
    }

    @Test
    public void testConvertIntDouble() {
        test("doConvertIntDouble", maxObject);
        test("doConvertIntDouble", (FieldObject) null);
    }

    public static double doConvertLongDouble(FieldObject f) {
        return f.longValue;
    }

    @Test
    public void testConvertLongDouble() {
        test("doConvertLongDouble", maxObject);
        test("doConvertLongDouble", (FieldObject) null);
    }

    public static double doConvertFloatDouble(FieldObject f) {
        return f.floatValue;
    }

    @Test
    public void testConvertFloatDouble() {
        test("doConvertFloatDouble", maxObject);
        test("doConvertFloatDouble", (FieldObject) null);
    }
}