MemoryArithmeticTest (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.test.GraalTest
- - com.oracle.graal.compiler.test.GraalCompilerTest
  - - com.oracle.graal.compiler.test.MemoryArithmeticTest

public class MemoryArithmeticTest
extends GraalCompilerTest

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

(package private) static class MemoryArithmeticTest.FieldObject
- Nested classes/interfaces inherited from class com.oracle.graal.compiler.test.GraalCompilerTest
  GraalCompilerTest.ArgSupplier, GraalCompilerTest.Result
- Nested classes/interfaces inherited from class com.oracle.graal.test.GraalTest
  GraalTest.MultiCauseAssertionError

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`MemoryArithmeticTest.FieldObject`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static boolean`	`booleanTestValue1`
`(package private) static boolean`	`booleanTestValue2`
`(package private) static byte`	`byteTestValue1`
`(package private) static byte`	`byteTestValue2`
`(package private) static char`	`charTestValue1`
`(package private) static char`	`charTestValue2`
`protected static int`	`count` A dummy field used by some tests to create side effects.
`(package private) static double`	`doubleTestValue1`
`(package private) static double`	`doubleTestValue2`
`(package private) static float`	`floatTestValue1`
`(package private) static float`	`floatTestValue2`
`(package private) static int`	`intTestValue1`
`(package private) static int`	`intTestValue2`
`(package private) static long`	`longTestValue1`
`(package private) static long`	`longTestValue2`
`(package private) static MemoryArithmeticTest.FieldObject`	`maxObject`
`(package private) static MemoryArithmeticTest.FieldObject`	`minObject`
`(package private) static Object`	`objectTestValue1`
`(package private) static Object`	`objectTestValue2`
`(package private) static short`	`shortTestValue1`
`(package private) static short`	`shortTestValue2`

Fields inherited from class com.oracle.graal.compiler.test.GraalCompilerTest
lastCompiledGraph

Constructor Summary

Constructors
Constructor and Description

MemoryArithmeticTest()

Constructors
Constructor and Description
`MemoryArithmeticTest()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`before(ResolvedJavaMethod method)` Called before a test is executed.
`static double`	`doConvertByteDouble(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertByteFloat(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertByteInt(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertByteLong(MemoryArithmeticTest.FieldObject f)`
`static double`	`doConvertCharDouble(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertCharFloat(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertCharInt(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertCharLong(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertDoubleFloat(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertDoubleInt(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertDoubleLong(MemoryArithmeticTest.FieldObject f)`
`static double`	`doConvertFloatDouble(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertFloatInt(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertFloatLong(MemoryArithmeticTest.FieldObject f)`
`static double`	`doConvertIntDouble(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertIntFloat(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertIntLong(MemoryArithmeticTest.FieldObject f)`
`static double`	`doConvertLongDouble(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertLongFloat(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertLongInt(MemoryArithmeticTest.FieldObject f)`
`static double`	`doConvertShortDouble(MemoryArithmeticTest.FieldObject f)`
`static float`	`doConvertShortFloat(MemoryArithmeticTest.FieldObject f)`
`static int`	`doConvertShortInt(MemoryArithmeticTest.FieldObject f)`
`static long`	`doConvertShortLong(MemoryArithmeticTest.FieldObject f)`
`protected InstalledCode`	`getCode(ResolvedJavaMethod method, StructuredGraph graph)` Gets installed code for a given method, compiling it first if necessary.
`static Object`	`testBooleanCompare(MemoryArithmeticTest.FieldObject f, boolean booleanValue)`
`static Object`	`testBooleanCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testBooleanCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testBooleanCompares()`
`void`	`testBooleanNullCompares()`
`void`	`testBooleanNullCompares1()`
`void`	`testBooleanNullCompares2()`
`static int`	`testByteAdd(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteAdds()`
`static int`	`testByteAnd(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteAndConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteAndConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteAnds()`
`static Object`	`testByteCompare(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareGreater(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareLess(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareLessEqual(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteCompares()`
`void`	`testByteComparesGreater()`
`void`	`testByteComparesGreaterEqual()`
`void`	`testByteComparesLess()`
`void`	`testByteComparesLessEqual()`
`static int`	`testByteDiv(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteDivs()`
`static int`	`testByteMul(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteMuls()`
`void`	`testByteNullAdd()`
`void`	`testByteNullAnd()`
`void`	`testByteNullCompares()`
`void`	`testByteNullCompares1()`
`void`	`testByteNullCompares2()`
`void`	`testByteNullComparesGreater()`
`void`	`testByteNullComparesGreater1()`
`void`	`testByteNullComparesGreater2()`
`void`	`testByteNullComparesGreaterEqual()`
`void`	`testByteNullComparesGreaterEqual1()`
`void`	`testByteNullComparesGreaterEqual2()`
`void`	`testByteNullComparesLess()`
`void`	`testByteNullComparesLess1()`
`void`	`testByteNullComparesLess2()`
`void`	`testByteNullComparesLessEqual()`
`void`	`testByteNullComparesLessEqual1()`
`void`	`testByteNullComparesLessEqual2()`
`void`	`testByteNullDiv()`
`void`	`testByteNullMul()`
`void`	`testByteNullOr()`
`void`	`testByteNullSub()`
`void`	`testByteNullSwappedComparesGreater()`
`void`	`testByteNullSwappedComparesGreater1()`
`void`	`testByteNullSwappedComparesGreater2()`
`void`	`testByteNullSwappedComparesGreaterEqual()`
`void`	`testByteNullSwappedComparesGreaterEqual1()`
`void`	`testByteNullSwappedComparesGreaterEqual2()`
`void`	`testByteNullSwappedComparesLess()`
`void`	`testByteNullSwappedComparesLess1()`
`void`	`testByteNullSwappedComparesLess2()`
`void`	`testByteNullSwappedComparesLessEqual()`
`void`	`testByteNullSwappedComparesLessEqual1()`
`void`	`testByteNullSwappedComparesLessEqual2()`
`void`	`testByteNullXor()`
`static int`	`testByteOr(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteOrConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteOrConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteOrs()`
`static int`	`testByteSub(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteSubs()`
`static Object`	`testByteSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareLess(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static Object`	`testByteSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testByteSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteSwappedComparesGreater()`
`void`	`testByteSwappedComparesGreaterEqual()`
`void`	`testByteSwappedComparesLess()`
`void`	`testByteSwappedComparesLessEqual()`
`static int`	`testByteXor(MemoryArithmeticTest.FieldObject f, byte byteValue)`
`static int`	`testByteXorConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testByteXorConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testByteXors()`
`static int`	`testCharAdd(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharAdds()`
`static int`	`testCharAnd(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharAndConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharAndConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharAnds()`
`static Object`	`testCharCompare(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareGreater(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareLess(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareLessEqual(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharCompares()`
`void`	`testCharComparesGreater()`
`void`	`testCharComparesGreaterEqual()`
`void`	`testCharComparesLess()`
`void`	`testCharComparesLessEqual()`
`static int`	`testCharDiv(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharDivs()`
`static int`	`testCharMul(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharMuls()`
`void`	`testCharNullAdd()`
`void`	`testCharNullAnd()`
`void`	`testCharNullCompares()`
`void`	`testCharNullCompares1()`
`void`	`testCharNullCompares2()`
`void`	`testCharNullComparesGreater()`
`void`	`testCharNullComparesGreater1()`
`void`	`testCharNullComparesGreater2()`
`void`	`testCharNullComparesGreaterEqual()`
`void`	`testCharNullComparesGreaterEqual1()`
`void`	`testCharNullComparesGreaterEqual2()`
`void`	`testCharNullComparesLess()`
`void`	`testCharNullComparesLess1()`
`void`	`testCharNullComparesLess2()`
`void`	`testCharNullComparesLessEqual()`
`void`	`testCharNullComparesLessEqual1()`
`void`	`testCharNullComparesLessEqual2()`
`void`	`testCharNullDiv()`
`void`	`testCharNullMul()`
`void`	`testCharNullOr()`
`void`	`testCharNullSub()`
`void`	`testCharNullSwappedComparesGreater()`
`void`	`testCharNullSwappedComparesGreater1()`
`void`	`testCharNullSwappedComparesGreater2()`
`void`	`testCharNullSwappedComparesGreaterEqual()`
`void`	`testCharNullSwappedComparesGreaterEqual1()`
`void`	`testCharNullSwappedComparesGreaterEqual2()`
`void`	`testCharNullSwappedComparesLess()`
`void`	`testCharNullSwappedComparesLess1()`
`void`	`testCharNullSwappedComparesLess2()`
`void`	`testCharNullSwappedComparesLessEqual()`
`void`	`testCharNullSwappedComparesLessEqual1()`
`void`	`testCharNullSwappedComparesLessEqual2()`
`void`	`testCharNullXor()`
`static int`	`testCharOr(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharOrConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharOrConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharOrs()`
`static int`	`testCharSub(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharSubs()`
`static Object`	`testCharSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareLess(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, char charValue)`
`static Object`	`testCharSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testCharSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharSwappedComparesGreater()`
`void`	`testCharSwappedComparesGreaterEqual()`
`void`	`testCharSwappedComparesLess()`
`void`	`testCharSwappedComparesLessEqual()`
`static int`	`testCharXor(MemoryArithmeticTest.FieldObject f, char charValue)`
`static int`	`testCharXorConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testCharXorConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testCharXors()`
`void`	`testConvertByteDouble()`
`void`	`testConvertByteFloat()`
`void`	`testConvertByteInt()`
`void`	`testConvertByteLong()`
`void`	`testConvertCharDouble()`
`void`	`testConvertCharFloat()`
`void`	`testConvertCharInt()`
`void`	`testConvertCharLong()`
`void`	`testConvertDoubleFloat()`
`void`	`testConvertDoubleInt()`
`void`	`testConvertDoubleLong()`
`void`	`testConvertFloatDouble()`
`void`	`testConvertFloatInt()`
`void`	`testConvertFloatLong()`
`void`	`testConvertIntDouble()`
`void`	`testConvertIntFloat()`
`void`	`testConvertIntLong()`
`void`	`testConvertLongDouble()`
`void`	`testConvertLongFloat()`
`void`	`testConvertLongInt()`
`void`	`testConvertShortDouble()`
`void`	`testConvertShortFloat()`
`void`	`testConvertShortInt()`
`void`	`testConvertShortLong()`
`static double`	`testDoubleAdd(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static double`	`testDoubleAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static double`	`testDoubleAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleAdds()`
`static Object`	`testDoubleCompare(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareGreater(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareLess(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareLessEqual(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleCompares()`
`void`	`testDoubleComparesGreater()`
`void`	`testDoubleComparesGreaterEqual()`
`void`	`testDoubleComparesLess()`
`void`	`testDoubleComparesLessEqual()`
`static double`	`testDoubleDiv(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static double`	`testDoubleDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static double`	`testDoubleDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleDivs()`
`static double`	`testDoubleMul(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static double`	`testDoubleMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static double`	`testDoubleMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleMuls()`
`void`	`testDoubleNullAdd()`
`void`	`testDoubleNullCompares()`
`void`	`testDoubleNullCompares1()`
`void`	`testDoubleNullCompares2()`
`void`	`testDoubleNullComparesGreater()`
`void`	`testDoubleNullComparesGreater1()`
`void`	`testDoubleNullComparesGreater2()`
`void`	`testDoubleNullComparesGreaterEqual()`
`void`	`testDoubleNullComparesGreaterEqual1()`
`void`	`testDoubleNullComparesGreaterEqual2()`
`void`	`testDoubleNullComparesLess()`
`void`	`testDoubleNullComparesLess1()`
`void`	`testDoubleNullComparesLess2()`
`void`	`testDoubleNullComparesLessEqual()`
`void`	`testDoubleNullComparesLessEqual1()`
`void`	`testDoubleNullComparesLessEqual2()`
`void`	`testDoubleNullDiv()`
`void`	`testDoubleNullMul()`
`void`	`testDoubleNullSub()`
`void`	`testDoubleNullSwappedComparesGreater()`
`void`	`testDoubleNullSwappedComparesGreater1()`
`void`	`testDoubleNullSwappedComparesGreater2()`
`void`	`testDoubleNullSwappedComparesGreaterEqual()`
`void`	`testDoubleNullSwappedComparesGreaterEqual1()`
`void`	`testDoubleNullSwappedComparesGreaterEqual2()`
`void`	`testDoubleNullSwappedComparesLess()`
`void`	`testDoubleNullSwappedComparesLess1()`
`void`	`testDoubleNullSwappedComparesLess2()`
`void`	`testDoubleNullSwappedComparesLessEqual()`
`void`	`testDoubleNullSwappedComparesLessEqual1()`
`void`	`testDoubleNullSwappedComparesLessEqual2()`
`static double`	`testDoubleSub(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static double`	`testDoubleSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static double`	`testDoubleSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleSubs()`
`static Object`	`testDoubleSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareLess(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, double doubleValue)`
`static Object`	`testDoubleSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testDoubleSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testDoubleSwappedComparesGreater()`
`void`	`testDoubleSwappedComparesGreaterEqual()`
`void`	`testDoubleSwappedComparesLess()`
`void`	`testDoubleSwappedComparesLessEqual()`
`static float`	`testFloatAdd(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static float`	`testFloatAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static float`	`testFloatAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatAdds()`
`static Object`	`testFloatCompare(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareGreater(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareLess(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareLessEqual(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatCompares()`
`void`	`testFloatComparesGreater()`
`void`	`testFloatComparesGreaterEqual()`
`void`	`testFloatComparesLess()`
`void`	`testFloatComparesLessEqual()`
`static float`	`testFloatDiv(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static float`	`testFloatDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static float`	`testFloatDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatDivs()`
`static float`	`testFloatMul(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static float`	`testFloatMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static float`	`testFloatMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatMuls()`
`void`	`testFloatNullAdd()`
`void`	`testFloatNullCompares()`
`void`	`testFloatNullCompares1()`
`void`	`testFloatNullCompares2()`
`void`	`testFloatNullComparesGreater()`
`void`	`testFloatNullComparesGreater1()`
`void`	`testFloatNullComparesGreater2()`
`void`	`testFloatNullComparesGreaterEqual()`
`void`	`testFloatNullComparesGreaterEqual1()`
`void`	`testFloatNullComparesGreaterEqual2()`
`void`	`testFloatNullComparesLess()`
`void`	`testFloatNullComparesLess1()`
`void`	`testFloatNullComparesLess2()`
`void`	`testFloatNullComparesLessEqual()`
`void`	`testFloatNullComparesLessEqual1()`
`void`	`testFloatNullComparesLessEqual2()`
`void`	`testFloatNullDiv()`
`void`	`testFloatNullMul()`
`void`	`testFloatNullSub()`
`void`	`testFloatNullSwappedComparesGreater()`
`void`	`testFloatNullSwappedComparesGreater1()`
`void`	`testFloatNullSwappedComparesGreater2()`
`void`	`testFloatNullSwappedComparesGreaterEqual()`
`void`	`testFloatNullSwappedComparesGreaterEqual1()`
`void`	`testFloatNullSwappedComparesGreaterEqual2()`
`void`	`testFloatNullSwappedComparesLess()`
`void`	`testFloatNullSwappedComparesLess1()`
`void`	`testFloatNullSwappedComparesLess2()`
`void`	`testFloatNullSwappedComparesLessEqual()`
`void`	`testFloatNullSwappedComparesLessEqual1()`
`void`	`testFloatNullSwappedComparesLessEqual2()`
`static float`	`testFloatSub(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static float`	`testFloatSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static float`	`testFloatSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatSubs()`
`static Object`	`testFloatSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareLess(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, float floatValue)`
`static Object`	`testFloatSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testFloatSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testFloatSwappedComparesGreater()`
`void`	`testFloatSwappedComparesGreaterEqual()`
`void`	`testFloatSwappedComparesLess()`
`void`	`testFloatSwappedComparesLessEqual()`
`static int`	`testIntAdd(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntAdds()`
`static int`	`testIntAnd(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntAndConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntAndConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntAnds()`
`static Object`	`testIntCompare(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareGreater(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareLess(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareLessEqual(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntCompares()`
`void`	`testIntComparesGreater()`
`void`	`testIntComparesGreaterEqual()`
`void`	`testIntComparesLess()`
`void`	`testIntComparesLessEqual()`
`static int`	`testIntDiv(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntDivs()`
`static boolean`	`testIntMask(MemoryArithmeticTest.FieldObject f, int intValue)`
`static boolean`	`testIntMaskConstant1(MemoryArithmeticTest.FieldObject f)`
`static boolean`	`testIntMaskConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntMasks()`
`static int`	`testIntMul(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntMuls()`
`void`	`testIntNullAdd()`
`void`	`testIntNullAnd()`
`void`	`testIntNullCompares()`
`void`	`testIntNullCompares1()`
`void`	`testIntNullCompares2()`
`void`	`testIntNullComparesGreater()`
`void`	`testIntNullComparesGreater1()`
`void`	`testIntNullComparesGreater2()`
`void`	`testIntNullComparesGreaterEqual()`
`void`	`testIntNullComparesGreaterEqual1()`
`void`	`testIntNullComparesGreaterEqual2()`
`void`	`testIntNullComparesLess()`
`void`	`testIntNullComparesLess1()`
`void`	`testIntNullComparesLess2()`
`void`	`testIntNullComparesLessEqual()`
`void`	`testIntNullComparesLessEqual1()`
`void`	`testIntNullComparesLessEqual2()`
`void`	`testIntNullDiv()`
`void`	`testIntNullMask()`
`void`	`testIntNullMul()`
`void`	`testIntNullOr()`
`void`	`testIntNullSub()`
`void`	`testIntNullSwappedComparesGreater()`
`void`	`testIntNullSwappedComparesGreater1()`
`void`	`testIntNullSwappedComparesGreater2()`
`void`	`testIntNullSwappedComparesGreaterEqual()`
`void`	`testIntNullSwappedComparesGreaterEqual1()`
`void`	`testIntNullSwappedComparesGreaterEqual2()`
`void`	`testIntNullSwappedComparesLess()`
`void`	`testIntNullSwappedComparesLess1()`
`void`	`testIntNullSwappedComparesLess2()`
`void`	`testIntNullSwappedComparesLessEqual()`
`void`	`testIntNullSwappedComparesLessEqual1()`
`void`	`testIntNullSwappedComparesLessEqual2()`
`void`	`testIntNullXor()`
`static int`	`testIntOr(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntOrConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntOrConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntOrs()`
`static int`	`testIntSub(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntSubs()`
`static Object`	`testIntSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareLess(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, int intValue)`
`static Object`	`testIntSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testIntSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntSwappedComparesGreater()`
`void`	`testIntSwappedComparesGreaterEqual()`
`void`	`testIntSwappedComparesLess()`
`void`	`testIntSwappedComparesLessEqual()`
`static int`	`testIntXor(MemoryArithmeticTest.FieldObject f, int intValue)`
`static int`	`testIntXorConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testIntXorConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testIntXors()`
`static long`	`testLongAdd(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongAdds()`
`static long`	`testLongAnd(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongAndConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongAndConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongAnds()`
`static Object`	`testLongCompare(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareGreater(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareLess(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareLessEqual(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongCompares()`
`void`	`testLongComparesGreater()`
`void`	`testLongComparesGreaterEqual()`
`void`	`testLongComparesLess()`
`void`	`testLongComparesLessEqual()`
`static long`	`testLongDiv(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongDivs()`
`static boolean`	`testLongMask(MemoryArithmeticTest.FieldObject f, long longValue)`
`static boolean`	`testLongMaskConstant1(MemoryArithmeticTest.FieldObject f)`
`static boolean`	`testLongMaskConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongMasks()`
`static long`	`testLongMul(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongMuls()`
`void`	`testLongNullAdd()`
`void`	`testLongNullAnd()`
`void`	`testLongNullCompares()`
`void`	`testLongNullCompares1()`
`void`	`testLongNullCompares2()`
`void`	`testLongNullComparesGreater()`
`void`	`testLongNullComparesGreater1()`
`void`	`testLongNullComparesGreater2()`
`void`	`testLongNullComparesGreaterEqual()`
`void`	`testLongNullComparesGreaterEqual1()`
`void`	`testLongNullComparesGreaterEqual2()`
`void`	`testLongNullComparesLess()`
`void`	`testLongNullComparesLess1()`
`void`	`testLongNullComparesLess2()`
`void`	`testLongNullComparesLessEqual()`
`void`	`testLongNullComparesLessEqual1()`
`void`	`testLongNullComparesLessEqual2()`
`void`	`testLongNullDiv()`
`void`	`testLongNullMask()`
`void`	`testLongNullMul()`
`void`	`testLongNullOr()`
`void`	`testLongNullSub()`
`void`	`testLongNullSwappedComparesGreater()`
`void`	`testLongNullSwappedComparesGreater1()`
`void`	`testLongNullSwappedComparesGreater2()`
`void`	`testLongNullSwappedComparesGreaterEqual()`
`void`	`testLongNullSwappedComparesGreaterEqual1()`
`void`	`testLongNullSwappedComparesGreaterEqual2()`
`void`	`testLongNullSwappedComparesLess()`
`void`	`testLongNullSwappedComparesLess1()`
`void`	`testLongNullSwappedComparesLess2()`
`void`	`testLongNullSwappedComparesLessEqual()`
`void`	`testLongNullSwappedComparesLessEqual1()`
`void`	`testLongNullSwappedComparesLessEqual2()`
`void`	`testLongNullXor()`
`static long`	`testLongOr(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongOrConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongOrConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongOrs()`
`static long`	`testLongSub(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongSubs()`
`static Object`	`testLongSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareLess(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, long longValue)`
`static Object`	`testLongSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testLongSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongSwappedComparesGreater()`
`void`	`testLongSwappedComparesGreaterEqual()`
`void`	`testLongSwappedComparesLess()`
`void`	`testLongSwappedComparesLessEqual()`
`static long`	`testLongXor(MemoryArithmeticTest.FieldObject f, long longValue)`
`static long`	`testLongXorConstant1(MemoryArithmeticTest.FieldObject f)`
`static long`	`testLongXorConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testLongXors()`
`static Object`	`testObjectCompare(MemoryArithmeticTest.FieldObject f, Object objectValue)`
`static Object`	`testObjectCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testObjectCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testObjectCompares()`
`void`	`testObjectNullCompares()`
`void`	`testObjectNullCompares1()`
`void`	`testObjectNullCompares2()`
`static int`	`testShortAdd(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortAddConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortAddConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortAdds()`
`static int`	`testShortAnd(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortAndConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortAndConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortAnds()`
`static Object`	`testShortCompare(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortCompareConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareGreater(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareLess(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareLessEqual(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortCompares()`
`void`	`testShortComparesGreater()`
`void`	`testShortComparesGreaterEqual()`
`void`	`testShortComparesLess()`
`void`	`testShortComparesLessEqual()`
`static int`	`testShortDiv(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortDivConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortDivConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortDivs()`
`static int`	`testShortMul(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortMulConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortMulConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortMuls()`
`void`	`testShortNullAdd()`
`void`	`testShortNullAnd()`
`void`	`testShortNullCompares()`
`void`	`testShortNullCompares1()`
`void`	`testShortNullCompares2()`
`void`	`testShortNullComparesGreater()`
`void`	`testShortNullComparesGreater1()`
`void`	`testShortNullComparesGreater2()`
`void`	`testShortNullComparesGreaterEqual()`
`void`	`testShortNullComparesGreaterEqual1()`
`void`	`testShortNullComparesGreaterEqual2()`
`void`	`testShortNullComparesLess()`
`void`	`testShortNullComparesLess1()`
`void`	`testShortNullComparesLess2()`
`void`	`testShortNullComparesLessEqual()`
`void`	`testShortNullComparesLessEqual1()`
`void`	`testShortNullComparesLessEqual2()`
`void`	`testShortNullDiv()`
`void`	`testShortNullMul()`
`void`	`testShortNullOr()`
`void`	`testShortNullSub()`
`void`	`testShortNullSwappedComparesGreater()`
`void`	`testShortNullSwappedComparesGreater1()`
`void`	`testShortNullSwappedComparesGreater2()`
`void`	`testShortNullSwappedComparesGreaterEqual()`
`void`	`testShortNullSwappedComparesGreaterEqual1()`
`void`	`testShortNullSwappedComparesGreaterEqual2()`
`void`	`testShortNullSwappedComparesLess()`
`void`	`testShortNullSwappedComparesLess1()`
`void`	`testShortNullSwappedComparesLess2()`
`void`	`testShortNullSwappedComparesLessEqual()`
`void`	`testShortNullSwappedComparesLessEqual1()`
`void`	`testShortNullSwappedComparesLessEqual2()`
`void`	`testShortNullXor()`
`static int`	`testShortOr(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortOrConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortOrConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortOrs()`
`static int`	`testShortSub(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortSubConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortSubConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortSubs()`
`static Object`	`testShortSwappedCompareGreater(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareLess(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static Object`	`testShortSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)`
`static Object`	`testShortSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortSwappedComparesGreater()`
`void`	`testShortSwappedComparesGreaterEqual()`
`void`	`testShortSwappedComparesLess()`
`void`	`testShortSwappedComparesLessEqual()`
`static int`	`testShortXor(MemoryArithmeticTest.FieldObject f, short shortValue)`
`static int`	`testShortXorConstant1(MemoryArithmeticTest.FieldObject f)`
`static int`	`testShortXorConstant2(MemoryArithmeticTest.FieldObject f)`
`void`	`testShortXors()`

Methods inherited from class com.oracle.graal.compiler.test.GraalCompilerTest
addMethod, after, afterTest, applyArgSuppliers, argsWithReceiver, asResolvedJavaMethod, assertConstantReturn, assertEquals, assertEquals, assertEquals, beforeTest, branchProbability, breakpoint, breakpoint, checkArgs, checkHighTierGraph, checkLowTierGraph, checkMidTierGraph, compile, countUnusedConstants, createLIRSuites, createSuites, editGraphBuilderConfiguration, executeActual, executeActualCheckDeopt, executeExpected, getBackend, getCanonicalGraphString, getCode, getCode, getCodeCache, getConstantReflection, getCustomGraphBuilderSuite, getDefaultGraphBuilderPlugins, getDefaultGraphBuilderSuite, getDefaultHighTierContext, getLIRSuites, getLowerer, getMetaAccess, getNodeCountExcludingUnusedConstants, getProviders, getReplacements, getResolvedJavaMethod, getResolvedJavaMethod, getResolvedJavaMethod, getSnippetReflection, getSpeculationLog, getSuites, getTarget, initializeDebugging, invoke, isArchitecture, iterationCount, lookupMethod, parseDebug, parseEager, parseEager, parseForCompile, parseProfiled, parseProfiled, referenceInvoke, supply, test, test, testAgainstExpected, testAgainstExpected, testN

Methods inherited from class com.oracle.graal.test.GraalTest
assertDeepEquals, assertDeepEquals, assertDeepEquals, assertDeepEquals, assertFalse, assertFalse, assertFalse, assertTrue, assertTrue, assertTrue, equalFloatsOrDoublesDelta, fail, getMethod, getMethod, getMethod, ulpsDelta

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- count
```
protected static int count
```
  A dummy field used by some tests to create side effects.
- maxObject
```
static MemoryArithmeticTest.FieldObject maxObject
```
- minObject
```
static MemoryArithmeticTest.FieldObject minObject
```
- booleanTestValue1
```
static final boolean booleanTestValue1
```
  See Also:
  
  Constant Field Values
- byteTestValue1
```
static final byte byteTestValue1
```
  See Also:
  
  Constant Field Values
- shortTestValue1
```
static final short shortTestValue1
```
  See Also:
  
  Constant Field Values
- charTestValue1
```
static final char charTestValue1
```
  See Also:
  
  Constant Field Values
- intTestValue1
```
static final int intTestValue1
```
  See Also:
  
  Constant Field Values
- floatTestValue1
```
static final float floatTestValue1
```
  See Also:
  
  Constant Field Values
- longTestValue1
```
static final long longTestValue1
```
  See Also:
  
  Constant Field Values
- doubleTestValue1
```
static final double doubleTestValue1
```
  See Also:
  
  Constant Field Values
- objectTestValue1
```
static final Object objectTestValue1
```
- booleanTestValue2
```
static final boolean booleanTestValue2
```
  See Also:
  
  Constant Field Values
- byteTestValue2
```
static final byte byteTestValue2
```
  See Also:
  
  Constant Field Values
- shortTestValue2
```
static final short shortTestValue2
```
  See Also:
  
  Constant Field Values
- charTestValue2
```
static final char charTestValue2
```
  See Also:
  
  Constant Field Values
- intTestValue2
```
static final int intTestValue2
```
  See Also:
  
  Constant Field Values
- floatTestValue2
```
static final float floatTestValue2
```
  See Also:
  
  Constant Field Values
- longTestValue2
```
static final long longTestValue2
```
  See Also:
  
  Constant Field Values
- doubleTestValue2
```
static final double doubleTestValue2
```
  See Also:
  
  Constant Field Values
- objectTestValue2
```
static final Object objectTestValue2
```

Constructor Detail
- MemoryArithmeticTest
```
public MemoryArithmeticTest()
```

Method Detail

getCode
```
protected InstalledCode getCode(ResolvedJavaMethod method,
                                StructuredGraph graph)
```
Description copied from class: GraalCompilerTest

Gets installed code for a given method, compiling it first if necessary.

Overrides:

getCode in class GraalCompilerTest

Parameters:

method - the method the compiled code will be associated with when installed

graph - the graph to be compiled. If null, a graph will be obtained from installedCodeOwner via GraalCompilerTest.parseForCompile(ResolvedJavaMethod).

before
```
protected void before(ResolvedJavaMethod method)
```
Called before a test is executed.

Overrides:

before in class GraalCompilerTest

testBooleanCompare

public static Object testBooleanCompare(MemoryArithmeticTest.FieldObject f,
                                        boolean booleanValue)

testBooleanCompareConstant1

public static Object testBooleanCompareConstant1(MemoryArithmeticTest.FieldObject f)

testBooleanCompareConstant2

public static Object testBooleanCompareConstant2(MemoryArithmeticTest.FieldObject f)

testBooleanCompares
```
public void testBooleanCompares()
```

testBooleanNullCompares
```
public void testBooleanNullCompares()
```

testBooleanNullCompares1

public void testBooleanNullCompares1()

testBooleanNullCompares2

public void testBooleanNullCompares2()

testByteCompare

public static Object testByteCompare(MemoryArithmeticTest.FieldObject f,
                                     byte byteValue)

testByteCompareConstant1

public static Object testByteCompareConstant1(MemoryArithmeticTest.FieldObject f)

testByteCompareConstant2

public static Object testByteCompareConstant2(MemoryArithmeticTest.FieldObject f)

testByteCompares
```
public void testByteCompares()
```

testByteNullCompares
```
public void testByteNullCompares()
```

testByteNullCompares1
```
public void testByteNullCompares1()
```

testByteNullCompares2
```
public void testByteNullCompares2()
```

testByteCompareLess

public static Object testByteCompareLess(MemoryArithmeticTest.FieldObject f,
                                         byte byteValue)

testByteCompareLessConstant1

public static Object testByteCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testByteCompareLessConstant2

public static Object testByteCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testByteComparesLess
```
public void testByteComparesLess()
```

testByteNullComparesLess

public void testByteNullComparesLess()

testByteNullComparesLess1

public void testByteNullComparesLess1()

testByteNullComparesLess2

public void testByteNullComparesLess2()

testByteSwappedCompareLess

public static Object testByteSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                byte byteValue)

