--- a/.hgtags	Wed Mar 26 17:02:45 2014 +0100
+++ b/.hgtags	Wed Mar 26 20:44:11 2014 +0100
@@ -408,3 +408,4 @@
 050a626a88951140df874f7b163e304d07b6c296 jdk9-b01
 b188446de75bda5fc52d102cddf242c3ef5ecbdf jdk9-b02
 b2fee789d23f3cdabb3db4e51af43038e5692d3a jdk9-b03
+483d05bf77a7c2a762aca1e06c4191bc06647176 graal-0.2

--- a/CHANGELOG.md	Wed Mar 26 17:02:45 2014 +0100
+++ b/CHANGELOG.md	Wed Mar 26 20:44:11 2014 +0100
@@ -2,30 +2,42 @@
 
 ## `tip`
 ### Graal
-* New methods for querying memory usage of individual objects and object graphs in Graal API (MetaAccessProvider#getMemorySize, MetaUtil#getMemorySizeRecursive).
-* New (tested) invariant that equality comparisons for JavaType/JavaMethod/JavaField values use .equals() instead of '=='.
+* ...
+### Truffle
+* ...
+
+## Version 0.2
+25-Mar-2014, [Repository Revision](http://hg.openjdk.java.net/graal/graal/rev/graal-0.2)
+
+### Graal
+* Use HotSpot stubs for certain array copy operations.
+* New methods for querying memory usage of individual objects and object graphs in Graal API (`MetaAccessProvider#getMemorySize`, `MetaUtil#getMemorySizeRecursive`).
+* Added tiered configuration (C1 + Graal).
+* Initial security model for Graal [GRAAL-22](https://bugs.openjdk.java.net/browse/GRAAL-22).
+* New (tested) invariant that equality comparisons for `JavaType`/`JavaMethod`/`JavaField` values use `.equals()` instead of `==`.
 * Made graph caching compilation-local.
+* Added AllocSpy tool for analyzing allocation in Graal using the [Java Allocation Instrumenter](https://code.google.com/p/java-allocation-instrumenter/).
+* Initial support for memory arithmetic operations on x86
 
 ### Truffle
-* New API TruffleRuntime#createCallNode to create call nodes and to give the runtime system control over its implementation.
-* New API RootNode#getCachedCallNodes to get a weak set of CallNodes that have registered to call the RootNode.
-* New API to split the AST of a call-site context sensitively. CallNode#split, CallNode#isSplittable, CallNode#getSplitCallTarget, CallNode#getCurrentCallTarget, RootNode#isSplittable, RootNode#split.
-* New API to inline a call-site into the call-graph. CallNode#isInlinable, CallNode#inline, CallNode#isInlined.
-* New API for the runtime environment to register CallTargets as caller to the RootNode. CallNode#registerCallTarget.
-* Improved API for counting nodes in Truffle ASTS. NodeUtil#countNodes can be used with a NodeFilter filter Nodes.
-* New API to declare the cost of a Node for use in runtime environment specific heuristics. See NodeCost, Node#getCost() and NodeInfo#cost().
-* Removed old API for NodeInfo#Kind and NodeInfo#kind(). As a replacement the new Node cost API can be used.
-* Changed Node#replace reason parameter type to CharSequence (to allow for lazy string building)
-* Deprecated Node#adoptChild and Node#adoptChild, no longer needed in node constructor
-* New Node#insert method for inserting new nodes into the tree (formerly adoptChild)
-* New Node#adoptChildren() helper method that adopts all (direct and indirect) children of a node
-* New API Node#atomic for atomic tree operations
-* Made Node#replace thread-safe
-
+* New API `TruffleRuntime#createCallNode` to create call nodes and to give the runtime system control over its implementation.
+* New API `RootNode#getCachedCallNodes` to get a weak set of `CallNode`s that have registered to call the `RootNode`.
+* New API to split the AST of a call-site context sensitively. `CallNode#split`, `CallNode#isSplittable`, `CallNode#getSplitCallTarget`, `CallNode#getCurrentCallTarget`, `RootNode#isSplittable`, `RootNode#split`.
+* New API to inline a call-site into the call-graph. `CallNode#isInlinable`, `CallNode#inline`, `CallNode#isInlined`.
+* New API for the runtime environment to register `CallTarget`s as caller to the `RootNode`. `CallNode#registerCallTarget`.
+* Improved API for counting nodes in Truffle ASTs. `NodeUtil#countNodes` can be used with a `NodeFilter`.
+* New API to declare the cost of a Node for use in runtime environment specific heuristics. See `NodeCost`, `Node#getCost` and `NodeInfo#cost`.
+* Removed old API for `NodeInfo#Kind` and `NodeInfo#kind`. As a replacement the new `NodeCost` API can be used.
+* Changed `Node#replace` reason parameter type to `CharSequence` (to enable lazy string building)
+* Deprecated `Node#adoptChild` and `Node#adoptChild`, no longer needed in node constructor
+* New `Node#insert` method for inserting new nodes into the tree (formerly `adoptChild`)
+* New `Node#adoptChildren` helper method that adopts all (direct and indirect) children of a node
+* New API `Node#atomic` for atomic tree operations
+* Made `Node#replace` thread-safe
 
 
 ## Version 0.1
-5-Feb-2014, [Repository Revision](http://hg.openjdk.java.net/graal/graal/rev/b124e22eb772)
+5-Feb-2014, [Repository Revision](http://hg.openjdk.java.net/graal/graal/rev/graal-0.1)
 
 ### Graal
 

--- a/README.md	Wed Mar 26 17:02:45 2014 +0100
+++ b/README.md	Wed Mar 26 20:44:11 2014 +0100
@@ -23,10 +23,11 @@
    Compilation with Graal is only done by explicit requests to the
    Graal API. This is how Truffle uses Graal.
    
-2. The 'graal' configuration is a VM where all compilation is performed
-   by Graal and no other compilers are built into the VM binary. This
-   VM will bootstrap Graal itself at startup unless the -XX:-BootstrapGraal
-   VM option is given.   
+2. The 'graal' configuration is a VM where normal compilations are performed
+   by Graal. This VM will bootstrap Graal itself at startup unless the
+   -XX:-BootstrapGraal. Note that if tiered compilation is enabled, Graal
+   will be used at the last tier while C1 will be used for the first compiled
+   tiers.
 
 Unless you use the --vm option with the build command, you will be presented
 with a dialogue to choose one of the above VM configurations for the build
@@ -78,5 +79,3 @@
 
 These configurations aim to match as closely as possible the
 VM(s) included in the OpenJDK binaries one can download.
- No newline at end of file
-

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CompilationResult.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CompilationResult.java	Wed Mar 26 20:44:11 2014 +0100
@@ -160,68 +160,79 @@
         public abstract void emit(TargetDescription target, ByteBuffer buffer);
     }
 
+    public abstract static class ConstantData extends Data {
+
+        private final Constant constant;
+
+        protected ConstantData(Constant constant, int alignment) {
+            super(alignment);
+            this.constant = constant;
+        }
+
+        public Constant getConstant() {
+            return constant;
+        }
+    }
+
     /**
      * Represents a Java primitive value used in a {@link DataPatch}. This implementation uses
      * {@link Kind#getByteCount()} bytes to encode each value.
      */
-    public static final class PrimitiveData extends Data {
-
-        public final Constant constant;
+    public static final class PrimitiveData extends ConstantData {
 
         public PrimitiveData(Constant constant, int alignment) {
-            super(alignment);
+            super(constant, alignment);
             assert constant.getKind().isPrimitive();
-            this.constant = constant;
         }
 
         @Override
         public int getSize(TargetDescription target) {
-            return constant.getKind().getByteCount();
+            return getConstant().getKind().getByteCount();
         }
 
         @Override
         public Kind getKind() {
-            return constant.getKind();
+            return getConstant().getKind();
         }
 
         @Override
         public void emit(TargetDescription target, ByteBuffer buffer) {
-            switch (constant.getKind()) {
+            switch (getConstant().getKind()) {
                 case Boolean:
-                    buffer.put(constant.asBoolean() ? (byte) 1 : (byte) 0);
+                    buffer.put(getConstant().asBoolean() ? (byte) 1 : (byte) 0);
                     break;
                 case Byte:
-                    buffer.put((byte) constant.asInt());
+                    buffer.put((byte) getConstant().asInt());
                     break;
                 case Char:
-                    buffer.putChar((char) constant.asInt());
+                    buffer.putChar((char) getConstant().asInt());
                     break;
                 case Short:
-                    buffer.putShort((short) constant.asInt());
+                    buffer.putShort((short) getConstant().asInt());
                     break;
                 case Int:
-                    buffer.putInt(constant.asInt());
+                    buffer.putInt(getConstant().asInt());
                     break;
                 case Long:
-                    buffer.putLong(constant.asLong());
+                    buffer.putLong(getConstant().asLong());
                     break;
                 case Float:
-                    buffer.putFloat(constant.asFloat());
+                    buffer.putFloat(getConstant().asFloat());
                     break;
                 case Double:
-                    buffer.putDouble(constant.asDouble());
+                    buffer.putDouble(getConstant().asDouble());
                     break;
             }
         }
 
         @Override
         public String toString() {
-            return constant.toString();
+            return getConstant().toString();
         }
 
         @Override
         public int hashCode() {
-            return constant.hashCode();
+            return getConstant().hashCode();
         }
 
         @Override
@@ -231,7 +242,7 @@
             }
             if (obj instanceof PrimitiveData) {
                 PrimitiveData other = (PrimitiveData) obj;
-                return constant.equals(other.constant);
+                return getConstant().equals(other.getConstant());
             } else {
                 return false;
             }
@@ -591,7 +602,15 @@
         addInfopoint(new Infopoint(codePos, debugInfo, reason));
     }
 
-    private void addInfopoint(Infopoint infopoint) {
+    /**
+     * Records a custom infopoint in the code section.
+     * 
+     * Compiler implementations can use this method to record non-standard infopoints, which are not
+     * handled by the dedicated methods like {@link #recordCall}.
+     * 
+     * @param infopoint the infopoint to record, usually a derived class from {@link Infopoint}
+     */
+    public void addInfopoint(Infopoint infopoint) {
         // The infopoints list must always be sorted
         if (!infopoints.isEmpty() && infopoints.get(infopoints.size() - 1).pcOffset >= infopoint.pcOffset) {
             // This re-sorting should be very rare

--- a/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64Assembler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64Assembler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -1213,6 +1213,7 @@
         emitByte(0xD0 | encode);
     }
 
+    @Override
     public final void ensureUniquePC() {
         nop();
     }
@@ -1669,6 +1670,13 @@
         emitInt(imm32);
     }
 
+    public final void testl(AMD64Address dst, int imm32) {
+        prefixq(dst);
+        emitByte(0xF7);
+        emitOperandHelper(0, dst);
+        emitInt(imm32);
+    }
+
     public final void testl(Register dst, Register src) {
         prefixAndEncode(dst.encoding, src.encoding);
         emitArith(0x85, 0xC0, dst, src);
@@ -2064,6 +2072,13 @@
         emitOperandHelper(dst, src);
     }
 
+    public final void cmpq(AMD64Address dst, int imm32) {
+        prefixq(dst);
+        emitByte(0x81);
+        emitOperandHelper(7, dst);
+        emitInt(imm32);
+    }
+
     public final void cmpq(Register dst, int imm32) {
         prefixqAndEncode(dst.encoding);
         emitArith(0x81, 0xF8, dst, imm32);
@@ -2410,6 +2425,13 @@
         emitOperandHelper(dst, src);
     }
 
+    public final void testq(AMD64Address dst, int imm32) {
+        prefixq(dst);
+        emitByte(0xF7);
+        emitOperandHelper(0, dst);
+        emitInt(imm32);
+    }
+
     public final void xorq(Register dst, int imm32) {
         prefixqAndEncode(dst.encoding);
         emitArith(0x81, 0xF0, dst, imm32);

--- a/graal/com.oracle.graal.asm.hsail/src/com/oracle/graal/asm/hsail/HSAILAssembler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.asm.hsail/src/com/oracle/graal/asm/hsail/HSAILAssembler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -68,6 +68,11 @@
         return null;
     }
 
+    @Override
+    public final void ensureUniquePC() {
+        throw GraalInternalError.unimplemented();
+    }
+
     public final void undefined(String str) {
         emitString("undefined operation " + str);
     }

--- a/graal/com.oracle.graal.asm.ptx/src/com/oracle/graal/asm/ptx/PTXAssembler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.asm.ptx/src/com/oracle/graal/asm/ptx/PTXAssembler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -696,6 +696,11 @@
     }
 
     @Override
+    public final void ensureUniquePC() {
+        throw GraalInternalError.unimplemented();
+    }
+
+    @Override
     public void jmp(Label l) {
         String str = nameOf(l);
         bra(str);

--- a/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -74,6 +74,7 @@
         return Placeholder;
     }
 
+    @Override
     public final void ensureUniquePC() {
         new Nop().emit(this);
     }

--- a/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/Assembler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/Assembler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -183,4 +183,9 @@
      * Returns a target specific placeholder address that can be used for code patching.
      */
     public abstract AbstractAddress getPlaceholder();
+
+    /**
+     * Emits a NOP instruction to advance the current PC.
+     */
+    public abstract void ensureUniquePC();
 }

--- a/graal/com.oracle.graal.baseline/src/com/oracle/graal/baseline/BaselineCompiler.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.baseline/src/com/oracle/graal/baseline/BaselineCompiler.java	Wed Mar 26 20:44:11 2014 +0100
@@ -771,7 +771,7 @@
             if (!currentBlock.jsrScope.isEmpty()) {
                 sb.append(' ').append(currentBlock.jsrScope);
             }
-            Debug.log(sb.toString());
+            Debug.log("%s", sb);
         }
     }
 

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Wed Mar 26 20:44:11 2014 +0100
@@ -41,6 +41,7 @@
 import com.oracle.graal.lir.StandardOp.JumpOp;
 import com.oracle.graal.lir.amd64.*;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.BinaryCommutative;
+import com.oracle.graal.lir.amd64.AMD64Arithmetic.BinaryMemory;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.BinaryRegConst;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.BinaryRegReg;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.BinaryRegStack;
@@ -48,7 +49,9 @@
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.DivRemOp;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.FPDivRemOp;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.Unary1Op;
+import com.oracle.graal.lir.amd64.AMD64Arithmetic.Unary2MemoryOp;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.Unary2Op;
+import com.oracle.graal.lir.amd64.AMD64Compare.CompareMemoryOp;
 import com.oracle.graal.lir.amd64.AMD64Compare.CompareOp;
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.BranchOp;
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.CondMoveOp;
@@ -58,6 +61,7 @@
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.StrategySwitchOp;
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.TableSwitchOp;
 import com.oracle.graal.lir.amd64.AMD64Move.LeaOp;
+import com.oracle.graal.lir.amd64.AMD64Move.LoadOp;
 import com.oracle.graal.lir.amd64.AMD64Move.MembarOp;
 import com.oracle.graal.lir.amd64.AMD64Move.MoveFromRegOp;
 import com.oracle.graal.lir.amd64.AMD64Move.MoveToRegOp;
@@ -327,10 +331,46 @@
         }
     }
 
+    protected void emitCompareMemoryConOp(Kind kind, AMD64AddressValue left, Value right, LIRFrameState state) {
+        assert kind == right.getKind();
+        switch (kind) {
+            case Int:
+                append(new CompareMemoryOp(ICMP, left, right, state));
+                break;
+            case Long:
+                append(new CompareMemoryOp(LCMP, left, right, state));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    protected void emitCompareRegMemoryOp(Kind kind, Value left, AMD64AddressValue right, LIRFrameState state) {
+        switch (kind) {
+            case Int:
+                append(new CompareMemoryOp(ICMP, left, right, state));
+                break;
+            case Long:
+                append(new CompareMemoryOp(LCMP, left, right, state));
+                break;
+            case Object:
+                append(new CompareMemoryOp(ACMP, left, right, state));
+                break;
+            case Float:
+                append(new CompareMemoryOp(FCMP, left, right, state));
+                break;
+            case Double:
+                append(new CompareMemoryOp(DCMP, left, right, state));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
     /**
      * This method emits the compare instruction, and may reorder the operands. It returns true if
      * it did so.
-     * 
+     *
      * @param a the left operand of the comparison
      * @param b the right operand of the comparison
      * @return true if the left and right operands were switched, false otherwise
@@ -492,6 +532,27 @@
         }
     }
 
+    protected Value emitBinaryMemory(AMD64Arithmetic op, Kind kind, AllocatableValue a, AMD64AddressValue location, LIRFrameState state) {
+        Variable result = newVariable(a.getKind());
+        append(new BinaryMemory(op, kind, result, a, location, state));
+        return result;
+    }
+
+    protected Value emitConvert2MemoryOp(PlatformKind kind, AMD64Arithmetic op, AMD64AddressValue address, LIRFrameState state) {
+        Variable result = newVariable(kind);
+        append(new Unary2MemoryOp(op, result, address, state));
+        return result;
+    }
+
+    protected Value emitZeroExtendMemory(Kind memoryKind, int resultBits, AMD64AddressValue address, LIRFrameState state) {
+        assert memoryKind.isUnsigned();
+        // Issue a zero extending load of the proper bit size and set the result to
+        // the proper kind.
+        Variable result = newVariable(resultBits == 32 ? Kind.Int : Kind.Long);
+        append(new LoadOp(memoryKind, result, address, state));
+        return result;
+    }
+
     private void emitDivRem(AMD64Arithmetic op, Value a, Value b, LIRFrameState state) {
         AllocatableValue rax = AMD64.rax.asValue(a.getPlatformKind());
         emitMove(rax, a);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64MemoryPeephole.java	Wed Mar 26 20:44:11 2014 +0100
@@ -0,0 +1,482 @@
+/*
+ * 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.amd64;
+
+import static com.oracle.graal.lir.amd64.AMD64Arithmetic.*;
+import static com.oracle.graal.nodes.ConstantNode.*;
+import static com.oracle.graal.phases.GraalOptions.*;
+
+import java.util.*;
+
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.asm.*;
+import com.oracle.graal.debug.*;
+import com.oracle.graal.graph.*;
+import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.amd64.*;
+import com.oracle.graal.lir.amd64.AMD64ControlFlow.BranchOp;
+import com.oracle.graal.lir.amd64.AMD64ControlFlow.FloatBranchOp;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.calc.*;
+import com.oracle.graal.nodes.calc.FloatConvertNode.FloatConvert;
+import com.oracle.graal.nodes.extended.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.graal.nodes.type.*;
+
+public class AMD64MemoryPeephole implements MemoryArithmeticLIRLowerer {
+    protected final AMD64NodeLIRGenerator gen;
+    protected List<ValueNode> deferredNodes;
+
+    protected AMD64MemoryPeephole(AMD64NodeLIRGenerator gen) {
+        this.gen = gen;
+    }
+
+    public Value setResult(ValueNode x, Value operand) {
+        return gen.setResult(x, operand);
+    }
+
+    @Override
+    public boolean memoryPeephole(Access access, MemoryArithmeticLIRLowerable operation, List<ValueNode> deferred) {
+        this.deferredNodes = deferred;
+        boolean result = operation.generate(this, access);
+        if (result) {
+            Debug.log("merge %s %s with %1s %s %s", access, access.asNode().stamp(), operation, result, access.asNode().graph().method());
+        } else {
+            Debug.log("can't merge %s %s with %1s", access, access.asNode().stamp(), operation);
+        }
+        this.deferredNodes = null;
+        return result;
+    }
+
+    protected LIRFrameState getState(Access access) {
+        if (access instanceof DeoptimizingNode) {
+            return gen.state((DeoptimizingNode) access);
+        }
+        return null;
+    }
+
+    protected AMD64AddressValue makeAddress(Access access) {
+        return (AMD64AddressValue) access.nullCheckLocation().generateAddress(gen, gen.operand(access.object()));
+    }
+
+    protected Value emitBinaryMemory(AMD64Arithmetic op, boolean commutative, ValueNode x, ValueNode y, Access access) {
+        ValueNode other = x;
+        if (other == access) {
+            if (commutative) {
+                other = y;
+            } else {
+                return null;
+            }
+        }
+        ensureEvaluated(other);
+        return gen.getLIRGenerator().emitBinaryMemory(op, access.nullCheckLocation().getValueKind(), gen.getLIRGeneratorTool().asAllocatable(gen.operand(other)), makeAddress(access), getState(access));
+    }
+
+    /**
+     * Constants with multiple users need to be evaluated in the right location so that later users
+     * can pick up the operand. Make sure that happens when it needs to.
+     */
+    protected void ensureEvaluated(ValueNode node) {
+        evaluateDeferred(node);
+        evaluateDeferred();
+    }
+
+    protected void evaluateDeferred(ValueNode node) {
+        // Ensure the other input value has a generated value.
+        if (ConstantNodeRecordsUsages) {
+            if (!gen.hasOperand(node)) {
+                assert node instanceof ConstantNode : node;
+                ((ConstantNode) node).generate(gen);
+            }
+        }
+    }
+
+    protected void evaluateDeferred() {
+        if (deferredNodes != null) {
+            for (ValueNode node : deferredNodes) {
+                evaluateDeferred(node);
+            }
+        }
+    }
+
+    protected Value emitConvert2MemoryOp(PlatformKind kind, AMD64Arithmetic op, Access access) {
+        AMD64AddressValue address = makeAddress(access);
+        LIRFrameState state = getState(access);
+        evaluateDeferred();
+        return gen.getLIRGenerator().emitConvert2MemoryOp(kind, op, address, state);
+    }
+
+    @Override
+    public Value emitAddMemory(ValueNode x, ValueNode y, Access access) {
+        switch (access.nullCheckLocation().getValueKind()) {
+            case Int:
+                return emitBinaryMemory(IADD, true, x, y, access);
+            case Long:
+                return emitBinaryMemory(LADD, true, x, y, access);
+            case Float:
+                return emitBinaryMemory(FADD, true, x, y, access);
+            case Double:
+                return emitBinaryMemory(DADD, true, x, y, access);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitSubMemory(ValueNode x, ValueNode y, Access access) {
+        switch (access.nullCheckLocation().getValueKind()) {
+            case Int:
+                return emitBinaryMemory(ISUB, false, x, y, access);
+            case Long:
+                return emitBinaryMemory(LSUB, false, x, y, access);
+            case Float:
+                return emitBinaryMemory(FSUB, false, x, y, access);
+            case Double:
+                return emitBinaryMemory(DSUB, false, x, y, access);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitMulMemory(ValueNode x, ValueNode y, Access access) {
+        switch (access.nullCheckLocation().getValueKind()) {
+            case Int:
+                return emitBinaryMemory(IMUL, true, x, y, access);
+            case Long:
+                return emitBinaryMemory(LMUL, true, x, y, access);
+            case Float:
+                return emitBinaryMemory(FMUL, true, x, y, access);
+            case Double:
+                return emitBinaryMemory(DMUL, true, x, y, access);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitDivMemory(ValueNode x, ValueNode y, Access access) {
+        return null;
+    }
+
+    @Override
+    public Value emitRemMemory(ValueNode x, ValueNode y, Access access) {
+        return null;
+    }
+
+    @Override
+    public Value emitAndMemory(ValueNode x, ValueNode y, Access access) {
+        Kind kind = access.nullCheckLocation().getValueKind();
+        switch (kind) {
+            case Int:
+                return emitBinaryMemory(IAND, true, x, y, access);
+            case Long:
+                return emitBinaryMemory(LAND, true, x, y, access);
+            case Short: {
+                ValueNode other = x == access ? y : x;
+                Constant constant = other instanceof ConstantNode ? ((ConstantNode) other).asConstant() : null;
+                if (constant != null && constant.asInt() == IntegerStamp.defaultMask(kind.getBitCount())) {
+                    // Convert to unsigned load
+                    ensureEvaluated(other);
+                    return emitZeroExtendMemory(16, 32, access);
+                }
+                return null;
+            }
+            case Byte: {
+                if (OptFoldMemory.getValue()) {
+                    return null;
+                }
+                ValueNode other = x == access ? y : x;
+                Constant constant = other instanceof ConstantNode ? ((ConstantNode) other).asConstant() : null;
+                if (constant != null && constant.asInt() == IntegerStamp.defaultMask(kind.getBitCount())) {
+                    // Convert to unsigned load
+                    ensureEvaluated(other);
+                    return emitConvert2MemoryOp(Kind.Int, MOV_B2UI, access);
+                }
+                return null;
+            }
+
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitOrMemory(ValueNode x, ValueNode y, Access access) {
+        switch (access.nullCheckLocation().getValueKind()) {
+            case Int:
+                return emitBinaryMemory(IOR, true, x, y, access);
+            case Long:
+                return emitBinaryMemory(LOR, true, x, y, access);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitXorMemory(ValueNode x, ValueNode y, Access access) {
+        switch (access.nullCheckLocation().getValueKind()) {
+            case Int:
+                return emitBinaryMemory(IXOR, true, x, y, access);
+            case Long:
+                return emitBinaryMemory(LXOR, true, x, y, access);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public Value emitReinterpretMemory(Stamp stamp, Access access) {
+        PlatformKind to = gen.getLIRGenerator().getPlatformKind(stamp);
+        Kind from = access.nullCheckLocation().getValueKind();
+        assert to != from : "should have been eliminated";
+
+        /*
+         * Conversions between integer to floating point types require moves between CPU and FPU
+         * registers.
+         */
+        switch ((Kind) to) {
+            case Int:
+                switch (from) {
+                    case Float:
+                        return emitConvert2MemoryOp(to, MOV_F2I, access);
+                }
+                break;
+            case Long:
+                switch (from) {
+                    case Double:
+                        return emitConvert2MemoryOp(to, MOV_D2L, access);
+                }
+                break;
+            case Float:
+                switch (from) {
+                    case Int:
+                        return emitConvert2MemoryOp(to, MOV_I2F, access);
+                }
+                break;
+            case Double:
+                switch (from) {
+                    case Long:
+                        return emitConvert2MemoryOp(to, MOV_L2D, access);
+                }
+                break;
+        }
+        throw GraalInternalError.shouldNotReachHere();
+    }
+
+    @Override
+    public Value emitFloatConvertMemory(FloatConvert op, Access access) {
+        switch (op) {
+            case D2F:
+                return emitConvert2MemoryOp(Kind.Float, D2F, access);
+            case D2I:
+                return emitConvert2MemoryOp(Kind.Int, D2I, access);
+            case D2L:
+                return emitConvert2MemoryOp(Kind.Long, D2L, access);
+            case F2D:
+                return emitConvert2MemoryOp(Kind.Double, F2D, access);
+            case F2I:
+                return emitConvert2MemoryOp(Kind.Int, F2I, access);
+            case F2L:
+                return emitConvert2MemoryOp(Kind.Long, F2L, access);
+            case I2D:
+                return emitConvert2MemoryOp(Kind.Double, I2D, access);
+            case I2F:
+                return emitConvert2MemoryOp(Kind.Float, I2F, access);
+            case L2D:
+                return emitConvert2MemoryOp(Kind.Double, L2D, access);
+            case L2F:
+                return emitConvert2MemoryOp(Kind.Float, L2F, access);
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    @Override
+    public Value emitSignExtendMemory(Access access, int fromBits, int toBits) {
+        assert fromBits <= toBits && toBits <= 64;
+        if (fromBits == toBits) {
+            return null;
+        } else if (toBits > 32) {
+            // sign extend to 64 bits
+            switch (fromBits) {
+                case 8:
+                    return emitConvert2MemoryOp(Kind.Long, B2L, access);
+                case 16:
+                    return emitConvert2MemoryOp(Kind.Long, S2L, access);
+                case 32:
+                    return emitConvert2MemoryOp(Kind.Long, I2L, access);
+                default:
+                    throw GraalInternalError.unimplemented("unsupported sign extension (" + fromBits + " bit -> " + toBits + " bit)");
+            }
+        } else {
+
+            // sign extend to 32 bits (smaller values are internally represented as 32 bit values)
+            switch (fromBits) {
+                case 8:
+                    return emitConvert2MemoryOp(Kind.Int, B2I, access);
+                case 16:
+                    return emitConvert2MemoryOp(Kind.Int, S2I, access);
+                case 32:
+                    return null;
+                default:
+                    throw GraalInternalError.unimplemented("unsupported sign extension (" + fromBits + " bit -> " + toBits + " bit)");
+            }
+        }
+    }
+
+    @Override
+    public Value emitNarrowMemory(int resultBits, Access access) {
+        // TODO
+        return null;
+    }
+
+    @Override
+    public Value emitZeroExtendMemory(int inputBits, int resultBits, Access access) {
+        assert resultBits == 32 || resultBits == 64;
+        Kind memoryKind = access.nullCheckLocation().getValueKind();
+        if (memoryKind.getBitCount() != inputBits && !memoryKind.isUnsigned()) {
+            // The memory being read from is signed and smaller than the result size so
+            // this is a sign extension to inputBits followed by a zero extension to resultBits
+            // which can't be expressed in a memory operation.
+            return null;
+        }
+        if (memoryKind == Kind.Short) {
+            memoryKind = Kind.Char;
+        }
+        evaluateDeferred();
+        return gen.getLIRGenerator().emitZeroExtendMemory(memoryKind, resultBits, makeAddress(access), getState(access));
+    }
+
+    public boolean emitIfMemory(IfNode x, Access access) {
+        return emitBranchMemory(x.condition(), access, gen.getLIRBlock(x.trueSuccessor()), gen.getLIRBlock(x.falseSuccessor()), x.probability(x.trueSuccessor()));
+    }
+
+    private boolean emitBranchMemory(LogicNode node, Access access, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) {
+        if (node instanceof IsNullNode) {
+            // can't do anything interesting.
+            return false;
+        } else if (node instanceof CompareNode) {
+            CompareNode compare = (CompareNode) node;
+            return emitCompareBranchMemory(compare, access, trueSuccessor, falseSuccessor, trueSuccessorProbability);
+        } else if (node instanceof LogicConstantNode) {
+            return false;
+        } else if (node instanceof IntegerTestNode) {
+            return emitIntegerTestBranchMemory((IntegerTestNode) node, access, trueSuccessor, falseSuccessor, trueSuccessorProbability);
+        } else {
+            throw GraalInternalError.unimplemented(node.toString());
+        }
+    }
+
+    public boolean emitCompareBranchMemory(CompareNode compare, Access access, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) {
+        return emitCompareBranchMemory(compare.x(), compare.y(), access, compare.condition(), compare.unorderedIsTrue(), trueSuccessor, falseSuccessor, trueSuccessorProbability);
+    }
+
+    public boolean emitIntegerTestBranchMemory(IntegerTestNode test, Access access, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability) {
+        return emitIntegerTestBranchMemory(test.x(), test.y(), access, trueSuccessor, falseSuccessor, trueSuccessorProbability);
+    }
+
+    private boolean emitIntegerTestBranchMemory(ValueNode left, ValueNode right, Access access, LabelRef trueLabel, LabelRef falseLabel, double trueLabelProbability) {
+        assert left == access || right == access;
+        ValueNode other = left == access ? right : left;
+        Kind kind = access.nullCheckLocation().getValueKind();
+        if (other.isConstant()) {
+            Constant constant = other.asConstant();
+            if (kind == Kind.Long && !NumUtil.isInt(constant.asLong())) {
+                // Only imm32 as long
+                return false;
+            }
+            ensureEvaluated(other);
+            gen.append(new AMD64TestMemoryOp(makeAddress(access), constant, getState(access)));
+        } else {
+            evaluateDeferred();
+            gen.append(new AMD64TestMemoryOp(makeAddress(access), gen.operand(other), getState(access)));
+        }
+
+        gen.append(new BranchOp(Condition.EQ, trueLabel, falseLabel, trueLabelProbability));
+        return true;
+    }
+
+    protected boolean emitCompareBranchMemory(ValueNode left, ValueNode right, Access access, Condition cond, boolean unorderedIsTrue, LabelRef trueLabel, LabelRef falseLabel,
+                    double trueLabelProbability) {
+        assert left == access || right == access;
+        ValueNode other = left == access ? right : left;
+        Kind kind = access.nullCheckLocation().getValueKind();
+        boolean mirrored = false;
+
+        if (other.isConstant()) {
+            Constant constant = other.asConstant();
+            if (kind == Kind.Long && !NumUtil.isInt(constant.asLong())) {
+                // Only imm32 as long
+                return false;
+            }
+            if (kind.isNumericFloat()) {
+                Debug.log("Skipping constant compares for float kinds");
+                return false;
+            }
+            if (kind == Kind.Object) {
+                if (!access.isCompressible() && !constant.isNull()) {
+                    Debug.log("Skipping constant compares for Object kinds");
+                    return false;
+                }
+            }
+            if (kind != kind.getStackKind()) {
+                Debug.log("Skipping constant compares for stack kinds");
+                return false;
+            }
+            ensureEvaluated(other);
+            gen.getLIRGenerator().emitCompareMemoryConOp(kind, makeAddress(access), constant, getState(access));
+            mirrored = right == access;
+        } else {
+            if (kind != kind.getStackKind()) {
+                // Register compares only work for stack kinds
+                Debug.log("Register compares only work for stack kinds");
+                return false;
+            } else if (kind == Kind.Object) {
+                // Can't compare against objects since they require encode/decode
+                Debug.log("Skipping compares for Object kinds");
+                return false;
+            }
+
+            evaluateDeferred();
+            gen.getLIRGenerator().emitCompareRegMemoryOp(kind, gen.operand(other), makeAddress(access), getState(access));
+            mirrored = left == access;
+        }
+
+        Condition finalCondition = mirrored ? cond.mirror() : cond;
+        switch (kind.getStackKind()) {
+            case Long:
+            case Int:
+            case Object:
+                gen.append(new BranchOp(finalCondition, trueLabel, falseLabel, trueLabelProbability));
+                return true;
+            case Float:
+            case Double:
+                gen.append(new FloatBranchOp(finalCondition, unorderedIsTrue, trueLabel, falseLabel, trueLabelProbability));
+                return true;
+            default:
+                throw GraalInternalError.shouldNotReachHere("" + kind.getStackKind());
+        }
+    }
+}

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRGenerator.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRGenerator.java	Wed Mar 26 20:44:11 2014 +0100
@@ -31,6 +31,7 @@
 import com.oracle.graal.lir.amd64.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.calc.*;
+import com.oracle.graal.nodes.spi.*;
 
 public abstract class AMD64NodeLIRGenerator extends NodeLIRGenerator {
 
@@ -38,6 +39,17 @@
         super(graph, res, gen);
     }
 
+    protected MemoryArithmeticLIRLowerer memoryPeephole;
+
+    @Override
+    public MemoryArithmeticLIRLowerer getMemoryLowerer() {
+        if (memoryPeephole == null) {
+            // Use the generic one
+            memoryPeephole = new AMD64MemoryPeephole(this);
+        }
+        return memoryPeephole;
+    }
+
     @Override
     protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
         AllocatableValue targetAddress = AMD64.rax.asValue();
@@ -93,4 +105,9 @@
     public void visitInfopointNode(InfopointNode i) {
         append(new InfopointOp(stateFor(i.getState()), i.reason));
     }
+
+    @Override
+    public AMD64LIRGenerator getLIRGenerator() {
+        return (AMD64LIRGenerator) gen;
+    }
 }

--- a/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java	Wed Mar 26 20:44:11 2014 +0100
@@ -113,6 +113,10 @@
         }
     }
 
+    public void emitData(AllocatableValue dst, byte[] data) {
+        throw GraalInternalError.unimplemented();
+    }
+
     public HSAILAddressValue asAddressValue(Value address) {
         if (address instanceof HSAILAddressValue) {
             return (HSAILAddressValue) address;

--- a/graal/com.oracle.graal.compiler.ptx.test/src/com/oracle/graal/compiler/ptx/test/ObjectPTXTest.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.ptx.test/src/com/oracle/graal/compiler/ptx/test/ObjectPTXTest.java	Wed Mar 26 20:44:11 2014 +0100
@@ -66,6 +66,7 @@
         return a.i + i;
     }
 
+    @Ignore("com.oracle.graal.graph.GraalInternalError: should not reach here: unhandled register type v3|z")
     @Test
     public void test2() {
         A a = new A();
@@ -79,6 +80,7 @@
         return a.z;
     }
 
+    @Ignore("[CUDA] Check for malformed PTX kernel or incorrect PTX compilation options")
     @Test
     public void test3() {
         for (byte b : new byte[]{Byte.MIN_VALUE, -10, 0, 1, 2, 10, Byte.MAX_VALUE}) {
@@ -92,6 +94,7 @@
         return a.b + b;
     }
 
+    @Ignore("com.oracle.graal.graph.GraalInternalError: should not reach here: unhandled register type v5|s")
     @Test
     public void test4() {
         for (short s : new short[]{Short.MIN_VALUE, -10, 0, 1, 2, 10, Short.MAX_VALUE}) {

--- a/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java	Wed Mar 26 20:44:11 2014 +0100
@@ -167,6 +167,11 @@
     }
 
     @Override
+    public void emitData(AllocatableValue dst, byte[] data) {
+        throw GraalInternalError.unimplemented();
+    }
+
+    @Override
     public PTXAddressValue emitAddress(Value base, long displacement, Value index, int scale) {
         AllocatableValue baseRegister;
         long finalDisp = displacement;

--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Wed Mar 26 20:44:11 2014 +0100
@@ -130,6 +130,11 @@
     }
 
     @Override
+    public void emitData(AllocatableValue dst, byte[] data) {
+        throw GraalInternalError.unimplemented();
+    }
+
+    @Override
     public SPARCAddressValue emitAddress(Value base, long displacement, Value index, int scale) {
         AllocatableValue baseRegister;
         long finalDisp = displacement;

--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/BoxingEliminationTest.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/BoxingEliminationTest.java	Wed Mar 26 20:44:11 2014 +0100
@@ -321,6 +321,7 @@
         Assumptions assumptions = new Assumptions(false);
         HighTierContext context = new HighTierContext(getProviders(), assumptions, null, getDefaultGraphBuilderSuite(), OptimisticOptimizations.ALL);
         CanonicalizerPhase canonicalizer = new CanonicalizerPhase(true);
+        canonicalizer.apply(graph, context);
         new InliningPhase(new CanonicalizerPhase(true)).apply(graph, context);
         if (loopPeeling) {
             new LoopTransformHighPhase().apply(graph);

--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/CheckGraalInvariants.java	Wed Mar 26 17:02:45 2014 +0100
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/CheckGraalInvariants.java	Wed Mar 26 20:44:11 2014 +0100
@@ -158,6 +158,7 @@
         new VerifyUsageWithEquals(JavaType.class).apply(graph, context);
         new VerifyUsageWithEquals(JavaMethod.class).apply(graph, context);
         new VerifyUsageWithEquals(JavaField.class).apply(graph, context);
+        new VerifyDebugUsage().apply(graph, context);
     }
 
     private static boolean matches(String[] filters, String s) {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/IfReorderTest.java	Wed Mar 26 20:44:11 2014 +0100
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2011, 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 java.io.*;
+import java.util.*;
+
+import org.junit.*;
+
+public class IfReorderTest extends GraalCompilerTest {
+
+    private static Object fieldA = Integer.class;
+    private static Object fieldB = Double.class;
+
+    @Test
+    public void test1() {
+        test("test1Snippet", new ArrayList<>());
+    }
+
+    public static Object test1Snippet(Object o) {
+        /*
+         * Serializable and List are not mutually exclusive, so these two IFs should never be
+         * reordered.
+         */
+        if (branchProbability(0.1, o instanceof Serializable)) {
+            return fieldA;
+        }
+        if (branchProbability(0.9, o instanceof List)) {
+            return fieldB;
+        }
+        return null;
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/IntegerEqualsCanonicalizerTest.java	Wed Mar 26 20:44:11 2014 +0100
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2011, 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 org.junit.*;
+
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.phases.common.*;
+import com.oracle.graal.phases.tiers.*;
+
+public class IntegerEqualsCanonicalizerTest extends GraalCompilerTest {
+
+    @Test
+    public void testShiftEquals() {
+        /*
+         * tests the canonicalization of (x >>> const) == 0 to x |test| (-1 << const)
+         */
+        test("testShiftEqualsSnippet", "testShiftEqualsReference");
+    }
+
+    @SuppressWarnings("unused") private static int field;
+
+    public static void testShiftEqualsSnippet(int x, int[] array, int y) {
+        // optimize
+        field = (x >>> 10) == 0 ? 1 : 0;
+        field = (array.length >> 10) == 0 ? 1 : 0;
+        field = (x << 10) == 0 ? 1 : 0;
+        // don't optimize
+        field = (x >> 10) == 0 ? 1 : 0;
+        field = (x >>> y) == 0 ? 1 : 0;
+        field = (x >> y) == 0 ? 1 : 0;
+        field = (x << y) == 0 ? 1 : 0;
+        field = (x >>> y) == 1 ? 1 : 0;
+        field = (x >> y) == 1 ? 1 : 0;
+        field = (x << y) == 1 ? 1 : 0;
+    }
+
+    public static void testShiftEqualsReference(int x, int[] array, int y) {
+        field = (x & 0xfffffc00) == 0 ? 1 : 0;
+        field = (array.length & 0xfffffc00) == 0 ? 1 : 0;
+        field = (x & 0x3fffff) == 0 ? 1 : 0;
+        // don't optimize signed right shifts
+        field = (x >> 10) == 0 ? 1 : 0;
+        // don't optimize no-constant shift amounts
+        field = (x >>> y) == 0 ? 1 : 0;
+        field = (x >> y) == 0 ? 1 : 0;
+        field = (x << y) == 0 ? 1 : 0;
+        // don't optimize non-zero comparisons
+        field = (x >>> y) == 1 ? 1 : 0;
+        field = (x >> y) == 1 ? 1 : 0;
+        field = (x << y) == 1 ? 1 : 0;
+    }
+
+    @Test
+    public void testCompare() {
+        test("testCompareSnippet", "testCompareReference");
+    }
+
+    public static void testCompareSnippet(int x, int y, int[] array1, int[] array2) {
+        int tempX = x;
+        int array1Length = array1.length;
+        int array2Length = array2.length;
+        // optimize
+        field = x == tempX ? 1 : 0;
+        field = x != tempX ? 1 : 0;
+        field = array1Length != (-1 - array2Length) ? 1 : 0;
+        field = array1Length == (-1 - array2Length) ? 1 : 0;
+        // don't optimize
+        field = x == y ? 1 : 0;
+        field = array1Length == array2Length ? 1 : 0;
+        field = array1Length == (-array2Length) ? 1 : 0;
+    }
+
+    public static void testCompareReference(int x, int y, int[] array1, int[] array2) {
+        int array1Length = array1.length;
+        int array2Length = array2.length;
+        // optimize
+        field = 1;
+        field = 0;
+        field = 1;
+        field = 0;
+        // don't optimize (overlapping value ranges)
+        field = x == y ? 1 : 0;
+        field = array1Length == array2Length ? 1 : 0;
+        field = array1Length == (-array2Length) ? 1 : 0;
+    }
+
+    private void test(String snippet, String referenceSnippet) {
+        StructuredGraph graph = getCanonicalizedGraph(snippet);
+        StructuredGraph referenceGraph = getCanonicalizedGraph(referenceSnippet);
+        assertEquals(referenceGraph, graph);
+    }
+
+    private StructuredGraph getCanonicalizedGraph(String snippet) {
+        StructuredGraph graph = parse(snippet);
+        new CanonicalizerPhase(false).apply(graph, new PhaseContext(getProviders(), null));
+        for (FrameState state : graph.getNodes(FrameState.class).snapshot()) {
+            state.replaceAtUsages(null);
+            state.safeDelete();
+        }
+        return graph;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/MemoryArithmeticTest.java	Wed Mar 26 20:44:11 2014 +0100
@@ -0,0 +1,4333 @@
+/*
+ * 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 java.lang.reflect.*;
+
+import org.junit.*;
+
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.nodes.*;
+
+public class MemoryArithmeticTest extends GraalCompilerTest {
+
+    @Override
+    protected InstalledCode getCode(ResolvedJavaMethod method, StructuredGraph graph) {
+        return super.getCode(method, graph, true);
+    }
+
+    /**
+     * Called before a test is executed.
+     */
+    @Override
+    protected void before(Method method) {
+        // don't let any null exception tracking change the generated code.
+        getMetaAccess().lookupJavaMethod(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);
+    }
+}