Mercurial > hg > truffle
changeset 14718:25359cbb95e3
don't do subword float converts
| author | Tom Rodriguez <tom.rodriguez@oracle.com> |
|---|---|
| date | Fri, 21 Mar 2014 15:28:37 -0700 |
| parents | aa1a43bfdf4e |
| children | 0bdd0d157040 |
| files | graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/MemoryArithmeticTest.java graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatConvertNode.java |
| diffstat | 2 files changed, 2814 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/MemoryArithmeticTest.java Fri Mar 21 14:26:58 2014 -0700 +++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/MemoryArithmeticTest.java Fri Mar 21 15:28:37 2014 -0700 @@ -63,6 +63,9 @@ 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; @@ -83,6 +86,18 @@ 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; @@ -117,6 +132,16 @@ 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; @@ -151,6 +176,368 @@ 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; @@ -185,6 +572,368 @@ 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; @@ -219,6 +968,368 @@ 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; @@ -253,6 +1364,368 @@ 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; @@ -287,6 +1760,368 @@ 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; @@ -321,6 +2156,368 @@ 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; @@ -355,6 +2552,368 @@ 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; @@ -389,6 +2948,16 @@ 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; } @@ -1522,4 +4091,243 @@ 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); + } }
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatConvertNode.java Fri Mar 21 14:26:58 2014 -0700 +++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/calc/FloatConvertNode.java Fri Mar 21 15:28:37 2014 -0700 @@ -197,6 +197,12 @@ } public boolean generate(MemoryArithmeticLIRLowerer gen, Access access) { + Kind kind = access.nullCheckLocation().getValueKind(); + if (kind != kind.getStackKind()) { + // Doesn't work for subword operations + return false; + } + Value result = gen.emitFloatConvertMemory(getOp(), access); if (result != null) { gen.setResult(this, result);