testByteSwappedCompareLessConstant1

public static Object testByteSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testByteSwappedCompareLessConstant2

public static Object testByteSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testByteSwappedComparesLess

public void testByteSwappedComparesLess()

testByteNullSwappedComparesLess

public void testByteNullSwappedComparesLess()

testByteNullSwappedComparesLess1

public void testByteNullSwappedComparesLess1()

testByteNullSwappedComparesLess2

public void testByteNullSwappedComparesLess2()

testByteCompareLessEqual

public static Object testByteCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                              byte byteValue)

testByteCompareLessEqualConstant1

public static Object testByteCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testByteCompareLessEqualConstant2

public static Object testByteCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testByteComparesLessEqual

public void testByteComparesLessEqual()

testByteNullComparesLessEqual

public void testByteNullComparesLessEqual()

testByteNullComparesLessEqual1

public void testByteNullComparesLessEqual1()

testByteNullComparesLessEqual2

public void testByteNullComparesLessEqual2()

testByteSwappedCompareLessEqual

public static Object testByteSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                     byte byteValue)

testByteSwappedCompareLessEqualConstant1

public static Object testByteSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testByteSwappedCompareLessEqualConstant2

public static Object testByteSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testByteSwappedComparesLessEqual

public void testByteSwappedComparesLessEqual()

testByteNullSwappedComparesLessEqual

public void testByteNullSwappedComparesLessEqual()

testByteNullSwappedComparesLessEqual1

public void testByteNullSwappedComparesLessEqual1()

testByteNullSwappedComparesLessEqual2

public void testByteNullSwappedComparesLessEqual2()

testByteCompareGreater

public static Object testByteCompareGreater(MemoryArithmeticTest.FieldObject f,
                                            byte byteValue)

testByteCompareGreaterConstant1

public static Object testByteCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testByteCompareGreaterConstant2

public static Object testByteCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testByteComparesGreater
```
public void testByteComparesGreater()
```

testByteNullComparesGreater

public void testByteNullComparesGreater()

testByteNullComparesGreater1

public void testByteNullComparesGreater1()

testByteNullComparesGreater2

public void testByteNullComparesGreater2()

testByteSwappedCompareGreater

public static Object testByteSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                   byte byteValue)

testByteSwappedCompareGreaterConstant1

public static Object testByteSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testByteSwappedCompareGreaterConstant2

public static Object testByteSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testByteSwappedComparesGreater

public void testByteSwappedComparesGreater()

testByteNullSwappedComparesGreater

public void testByteNullSwappedComparesGreater()

testByteNullSwappedComparesGreater1

public void testByteNullSwappedComparesGreater1()

testByteNullSwappedComparesGreater2

public void testByteNullSwappedComparesGreater2()

testByteCompareGreaterEqual

public static Object testByteCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                 byte byteValue)

testByteCompareGreaterEqualConstant1

public static Object testByteCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testByteCompareGreaterEqualConstant2

public static Object testByteCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testByteComparesGreaterEqual

public void testByteComparesGreaterEqual()

testByteNullComparesGreaterEqual

public void testByteNullComparesGreaterEqual()

testByteNullComparesGreaterEqual1

public void testByteNullComparesGreaterEqual1()

testByteNullComparesGreaterEqual2

public void testByteNullComparesGreaterEqual2()

testByteSwappedCompareGreaterEqual

public static Object testByteSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                        byte byteValue)

testByteSwappedCompareGreaterEqualConstant1

public static Object testByteSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testByteSwappedCompareGreaterEqualConstant2

public static Object testByteSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testByteSwappedComparesGreaterEqual

public void testByteSwappedComparesGreaterEqual()

testByteNullSwappedComparesGreaterEqual

public void testByteNullSwappedComparesGreaterEqual()

testByteNullSwappedComparesGreaterEqual1

public void testByteNullSwappedComparesGreaterEqual1()

testByteNullSwappedComparesGreaterEqual2

public void testByteNullSwappedComparesGreaterEqual2()

testShortCompare

public static Object testShortCompare(MemoryArithmeticTest.FieldObject f,
                                      short shortValue)

testShortCompareConstant1

public static Object testShortCompareConstant1(MemoryArithmeticTest.FieldObject f)

testShortCompareConstant2

public static Object testShortCompareConstant2(MemoryArithmeticTest.FieldObject f)

testShortCompares
```
public void testShortCompares()
```

testShortNullCompares
```
public void testShortNullCompares()
```

testShortNullCompares1
```
public void testShortNullCompares1()
```

testShortNullCompares2
```
public void testShortNullCompares2()
```

testShortCompareLess

public static Object testShortCompareLess(MemoryArithmeticTest.FieldObject f,
                                          short shortValue)

testShortCompareLessConstant1

public static Object testShortCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testShortCompareLessConstant2

public static Object testShortCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testShortComparesLess
```
public void testShortComparesLess()
```

testShortNullComparesLess

public void testShortNullComparesLess()

testShortNullComparesLess1

public void testShortNullComparesLess1()

testShortNullComparesLess2

public void testShortNullComparesLess2()

testShortSwappedCompareLess

public static Object testShortSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                 short shortValue)

testShortSwappedCompareLessConstant1

public static Object testShortSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testShortSwappedCompareLessConstant2

public static Object testShortSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testShortSwappedComparesLess

public void testShortSwappedComparesLess()

testShortNullSwappedComparesLess

public void testShortNullSwappedComparesLess()

testShortNullSwappedComparesLess1

public void testShortNullSwappedComparesLess1()

testShortNullSwappedComparesLess2

public void testShortNullSwappedComparesLess2()

testShortCompareLessEqual

public static Object testShortCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                               short shortValue)

testShortCompareLessEqualConstant1

public static Object testShortCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testShortCompareLessEqualConstant2

public static Object testShortCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testShortComparesLessEqual

public void testShortComparesLessEqual()

testShortNullComparesLessEqual

public void testShortNullComparesLessEqual()

testShortNullComparesLessEqual1

public void testShortNullComparesLessEqual1()

testShortNullComparesLessEqual2

public void testShortNullComparesLessEqual2()

testShortSwappedCompareLessEqual

public static Object testShortSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                      short shortValue)

testShortSwappedCompareLessEqualConstant1

public static Object testShortSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testShortSwappedCompareLessEqualConstant2

public static Object testShortSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testShortSwappedComparesLessEqual

public void testShortSwappedComparesLessEqual()

testShortNullSwappedComparesLessEqual

public void testShortNullSwappedComparesLessEqual()

testShortNullSwappedComparesLessEqual1

public void testShortNullSwappedComparesLessEqual1()

testShortNullSwappedComparesLessEqual2

public void testShortNullSwappedComparesLessEqual2()

testShortCompareGreater

public static Object testShortCompareGreater(MemoryArithmeticTest.FieldObject f,
                                             short shortValue)

testShortCompareGreaterConstant1

public static Object testShortCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testShortCompareGreaterConstant2

public static Object testShortCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testShortComparesGreater

public void testShortComparesGreater()

testShortNullComparesGreater

public void testShortNullComparesGreater()

testShortNullComparesGreater1

public void testShortNullComparesGreater1()

testShortNullComparesGreater2

public void testShortNullComparesGreater2()

testShortSwappedCompareGreater

public static Object testShortSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                    short shortValue)

testShortSwappedCompareGreaterConstant1

public static Object testShortSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testShortSwappedCompareGreaterConstant2

public static Object testShortSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testShortSwappedComparesGreater

public void testShortSwappedComparesGreater()

testShortNullSwappedComparesGreater

public void testShortNullSwappedComparesGreater()

testShortNullSwappedComparesGreater1

public void testShortNullSwappedComparesGreater1()

testShortNullSwappedComparesGreater2

public void testShortNullSwappedComparesGreater2()

testShortCompareGreaterEqual

public static Object testShortCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                  short shortValue)

testShortCompareGreaterEqualConstant1

public static Object testShortCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testShortCompareGreaterEqualConstant2

public static Object testShortCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testShortComparesGreaterEqual

public void testShortComparesGreaterEqual()

testShortNullComparesGreaterEqual

public void testShortNullComparesGreaterEqual()

testShortNullComparesGreaterEqual1

public void testShortNullComparesGreaterEqual1()

testShortNullComparesGreaterEqual2

public void testShortNullComparesGreaterEqual2()

testShortSwappedCompareGreaterEqual

public static Object testShortSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                         short shortValue)

testShortSwappedCompareGreaterEqualConstant1

public static Object testShortSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testShortSwappedCompareGreaterEqualConstant2

public static Object testShortSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testShortSwappedComparesGreaterEqual

public void testShortSwappedComparesGreaterEqual()

testShortNullSwappedComparesGreaterEqual

public void testShortNullSwappedComparesGreaterEqual()

testShortNullSwappedComparesGreaterEqual1

public void testShortNullSwappedComparesGreaterEqual1()

testShortNullSwappedComparesGreaterEqual2

public void testShortNullSwappedComparesGreaterEqual2()

testCharCompare

public static Object testCharCompare(MemoryArithmeticTest.FieldObject f,
                                     char charValue)

testCharCompareConstant1

public static Object testCharCompareConstant1(MemoryArithmeticTest.FieldObject f)

testCharCompareConstant2

public static Object testCharCompareConstant2(MemoryArithmeticTest.FieldObject f)

testCharCompares
```
public void testCharCompares()
```

testCharNullCompares
```
public void testCharNullCompares()
```

testCharNullCompares1
```
public void testCharNullCompares1()
```

testCharNullCompares2
```
public void testCharNullCompares2()
```

testCharCompareLess

public static Object testCharCompareLess(MemoryArithmeticTest.FieldObject f,
                                         char charValue)

testCharCompareLessConstant1

public static Object testCharCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testCharCompareLessConstant2

public static Object testCharCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testCharComparesLess
```
public void testCharComparesLess()
```

testCharNullComparesLess

public void testCharNullComparesLess()

testCharNullComparesLess1

public void testCharNullComparesLess1()

testCharNullComparesLess2

public void testCharNullComparesLess2()

testCharSwappedCompareLess

public static Object testCharSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                char charValue)

testCharSwappedCompareLessConstant1

public static Object testCharSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testCharSwappedCompareLessConstant2

public static Object testCharSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testCharSwappedComparesLess

public void testCharSwappedComparesLess()

testCharNullSwappedComparesLess

public void testCharNullSwappedComparesLess()

testCharNullSwappedComparesLess1

public void testCharNullSwappedComparesLess1()

testCharNullSwappedComparesLess2

public void testCharNullSwappedComparesLess2()

testCharCompareLessEqual

public static Object testCharCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                              char charValue)

testCharCompareLessEqualConstant1

public static Object testCharCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testCharCompareLessEqualConstant2

public static Object testCharCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testCharComparesLessEqual

public void testCharComparesLessEqual()

testCharNullComparesLessEqual

public void testCharNullComparesLessEqual()

testCharNullComparesLessEqual1

public void testCharNullComparesLessEqual1()

testCharNullComparesLessEqual2

public void testCharNullComparesLessEqual2()

testCharSwappedCompareLessEqual

public static Object testCharSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                     char charValue)

testCharSwappedCompareLessEqualConstant1

public static Object testCharSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testCharSwappedCompareLessEqualConstant2

public static Object testCharSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testCharSwappedComparesLessEqual

public void testCharSwappedComparesLessEqual()

testCharNullSwappedComparesLessEqual

public void testCharNullSwappedComparesLessEqual()

testCharNullSwappedComparesLessEqual1

public void testCharNullSwappedComparesLessEqual1()

testCharNullSwappedComparesLessEqual2

public void testCharNullSwappedComparesLessEqual2()

testCharCompareGreater

public static Object testCharCompareGreater(MemoryArithmeticTest.FieldObject f,
                                            char charValue)

testCharCompareGreaterConstant1

public static Object testCharCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testCharCompareGreaterConstant2

public static Object testCharCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testCharComparesGreater
```
public void testCharComparesGreater()
```

testCharNullComparesGreater

public void testCharNullComparesGreater()

testCharNullComparesGreater1

public void testCharNullComparesGreater1()

testCharNullComparesGreater2

public void testCharNullComparesGreater2()

testCharSwappedCompareGreater

public static Object testCharSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                   char charValue)

testCharSwappedCompareGreaterConstant1

public static Object testCharSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testCharSwappedCompareGreaterConstant2

public static Object testCharSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testCharSwappedComparesGreater

public void testCharSwappedComparesGreater()

testCharNullSwappedComparesGreater

public void testCharNullSwappedComparesGreater()

testCharNullSwappedComparesGreater1

public void testCharNullSwappedComparesGreater1()

testCharNullSwappedComparesGreater2

public void testCharNullSwappedComparesGreater2()

testCharCompareGreaterEqual

public static Object testCharCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                 char charValue)

testCharCompareGreaterEqualConstant1

public static Object testCharCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testCharCompareGreaterEqualConstant2

public static Object testCharCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testCharComparesGreaterEqual

public void testCharComparesGreaterEqual()

testCharNullComparesGreaterEqual

public void testCharNullComparesGreaterEqual()

testCharNullComparesGreaterEqual1

public void testCharNullComparesGreaterEqual1()

testCharNullComparesGreaterEqual2

public void testCharNullComparesGreaterEqual2()

testCharSwappedCompareGreaterEqual

public static Object testCharSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                        char charValue)

testCharSwappedCompareGreaterEqualConstant1

public static Object testCharSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testCharSwappedCompareGreaterEqualConstant2

public static Object testCharSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testCharSwappedComparesGreaterEqual

public void testCharSwappedComparesGreaterEqual()

testCharNullSwappedComparesGreaterEqual

public void testCharNullSwappedComparesGreaterEqual()

testCharNullSwappedComparesGreaterEqual1

public void testCharNullSwappedComparesGreaterEqual1()

testCharNullSwappedComparesGreaterEqual2

public void testCharNullSwappedComparesGreaterEqual2()

testIntCompare

public static Object testIntCompare(MemoryArithmeticTest.FieldObject f,
                                    int intValue)

testIntCompareConstant1

public static Object testIntCompareConstant1(MemoryArithmeticTest.FieldObject f)

testIntCompareConstant2

public static Object testIntCompareConstant2(MemoryArithmeticTest.FieldObject f)

testIntCompares
```
public void testIntCompares()
```

testIntNullCompares
```
public void testIntNullCompares()
```

testIntNullCompares1
```
public void testIntNullCompares1()
```

testIntNullCompares2
```
public void testIntNullCompares2()
```

testIntCompareLess

public static Object testIntCompareLess(MemoryArithmeticTest.FieldObject f,
                                        int intValue)

testIntCompareLessConstant1

public static Object testIntCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testIntCompareLessConstant2

public static Object testIntCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testIntComparesLess
```
public void testIntComparesLess()
```

testIntNullComparesLess
```
public void testIntNullComparesLess()
```

testIntNullComparesLess1

public void testIntNullComparesLess1()

testIntNullComparesLess2

public void testIntNullComparesLess2()

testIntSwappedCompareLess

public static Object testIntSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                               int intValue)

testIntSwappedCompareLessConstant1

public static Object testIntSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testIntSwappedCompareLessConstant2

public static Object testIntSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testIntSwappedComparesLess

public void testIntSwappedComparesLess()

testIntNullSwappedComparesLess

public void testIntNullSwappedComparesLess()

testIntNullSwappedComparesLess1

public void testIntNullSwappedComparesLess1()

testIntNullSwappedComparesLess2

public void testIntNullSwappedComparesLess2()

testIntCompareLessEqual

public static Object testIntCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                             int intValue)

testIntCompareLessEqualConstant1

public static Object testIntCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testIntCompareLessEqualConstant2

public static Object testIntCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testIntComparesLessEqual

public void testIntComparesLessEqual()

testIntNullComparesLessEqual

public void testIntNullComparesLessEqual()

testIntNullComparesLessEqual1

public void testIntNullComparesLessEqual1()

testIntNullComparesLessEqual2

public void testIntNullComparesLessEqual2()

testIntSwappedCompareLessEqual

public static Object testIntSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                    int intValue)

testIntSwappedCompareLessEqualConstant1

public static Object testIntSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testIntSwappedCompareLessEqualConstant2

public static Object testIntSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testIntSwappedComparesLessEqual

public void testIntSwappedComparesLessEqual()

testIntNullSwappedComparesLessEqual

public void testIntNullSwappedComparesLessEqual()

testIntNullSwappedComparesLessEqual1

public void testIntNullSwappedComparesLessEqual1()

testIntNullSwappedComparesLessEqual2

public void testIntNullSwappedComparesLessEqual2()

testIntCompareGreater

public static Object testIntCompareGreater(MemoryArithmeticTest.FieldObject f,
                                           int intValue)

testIntCompareGreaterConstant1

public static Object testIntCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testIntCompareGreaterConstant2

public static Object testIntCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testIntComparesGreater
```
public void testIntComparesGreater()
```

testIntNullComparesGreater

public void testIntNullComparesGreater()

testIntNullComparesGreater1

public void testIntNullComparesGreater1()

testIntNullComparesGreater2

public void testIntNullComparesGreater2()

testIntSwappedCompareGreater

public static Object testIntSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                  int intValue)

testIntSwappedCompareGreaterConstant1

public static Object testIntSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testIntSwappedCompareGreaterConstant2

public static Object testIntSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testIntSwappedComparesGreater

public void testIntSwappedComparesGreater()

testIntNullSwappedComparesGreater

public void testIntNullSwappedComparesGreater()

testIntNullSwappedComparesGreater1

public void testIntNullSwappedComparesGreater1()

testIntNullSwappedComparesGreater2

public void testIntNullSwappedComparesGreater2()

testIntCompareGreaterEqual

public static Object testIntCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                int intValue)

testIntCompareGreaterEqualConstant1

public static Object testIntCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testIntCompareGreaterEqualConstant2

public static Object testIntCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testIntComparesGreaterEqual

public void testIntComparesGreaterEqual()

testIntNullComparesGreaterEqual

public void testIntNullComparesGreaterEqual()

testIntNullComparesGreaterEqual1

public void testIntNullComparesGreaterEqual1()

testIntNullComparesGreaterEqual2

public void testIntNullComparesGreaterEqual2()

testIntSwappedCompareGreaterEqual

public static Object testIntSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                       int intValue)

testIntSwappedCompareGreaterEqualConstant1

public static Object testIntSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testIntSwappedCompareGreaterEqualConstant2

public static Object testIntSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testIntSwappedComparesGreaterEqual

public void testIntSwappedComparesGreaterEqual()

testIntNullSwappedComparesGreaterEqual

public void testIntNullSwappedComparesGreaterEqual()

testIntNullSwappedComparesGreaterEqual1

public void testIntNullSwappedComparesGreaterEqual1()

testIntNullSwappedComparesGreaterEqual2

public void testIntNullSwappedComparesGreaterEqual2()

testFloatCompare

public static Object testFloatCompare(MemoryArithmeticTest.FieldObject f,
                                      float floatValue)

testFloatCompareConstant1

public static Object testFloatCompareConstant1(MemoryArithmeticTest.FieldObject f)

testFloatCompareConstant2

public static Object testFloatCompareConstant2(MemoryArithmeticTest.FieldObject f)

testFloatCompares
```
public void testFloatCompares()
```

testFloatNullCompares
```
public void testFloatNullCompares()
```

testFloatNullCompares1
```
public void testFloatNullCompares1()
```

testFloatNullCompares2
```
public void testFloatNullCompares2()
```

testFloatCompareLess

public static Object testFloatCompareLess(MemoryArithmeticTest.FieldObject f,
                                          float floatValue)

testFloatCompareLessConstant1

public static Object testFloatCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testFloatCompareLessConstant2

public static Object testFloatCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testFloatComparesLess
```
public void testFloatComparesLess()
```

testFloatNullComparesLess

public void testFloatNullComparesLess()

testFloatNullComparesLess1

public void testFloatNullComparesLess1()

testFloatNullComparesLess2

public void testFloatNullComparesLess2()

testFloatSwappedCompareLess

public static Object testFloatSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                 float floatValue)

testFloatSwappedCompareLessConstant1

public static Object testFloatSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testFloatSwappedCompareLessConstant2

public static Object testFloatSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testFloatSwappedComparesLess

public void testFloatSwappedComparesLess()

testFloatNullSwappedComparesLess

public void testFloatNullSwappedComparesLess()

testFloatNullSwappedComparesLess1

public void testFloatNullSwappedComparesLess1()

testFloatNullSwappedComparesLess2

public void testFloatNullSwappedComparesLess2()

testFloatCompareLessEqual

public static Object testFloatCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                               float floatValue)

testFloatCompareLessEqualConstant1

public static Object testFloatCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testFloatCompareLessEqualConstant2

public static Object testFloatCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testFloatComparesLessEqual

public void testFloatComparesLessEqual()

testFloatNullComparesLessEqual

public void testFloatNullComparesLessEqual()

testFloatNullComparesLessEqual1

public void testFloatNullComparesLessEqual1()

testFloatNullComparesLessEqual2

public void testFloatNullComparesLessEqual2()

testFloatSwappedCompareLessEqual

public static Object testFloatSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                      float floatValue)

testFloatSwappedCompareLessEqualConstant1

public static Object testFloatSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testFloatSwappedCompareLessEqualConstant2

public static Object testFloatSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testFloatSwappedComparesLessEqual

public void testFloatSwappedComparesLessEqual()

testFloatNullSwappedComparesLessEqual

public void testFloatNullSwappedComparesLessEqual()

testFloatNullSwappedComparesLessEqual1

public void testFloatNullSwappedComparesLessEqual1()

testFloatNullSwappedComparesLessEqual2

public void testFloatNullSwappedComparesLessEqual2()

testFloatCompareGreater

public static Object testFloatCompareGreater(MemoryArithmeticTest.FieldObject f,
                                             float floatValue)

testFloatCompareGreaterConstant1

public static Object testFloatCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testFloatCompareGreaterConstant2

public static Object testFloatCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testFloatComparesGreater

public void testFloatComparesGreater()

testFloatNullComparesGreater

public void testFloatNullComparesGreater()

testFloatNullComparesGreater1

public void testFloatNullComparesGreater1()

testFloatNullComparesGreater2

public void testFloatNullComparesGreater2()

testFloatSwappedCompareGreater

public static Object testFloatSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                    float floatValue)

testFloatSwappedCompareGreaterConstant1

public static Object testFloatSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testFloatSwappedCompareGreaterConstant2

public static Object testFloatSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testFloatSwappedComparesGreater

public void testFloatSwappedComparesGreater()

testFloatNullSwappedComparesGreater

public void testFloatNullSwappedComparesGreater()

testFloatNullSwappedComparesGreater1

public void testFloatNullSwappedComparesGreater1()

testFloatNullSwappedComparesGreater2

public void testFloatNullSwappedComparesGreater2()

testFloatCompareGreaterEqual

public static Object testFloatCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                  float floatValue)

testFloatCompareGreaterEqualConstant1

public static Object testFloatCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testFloatCompareGreaterEqualConstant2

public static Object testFloatCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testFloatComparesGreaterEqual

public void testFloatComparesGreaterEqual()

testFloatNullComparesGreaterEqual

public void testFloatNullComparesGreaterEqual()

testFloatNullComparesGreaterEqual1

public void testFloatNullComparesGreaterEqual1()

testFloatNullComparesGreaterEqual2

public void testFloatNullComparesGreaterEqual2()

testFloatSwappedCompareGreaterEqual

public static Object testFloatSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                         float floatValue)

testFloatSwappedCompareGreaterEqualConstant1

public static Object testFloatSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testFloatSwappedCompareGreaterEqualConstant2

public static Object testFloatSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testFloatSwappedComparesGreaterEqual

public void testFloatSwappedComparesGreaterEqual()

testFloatNullSwappedComparesGreaterEqual

public void testFloatNullSwappedComparesGreaterEqual()

testFloatNullSwappedComparesGreaterEqual1

public void testFloatNullSwappedComparesGreaterEqual1()

testFloatNullSwappedComparesGreaterEqual2

public void testFloatNullSwappedComparesGreaterEqual2()

testLongCompare

public static Object testLongCompare(MemoryArithmeticTest.FieldObject f,
                                     long longValue)

testLongCompareConstant1

public static Object testLongCompareConstant1(MemoryArithmeticTest.FieldObject f)

testLongCompareConstant2

public static Object testLongCompareConstant2(MemoryArithmeticTest.FieldObject f)

testLongCompares
```
public void testLongCompares()
```

testLongNullCompares
```
public void testLongNullCompares()
```

testLongNullCompares1
```
public void testLongNullCompares1()
```

testLongNullCompares2
```
public void testLongNullCompares2()
```

testLongCompareLess

public static Object testLongCompareLess(MemoryArithmeticTest.FieldObject f,
                                         long longValue)

testLongCompareLessConstant1

public static Object testLongCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testLongCompareLessConstant2

public static Object testLongCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testLongComparesLess
```
public void testLongComparesLess()
```

testLongNullComparesLess

public void testLongNullComparesLess()

testLongNullComparesLess1

public void testLongNullComparesLess1()

testLongNullComparesLess2

public void testLongNullComparesLess2()

testLongSwappedCompareLess

public static Object testLongSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                long longValue)

testLongSwappedCompareLessConstant1

public static Object testLongSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testLongSwappedCompareLessConstant2

public static Object testLongSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testLongSwappedComparesLess

public void testLongSwappedComparesLess()

testLongNullSwappedComparesLess

public void testLongNullSwappedComparesLess()

testLongNullSwappedComparesLess1

public void testLongNullSwappedComparesLess1()

testLongNullSwappedComparesLess2

public void testLongNullSwappedComparesLess2()

testLongCompareLessEqual

public static Object testLongCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                              long longValue)

testLongCompareLessEqualConstant1

public static Object testLongCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testLongCompareLessEqualConstant2

public static Object testLongCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testLongComparesLessEqual

public void testLongComparesLessEqual()

testLongNullComparesLessEqual

public void testLongNullComparesLessEqual()

testLongNullComparesLessEqual1

public void testLongNullComparesLessEqual1()

testLongNullComparesLessEqual2

public void testLongNullComparesLessEqual2()

testLongSwappedCompareLessEqual

public static Object testLongSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                     long longValue)

testLongSwappedCompareLessEqualConstant1

public static Object testLongSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testLongSwappedCompareLessEqualConstant2

public static Object testLongSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testLongSwappedComparesLessEqual

public void testLongSwappedComparesLessEqual()

testLongNullSwappedComparesLessEqual

public void testLongNullSwappedComparesLessEqual()

testLongNullSwappedComparesLessEqual1

public void testLongNullSwappedComparesLessEqual1()

testLongNullSwappedComparesLessEqual2

public void testLongNullSwappedComparesLessEqual2()

testLongCompareGreater

public static Object testLongCompareGreater(MemoryArithmeticTest.FieldObject f,
                                            long longValue)

testLongCompareGreaterConstant1

public static Object testLongCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testLongCompareGreaterConstant2

public static Object testLongCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testLongComparesGreater
```
public void testLongComparesGreater()
```

testLongNullComparesGreater

public void testLongNullComparesGreater()

testLongNullComparesGreater1

public void testLongNullComparesGreater1()

testLongNullComparesGreater2

public void testLongNullComparesGreater2()

testLongSwappedCompareGreater

public static Object testLongSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                   long longValue)

testLongSwappedCompareGreaterConstant1

public static Object testLongSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testLongSwappedCompareGreaterConstant2

public static Object testLongSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testLongSwappedComparesGreater

public void testLongSwappedComparesGreater()

testLongNullSwappedComparesGreater

public void testLongNullSwappedComparesGreater()

testLongNullSwappedComparesGreater1

public void testLongNullSwappedComparesGreater1()

testLongNullSwappedComparesGreater2

public void testLongNullSwappedComparesGreater2()

testLongCompareGreaterEqual

public static Object testLongCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                 long longValue)

testLongCompareGreaterEqualConstant1

public static Object testLongCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testLongCompareGreaterEqualConstant2

public static Object testLongCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testLongComparesGreaterEqual

public void testLongComparesGreaterEqual()

testLongNullComparesGreaterEqual

public void testLongNullComparesGreaterEqual()

testLongNullComparesGreaterEqual1

public void testLongNullComparesGreaterEqual1()

testLongNullComparesGreaterEqual2

public void testLongNullComparesGreaterEqual2()

testLongSwappedCompareGreaterEqual

public static Object testLongSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                        long longValue)

testLongSwappedCompareGreaterEqualConstant1

public static Object testLongSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testLongSwappedCompareGreaterEqualConstant2

public static Object testLongSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testLongSwappedComparesGreaterEqual

public void testLongSwappedComparesGreaterEqual()

testLongNullSwappedComparesGreaterEqual

public void testLongNullSwappedComparesGreaterEqual()

testLongNullSwappedComparesGreaterEqual1

public void testLongNullSwappedComparesGreaterEqual1()

testLongNullSwappedComparesGreaterEqual2

public void testLongNullSwappedComparesGreaterEqual2()

testDoubleCompare

public static Object testDoubleCompare(MemoryArithmeticTest.FieldObject f,
                                       double doubleValue)

testDoubleCompareConstant1

public static Object testDoubleCompareConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleCompareConstant2

public static Object testDoubleCompareConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleCompares
```
public void testDoubleCompares()
```

testDoubleNullCompares
```
public void testDoubleNullCompares()
```

testDoubleNullCompares1
```
public void testDoubleNullCompares1()
```

testDoubleNullCompares2
```
public void testDoubleNullCompares2()
```

testDoubleCompareLess

public static Object testDoubleCompareLess(MemoryArithmeticTest.FieldObject f,
                                           double doubleValue)

testDoubleCompareLessConstant1

public static Object testDoubleCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleCompareLessConstant2

public static Object testDoubleCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleComparesLess
```
public void testDoubleComparesLess()
```

testDoubleNullComparesLess

public void testDoubleNullComparesLess()

testDoubleNullComparesLess1

public void testDoubleNullComparesLess1()

testDoubleNullComparesLess2

public void testDoubleNullComparesLess2()

testDoubleSwappedCompareLess

public static Object testDoubleSwappedCompareLess(MemoryArithmeticTest.FieldObject f,
                                                  double doubleValue)

testDoubleSwappedCompareLessConstant1

public static Object testDoubleSwappedCompareLessConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedCompareLessConstant2

public static Object testDoubleSwappedCompareLessConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedComparesLess

public void testDoubleSwappedComparesLess()

testDoubleNullSwappedComparesLess

public void testDoubleNullSwappedComparesLess()

testDoubleNullSwappedComparesLess1

public void testDoubleNullSwappedComparesLess1()

testDoubleNullSwappedComparesLess2

public void testDoubleNullSwappedComparesLess2()

testDoubleCompareLessEqual

public static Object testDoubleCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                double doubleValue)

testDoubleCompareLessEqualConstant1

public static Object testDoubleCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleCompareLessEqualConstant2

public static Object testDoubleCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleComparesLessEqual

public void testDoubleComparesLessEqual()

testDoubleNullComparesLessEqual

public void testDoubleNullComparesLessEqual()

testDoubleNullComparesLessEqual1

public void testDoubleNullComparesLessEqual1()

testDoubleNullComparesLessEqual2

public void testDoubleNullComparesLessEqual2()

testDoubleSwappedCompareLessEqual

public static Object testDoubleSwappedCompareLessEqual(MemoryArithmeticTest.FieldObject f,
                                                       double doubleValue)

testDoubleSwappedCompareLessEqualConstant1

public static Object testDoubleSwappedCompareLessEqualConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedCompareLessEqualConstant2

public static Object testDoubleSwappedCompareLessEqualConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedComparesLessEqual

public void testDoubleSwappedComparesLessEqual()

testDoubleNullSwappedComparesLessEqual

public void testDoubleNullSwappedComparesLessEqual()

testDoubleNullSwappedComparesLessEqual1

public void testDoubleNullSwappedComparesLessEqual1()

testDoubleNullSwappedComparesLessEqual2

public void testDoubleNullSwappedComparesLessEqual2()

testDoubleCompareGreater

public static Object testDoubleCompareGreater(MemoryArithmeticTest.FieldObject f,
                                              double doubleValue)

testDoubleCompareGreaterConstant1

public static Object testDoubleCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleCompareGreaterConstant2

public static Object testDoubleCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleComparesGreater

public void testDoubleComparesGreater()

testDoubleNullComparesGreater

public void testDoubleNullComparesGreater()

testDoubleNullComparesGreater1

public void testDoubleNullComparesGreater1()

testDoubleNullComparesGreater2

public void testDoubleNullComparesGreater2()

testDoubleSwappedCompareGreater

public static Object testDoubleSwappedCompareGreater(MemoryArithmeticTest.FieldObject f,
                                                     double doubleValue)

testDoubleSwappedCompareGreaterConstant1

public static Object testDoubleSwappedCompareGreaterConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedCompareGreaterConstant2

public static Object testDoubleSwappedCompareGreaterConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedComparesGreater

public void testDoubleSwappedComparesGreater()

testDoubleNullSwappedComparesGreater

public void testDoubleNullSwappedComparesGreater()

testDoubleNullSwappedComparesGreater1

public void testDoubleNullSwappedComparesGreater1()

testDoubleNullSwappedComparesGreater2

public void testDoubleNullSwappedComparesGreater2()

testDoubleCompareGreaterEqual

public static Object testDoubleCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                   double doubleValue)

testDoubleCompareGreaterEqualConstant1

public static Object testDoubleCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleCompareGreaterEqualConstant2

public static Object testDoubleCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleComparesGreaterEqual

public void testDoubleComparesGreaterEqual()

testDoubleNullComparesGreaterEqual

public void testDoubleNullComparesGreaterEqual()

testDoubleNullComparesGreaterEqual1

public void testDoubleNullComparesGreaterEqual1()

testDoubleNullComparesGreaterEqual2

public void testDoubleNullComparesGreaterEqual2()

testDoubleSwappedCompareGreaterEqual

public static Object testDoubleSwappedCompareGreaterEqual(MemoryArithmeticTest.FieldObject f,
                                                          double doubleValue)

testDoubleSwappedCompareGreaterEqualConstant1

public static Object testDoubleSwappedCompareGreaterEqualConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedCompareGreaterEqualConstant2

public static Object testDoubleSwappedCompareGreaterEqualConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleSwappedComparesGreaterEqual

public void testDoubleSwappedComparesGreaterEqual()

testDoubleNullSwappedComparesGreaterEqual

public void testDoubleNullSwappedComparesGreaterEqual()

testDoubleNullSwappedComparesGreaterEqual1

public void testDoubleNullSwappedComparesGreaterEqual1()

testDoubleNullSwappedComparesGreaterEqual2

public void testDoubleNullSwappedComparesGreaterEqual2()

testObjectCompare

public static Object testObjectCompare(MemoryArithmeticTest.FieldObject f,
                                       Object objectValue)

testObjectCompareConstant1

public static Object testObjectCompareConstant1(MemoryArithmeticTest.FieldObject f)

testObjectCompareConstant2

public static Object testObjectCompareConstant2(MemoryArithmeticTest.FieldObject f)

testObjectCompares
```
public void testObjectCompares()
```

testObjectNullCompares
```
public void testObjectNullCompares()
```

testObjectNullCompares1
```
public void testObjectNullCompares1()
```

testObjectNullCompares2
```
public void testObjectNullCompares2()
```

testByteAdd

public static int testByteAdd(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteAddConstant1

public static int testByteAddConstant1(MemoryArithmeticTest.FieldObject f)

testByteAddConstant2

public static int testByteAddConstant2(MemoryArithmeticTest.FieldObject f)

testByteAdds
```
public void testByteAdds()
```

testByteNullAdd
```
public void testByteNullAdd()
```

testShortAdd

public static int testShortAdd(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortAddConstant1

public static int testShortAddConstant1(MemoryArithmeticTest.FieldObject f)

testShortAddConstant2

public static int testShortAddConstant2(MemoryArithmeticTest.FieldObject f)

testShortAdds
```
public void testShortAdds()
```

testShortNullAdd
```
public void testShortNullAdd()
```

testCharAdd

public static int testCharAdd(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharAddConstant1

public static int testCharAddConstant1(MemoryArithmeticTest.FieldObject f)

testCharAddConstant2

public static int testCharAddConstant2(MemoryArithmeticTest.FieldObject f)

testCharAdds
```
public void testCharAdds()
```

testCharNullAdd
```
public void testCharNullAdd()
```

testIntAdd

public static int testIntAdd(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntAddConstant1

public static int testIntAddConstant1(MemoryArithmeticTest.FieldObject f)

testIntAddConstant2

public static int testIntAddConstant2(MemoryArithmeticTest.FieldObject f)

testIntAdds
```
public void testIntAdds()
```

testIntNullAdd
```
public void testIntNullAdd()
```

testLongAdd

public static long testLongAdd(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongAddConstant1

public static long testLongAddConstant1(MemoryArithmeticTest.FieldObject f)

testLongAddConstant2

public static long testLongAddConstant2(MemoryArithmeticTest.FieldObject f)

testLongAdds
```
public void testLongAdds()
```

testLongNullAdd
```
public void testLongNullAdd()
```

testFloatAdd

public static float testFloatAdd(MemoryArithmeticTest.FieldObject f,
                                 float floatValue)

testFloatAddConstant1

public static float testFloatAddConstant1(MemoryArithmeticTest.FieldObject f)

testFloatAddConstant2

public static float testFloatAddConstant2(MemoryArithmeticTest.FieldObject f)

testFloatAdds
```
public void testFloatAdds()
```

testFloatNullAdd
```
public void testFloatNullAdd()
```

testDoubleAdd

public static double testDoubleAdd(MemoryArithmeticTest.FieldObject f,
                                   double doubleValue)

testDoubleAddConstant1

public static double testDoubleAddConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleAddConstant2

public static double testDoubleAddConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleAdds
```
public void testDoubleAdds()
```

testDoubleNullAdd
```
public void testDoubleNullAdd()
```

testByteSub

public static int testByteSub(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteSubConstant1

public static int testByteSubConstant1(MemoryArithmeticTest.FieldObject f)

testByteSubConstant2

public static int testByteSubConstant2(MemoryArithmeticTest.FieldObject f)

testByteSubs
```
public void testByteSubs()
```

testByteNullSub
```
public void testByteNullSub()
```

testShortSub

public static int testShortSub(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortSubConstant1

public static int testShortSubConstant1(MemoryArithmeticTest.FieldObject f)

testShortSubConstant2

public static int testShortSubConstant2(MemoryArithmeticTest.FieldObject f)

testShortSubs
```
public void testShortSubs()
```

testShortNullSub
```
public void testShortNullSub()
```

testCharSub

public static int testCharSub(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharSubConstant1

public static int testCharSubConstant1(MemoryArithmeticTest.FieldObject f)

testCharSubConstant2

public static int testCharSubConstant2(MemoryArithmeticTest.FieldObject f)

testCharSubs
```
public void testCharSubs()
```

testCharNullSub
```
public void testCharNullSub()
```

testIntSub

public static int testIntSub(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntSubConstant1

public static int testIntSubConstant1(MemoryArithmeticTest.FieldObject f)

testIntSubConstant2

public static int testIntSubConstant2(MemoryArithmeticTest.FieldObject f)

testIntSubs
```
public void testIntSubs()
```

testIntNullSub
```
public void testIntNullSub()
```

testLongSub

public static long testLongSub(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongSubConstant1

public static long testLongSubConstant1(MemoryArithmeticTest.FieldObject f)

testLongSubConstant2

public static long testLongSubConstant2(MemoryArithmeticTest.FieldObject f)

testLongSubs
```
public void testLongSubs()
```

testLongNullSub
```
public void testLongNullSub()
```

testFloatSub

public static float testFloatSub(MemoryArithmeticTest.FieldObject f,
                                 float floatValue)

testFloatSubConstant1

public static float testFloatSubConstant1(MemoryArithmeticTest.FieldObject f)

testFloatSubConstant2

public static float testFloatSubConstant2(MemoryArithmeticTest.FieldObject f)

testFloatSubs
```
public void testFloatSubs()
```

testFloatNullSub
```
public void testFloatNullSub()
```

testDoubleSub

public static double testDoubleSub(MemoryArithmeticTest.FieldObject f,
                                   double doubleValue)

testDoubleSubConstant1

public static double testDoubleSubConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleSubConstant2

public static double testDoubleSubConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleSubs
```
public void testDoubleSubs()
```

testDoubleNullSub
```
public void testDoubleNullSub()
```

testByteMul

public static int testByteMul(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteMulConstant1

public static int testByteMulConstant1(MemoryArithmeticTest.FieldObject f)

testByteMulConstant2

public static int testByteMulConstant2(MemoryArithmeticTest.FieldObject f)

testByteMuls
```
public void testByteMuls()
```

testByteNullMul
```
public void testByteNullMul()
```

testShortMul

public static int testShortMul(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortMulConstant1

public static int testShortMulConstant1(MemoryArithmeticTest.FieldObject f)

testShortMulConstant2

public static int testShortMulConstant2(MemoryArithmeticTest.FieldObject f)

testShortMuls
```
public void testShortMuls()
```

testShortNullMul
```
public void testShortNullMul()
```

testCharMul

public static int testCharMul(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharMulConstant1

public static int testCharMulConstant1(MemoryArithmeticTest.FieldObject f)

testCharMulConstant2

public static int testCharMulConstant2(MemoryArithmeticTest.FieldObject f)

testCharMuls
```
public void testCharMuls()
```

testCharNullMul
```
public void testCharNullMul()
```

testIntMul

public static int testIntMul(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntMulConstant1

public static int testIntMulConstant1(MemoryArithmeticTest.FieldObject f)

testIntMulConstant2

public static int testIntMulConstant2(MemoryArithmeticTest.FieldObject f)

testIntMuls
```
public void testIntMuls()
```

testIntNullMul
```
public void testIntNullMul()
```

testLongMul

public static long testLongMul(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongMulConstant1

public static long testLongMulConstant1(MemoryArithmeticTest.FieldObject f)

testLongMulConstant2

public static long testLongMulConstant2(MemoryArithmeticTest.FieldObject f)

testLongMuls
```
public void testLongMuls()
```

testLongNullMul
```
public void testLongNullMul()
```

testFloatMul

public static float testFloatMul(MemoryArithmeticTest.FieldObject f,
                                 float floatValue)

testFloatMulConstant1

public static float testFloatMulConstant1(MemoryArithmeticTest.FieldObject f)

testFloatMulConstant2

public static float testFloatMulConstant2(MemoryArithmeticTest.FieldObject f)

testFloatMuls
```
public void testFloatMuls()
```

testFloatNullMul
```
public void testFloatNullMul()
```

testDoubleMul

public static double testDoubleMul(MemoryArithmeticTest.FieldObject f,
                                   double doubleValue)

testDoubleMulConstant1

public static double testDoubleMulConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleMulConstant2

public static double testDoubleMulConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleMuls
```
public void testDoubleMuls()
```

testDoubleNullMul
```
public void testDoubleNullMul()
```

testByteDiv

public static int testByteDiv(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteDivConstant1

public static int testByteDivConstant1(MemoryArithmeticTest.FieldObject f)

testByteDivConstant2

public static int testByteDivConstant2(MemoryArithmeticTest.FieldObject f)

testByteDivs
```
public void testByteDivs()
```

testByteNullDiv
```
public void testByteNullDiv()
```

testShortDiv

public static int testShortDiv(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortDivConstant1

public static int testShortDivConstant1(MemoryArithmeticTest.FieldObject f)

testShortDivConstant2

public static int testShortDivConstant2(MemoryArithmeticTest.FieldObject f)

testShortDivs
```
public void testShortDivs()
```

testShortNullDiv
```
public void testShortNullDiv()
```

testCharDiv

public static int testCharDiv(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharDivConstant1

public static int testCharDivConstant1(MemoryArithmeticTest.FieldObject f)

testCharDivConstant2

public static int testCharDivConstant2(MemoryArithmeticTest.FieldObject f)

testCharDivs
```
public void testCharDivs()
```

testCharNullDiv
```
public void testCharNullDiv()
```

testIntDiv

public static int testIntDiv(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntDivConstant1

public static int testIntDivConstant1(MemoryArithmeticTest.FieldObject f)

testIntDivConstant2

public static int testIntDivConstant2(MemoryArithmeticTest.FieldObject f)

testIntDivs
```
public void testIntDivs()
```

testIntNullDiv
```
public void testIntNullDiv()
```

testLongDiv

public static long testLongDiv(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongDivConstant1

public static long testLongDivConstant1(MemoryArithmeticTest.FieldObject f)

testLongDivConstant2

public static long testLongDivConstant2(MemoryArithmeticTest.FieldObject f)

testLongDivs
```
public void testLongDivs()
```

testLongNullDiv
```
public void testLongNullDiv()
```

testFloatDiv

public static float testFloatDiv(MemoryArithmeticTest.FieldObject f,
                                 float floatValue)

testFloatDivConstant1

public static float testFloatDivConstant1(MemoryArithmeticTest.FieldObject f)

testFloatDivConstant2

public static float testFloatDivConstant2(MemoryArithmeticTest.FieldObject f)

testFloatDivs
```
public void testFloatDivs()
```

testFloatNullDiv
```
public void testFloatNullDiv()
```

testDoubleDiv

public static double testDoubleDiv(MemoryArithmeticTest.FieldObject f,
                                   double doubleValue)

testDoubleDivConstant1

public static double testDoubleDivConstant1(MemoryArithmeticTest.FieldObject f)

testDoubleDivConstant2

public static double testDoubleDivConstant2(MemoryArithmeticTest.FieldObject f)

testDoubleDivs
```
public void testDoubleDivs()
```

testDoubleNullDiv
```
public void testDoubleNullDiv()
```

testByteOr

public static int testByteOr(MemoryArithmeticTest.FieldObject f,
                             byte byteValue)

testByteOrConstant1

public static int testByteOrConstant1(MemoryArithmeticTest.FieldObject f)

testByteOrConstant2

public static int testByteOrConstant2(MemoryArithmeticTest.FieldObject f)

testByteOrs
```
public void testByteOrs()
```

testByteNullOr
```
public void testByteNullOr()
```

testShortOr

public static int testShortOr(MemoryArithmeticTest.FieldObject f,
                              short shortValue)

testShortOrConstant1

public static int testShortOrConstant1(MemoryArithmeticTest.FieldObject f)

testShortOrConstant2

public static int testShortOrConstant2(MemoryArithmeticTest.FieldObject f)

testShortOrs
```
public void testShortOrs()
```

testShortNullOr
```
public void testShortNullOr()
```

testCharOr

public static int testCharOr(MemoryArithmeticTest.FieldObject f,
                             char charValue)

testCharOrConstant1

public static int testCharOrConstant1(MemoryArithmeticTest.FieldObject f)

testCharOrConstant2

public static int testCharOrConstant2(MemoryArithmeticTest.FieldObject f)

testCharOrs
```
public void testCharOrs()
```

testCharNullOr
```
public void testCharNullOr()
```

testIntOr

public static int testIntOr(MemoryArithmeticTest.FieldObject f,
                            int intValue)

testIntOrConstant1

public static int testIntOrConstant1(MemoryArithmeticTest.FieldObject f)

testIntOrConstant2

public static int testIntOrConstant2(MemoryArithmeticTest.FieldObject f)

testIntOrs
```
public void testIntOrs()
```

testIntNullOr
```
public void testIntNullOr()
```

testLongOr

public static long testLongOr(MemoryArithmeticTest.FieldObject f,
                              long longValue)

testLongOrConstant1

public static long testLongOrConstant1(MemoryArithmeticTest.FieldObject f)

testLongOrConstant2

public static long testLongOrConstant2(MemoryArithmeticTest.FieldObject f)

testLongOrs
```
public void testLongOrs()
```

testLongNullOr
```
public void testLongNullOr()
```

testByteXor

public static int testByteXor(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteXorConstant1

public static int testByteXorConstant1(MemoryArithmeticTest.FieldObject f)

testByteXorConstant2

public static int testByteXorConstant2(MemoryArithmeticTest.FieldObject f)

testByteXors
```
public void testByteXors()
```

testByteNullXor
```
public void testByteNullXor()
```

testShortXor

public static int testShortXor(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortXorConstant1

public static int testShortXorConstant1(MemoryArithmeticTest.FieldObject f)

testShortXorConstant2

public static int testShortXorConstant2(MemoryArithmeticTest.FieldObject f)

testShortXors
```
public void testShortXors()
```

testShortNullXor
```
public void testShortNullXor()
```

testCharXor

public static int testCharXor(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharXorConstant1

public static int testCharXorConstant1(MemoryArithmeticTest.FieldObject f)

testCharXorConstant2

public static int testCharXorConstant2(MemoryArithmeticTest.FieldObject f)

testCharXors
```
public void testCharXors()
```

testCharNullXor
```
public void testCharNullXor()
```

testIntXor

public static int testIntXor(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntXorConstant1

public static int testIntXorConstant1(MemoryArithmeticTest.FieldObject f)

testIntXorConstant2

public static int testIntXorConstant2(MemoryArithmeticTest.FieldObject f)

testIntXors
```
public void testIntXors()
```

testIntNullXor
```
public void testIntNullXor()
```

testLongXor

public static long testLongXor(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongXorConstant1

public static long testLongXorConstant1(MemoryArithmeticTest.FieldObject f)

testLongXorConstant2

public static long testLongXorConstant2(MemoryArithmeticTest.FieldObject f)

testLongXors
```
public void testLongXors()
```

testLongNullXor
```
public void testLongNullXor()
```

testByteAnd

public static int testByteAnd(MemoryArithmeticTest.FieldObject f,
                              byte byteValue)

testByteAndConstant1

public static int testByteAndConstant1(MemoryArithmeticTest.FieldObject f)

testByteAndConstant2

public static int testByteAndConstant2(MemoryArithmeticTest.FieldObject f)

testByteAnds
```
public void testByteAnds()
```

testByteNullAnd
```
public void testByteNullAnd()
```

testShortAnd

public static int testShortAnd(MemoryArithmeticTest.FieldObject f,
                               short shortValue)

testShortAndConstant1

public static int testShortAndConstant1(MemoryArithmeticTest.FieldObject f)

testShortAndConstant2

public static int testShortAndConstant2(MemoryArithmeticTest.FieldObject f)

testShortAnds
```
public void testShortAnds()
```

testShortNullAnd
```
public void testShortNullAnd()
```

testCharAnd

public static int testCharAnd(MemoryArithmeticTest.FieldObject f,
                              char charValue)

testCharAndConstant1

public static int testCharAndConstant1(MemoryArithmeticTest.FieldObject f)

testCharAndConstant2

public static int testCharAndConstant2(MemoryArithmeticTest.FieldObject f)

testCharAnds
```
public void testCharAnds()
```

testCharNullAnd
```
public void testCharNullAnd()
```

testIntAnd

public static int testIntAnd(MemoryArithmeticTest.FieldObject f,
                             int intValue)

testIntAndConstant1

public static int testIntAndConstant1(MemoryArithmeticTest.FieldObject f)

testIntAndConstant2

public static int testIntAndConstant2(MemoryArithmeticTest.FieldObject f)

testIntAnds
```
public void testIntAnds()
```

testIntNullAnd
```
public void testIntNullAnd()
```

testLongAnd

public static long testLongAnd(MemoryArithmeticTest.FieldObject f,
                               long longValue)

testLongAndConstant1

public static long testLongAndConstant1(MemoryArithmeticTest.FieldObject f)

testLongAndConstant2

public static long testLongAndConstant2(MemoryArithmeticTest.FieldObject f)

testLongAnds
```
public void testLongAnds()
```

testLongNullAnd
```
public void testLongNullAnd()
```

testIntMask

public static boolean testIntMask(MemoryArithmeticTest.FieldObject f,
                                  int intValue)

testIntMaskConstant1

public static boolean testIntMaskConstant1(MemoryArithmeticTest.FieldObject f)

testIntMaskConstant2

public static boolean testIntMaskConstant2(MemoryArithmeticTest.FieldObject f)

testIntMasks
```
public void testIntMasks()
```

testIntNullMask
```
public void testIntNullMask()
```

testLongMask

public static boolean testLongMask(MemoryArithmeticTest.FieldObject f,
                                   long longValue)

testLongMaskConstant1

public static boolean testLongMaskConstant1(MemoryArithmeticTest.FieldObject f)

testLongMaskConstant2

public static boolean testLongMaskConstant2(MemoryArithmeticTest.FieldObject f)

testLongMasks
```
public void testLongMasks()
```

testLongNullMask
```
public void testLongNullMask()
```

doConvertByteInt

public static int doConvertByteInt(MemoryArithmeticTest.FieldObject f)

testConvertByteInt
```
public void testConvertByteInt()
```

doConvertShortInt

public static int doConvertShortInt(MemoryArithmeticTest.FieldObject f)

testConvertShortInt
```
public void testConvertShortInt()
```

doConvertCharInt

public static int doConvertCharInt(MemoryArithmeticTest.FieldObject f)

testConvertCharInt
```
public void testConvertCharInt()
```

doConvertLongInt

public static int doConvertLongInt(MemoryArithmeticTest.FieldObject f)

testConvertLongInt
```
public void testConvertLongInt()
```

doConvertFloatInt

public static int doConvertFloatInt(MemoryArithmeticTest.FieldObject f)

testConvertFloatInt
```
public void testConvertFloatInt()
```

doConvertDoubleInt

public static int doConvertDoubleInt(MemoryArithmeticTest.FieldObject f)

testConvertDoubleInt
```
public void testConvertDoubleInt()
```

doConvertByteLong

public static long doConvertByteLong(MemoryArithmeticTest.FieldObject f)

testConvertByteLong
```
public void testConvertByteLong()
```

doConvertShortLong

public static long doConvertShortLong(MemoryArithmeticTest.FieldObject f)

testConvertShortLong
```
public void testConvertShortLong()
```

doConvertCharLong

public static long doConvertCharLong(MemoryArithmeticTest.FieldObject f)

testConvertCharLong
```
public void testConvertCharLong()
```

doConvertIntLong

public static long doConvertIntLong(MemoryArithmeticTest.FieldObject f)

testConvertIntLong
```
public void testConvertIntLong()
```

doConvertFloatLong

public static long doConvertFloatLong(MemoryArithmeticTest.FieldObject f)

testConvertFloatLong
```
public void testConvertFloatLong()
```

doConvertDoubleLong

public static long doConvertDoubleLong(MemoryArithmeticTest.FieldObject f)

testConvertDoubleLong
```
public void testConvertDoubleLong()
```

doConvertByteFloat

public static float doConvertByteFloat(MemoryArithmeticTest.FieldObject f)

testConvertByteFloat
```
public void testConvertByteFloat()
```

doConvertShortFloat

public static float doConvertShortFloat(MemoryArithmeticTest.FieldObject f)

testConvertShortFloat
```
public void testConvertShortFloat()
```

doConvertCharFloat

public static float doConvertCharFloat(MemoryArithmeticTest.FieldObject f)

testConvertCharFloat
```
public void testConvertCharFloat()
```

doConvertIntFloat

public static float doConvertIntFloat(MemoryArithmeticTest.FieldObject f)

testConvertIntFloat
```
public void testConvertIntFloat()
```

doConvertLongFloat

public static float doConvertLongFloat(MemoryArithmeticTest.FieldObject f)

testConvertLongFloat
```
public void testConvertLongFloat()
```

doConvertDoubleFloat

public static float doConvertDoubleFloat(MemoryArithmeticTest.FieldObject f)

testConvertDoubleFloat
```
public void testConvertDoubleFloat()
```

doConvertByteDouble

public static double doConvertByteDouble(MemoryArithmeticTest.FieldObject f)

testConvertByteDouble
```
public void testConvertByteDouble()
```

doConvertShortDouble

public static double doConvertShortDouble(MemoryArithmeticTest.FieldObject f)

testConvertShortDouble
```
public void testConvertShortDouble()
```

doConvertCharDouble

public static double doConvertCharDouble(MemoryArithmeticTest.FieldObject f)

testConvertCharDouble
```
public void testConvertCharDouble()
```

doConvertIntDouble

public static double doConvertIntDouble(MemoryArithmeticTest.FieldObject f)

testConvertIntDouble
```
public void testConvertIntDouble()
```

doConvertLongDouble

public static double doConvertLongDouble(MemoryArithmeticTest.FieldObject f)

testConvertLongDouble
```
public void testConvertLongDouble()
```

doConvertFloatDouble

public static double doConvertFloatDouble(MemoryArithmeticTest.FieldObject f)

testConvertFloatDouble
```
public void testConvertFloatDouble()
```

Class MemoryArithmeticTest

Nested Class Summary

Nested classes/interfaces inherited from class com.oracle.graal.compiler.test.GraalCompilerTest

Nested classes/interfaces inherited from class com.oracle.graal.test.GraalTest

Field Summary

Fields inherited from class com.oracle.graal.compiler.test.GraalCompilerTest

Constructor Summary

Method Summary

Methods inherited from class com.oracle.graal.compiler.test.GraalCompilerTest

Methods inherited from class com.oracle.graal.test.GraalTest

Methods inherited from class java.lang.Object

Field Detail

count

maxObject

minObject

booleanTestValue1

byteTestValue1

shortTestValue1

charTestValue1

intTestValue1

floatTestValue1

longTestValue1

doubleTestValue1

objectTestValue1

booleanTestValue2

byteTestValue2

shortTestValue2

charTestValue2

intTestValue2

floatTestValue2

longTestValue2

doubleTestValue2

objectTestValue2

Constructor Detail

MemoryArithmeticTest

Method Detail

getCode

before

testBooleanCompare

testBooleanCompareConstant1

testBooleanCompareConstant2

testBooleanCompares

testBooleanNullCompares

testBooleanNullCompares1

testBooleanNullCompares2

testByteCompare

testByteCompareConstant1

testByteCompareConstant2

testByteCompares

testByteNullCompares

testByteNullCompares1

testByteNullCompares2

testByteCompareLess

testByteCompareLessConstant1

testByteCompareLessConstant2

testByteComparesLess

testByteNullComparesLess

testByteNullComparesLess1

testByteNullComparesLess2

testByteSwappedCompareLess

testByteSwappedCompareLessConstant1

testByteSwappedCompareLessConstant2

testByteSwappedComparesLess

testByteNullSwappedComparesLess

testByteNullSwappedComparesLess1

testByteNullSwappedComparesLess2

testByteCompareLessEqual

testByteCompareLessEqualConstant1

testByteCompareLessEqualConstant2

testByteComparesLessEqual

testByteNullComparesLessEqual

testByteNullComparesLessEqual1

testByteNullComparesLessEqual2

testByteSwappedCompareLessEqual

testByteSwappedCompareLessEqualConstant1

testByteSwappedCompareLessEqualConstant2

testByteSwappedComparesLessEqual

testByteNullSwappedComparesLessEqual

testByteNullSwappedComparesLessEqual1

testByteNullSwappedComparesLessEqual2