Merge "Add complementary test for not simplifier optimization" into ub-jack-brest

8 files changed, 459 insertions, 57 deletions

diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/dx/Tests.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/dx/Tests.java
index f63b42f1..b07b4cc5 100644
--- a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/dx/Tests.java
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/dx/Tests.java
@@ -16,7 +16,13 @@
 
 package com.android.jack.optimizations.notsimplifier.test002.dx;
 
-import com.android.jack.optimizations.notsimplifier.test002.jack.NotSimplifier;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithComparisonOperator;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithEQ;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithGT;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithGTE;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithLT;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithLTE;
+import com.android.jack.optimizations.notsimplifier.test002.jack.NotWithNEQ;
 
 import junit.framework.Assert;
 
@@ -28,59 +34,135 @@ import org.junit.Test;
 public class Tests {
 
   @Test
-  public void test1() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Double.NaN));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(0.0d));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-5.0d));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-Double.MIN_VALUE));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Double.NEGATIVE_INFINITY));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Double.POSITIVE_INFINITY));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Double.MAX_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(5.0d));
-  }
+  public void test() {
+    NotWithComparisonOperator[] operators = new NotWithComparisonOperator[] {
+        new NotWithGT(),
+        new NotWithGTE(),
+        new NotWithEQ(),
+        new NotWithNEQ(),
+        new NotWithLT(),
+        new NotWithLTE()};
 
-  @Test
-  public void test2() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Float.NaN));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(0.0f));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-5.0f));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-Float.MIN_VALUE));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Float.NEGATIVE_INFINITY));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Float.POSITIVE_INFINITY));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Float.MAX_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(5.0f));
-  }
+    double[] doubleValues = new double[] {
+        Double.NaN,
+        0.0d,
+        -5.0d,
+        -Double.MIN_VALUE,
+        Double.NEGATIVE_INFINITY,
+        Double.POSITIVE_INFINITY,
+        Double.MAX_VALUE,
+        5.0d};
 
-  @Test
-  public void test3() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(0l));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-5l));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-Long.MIN_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Long.MAX_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(1l));
-  }
+    float[] floatValues = new float[] {
+        Float.NaN,
+        0.0f,
+        -5.0f,
+        -Float.MIN_VALUE,
+        Float.NEGATIVE_INFINITY,
+        Float.POSITIVE_INFINITY,
+        Float.MAX_VALUE,
+        5.0f};
 
-  @Test
-  public void test4() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(0));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-5));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(-Integer.MIN_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Integer.MAX_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(1));
-  }
+    int[] intValues = new int[] {
+        0,
+        -5,
+        -Integer.MIN_VALUE,
+        Integer.MAX_VALUE,
+        1};
 
-  @Test
-  public void test5() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0((byte) 0));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0((byte) -5));
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Byte.MIN_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Byte.MAX_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0((byte) 1));
-  }
+    long[] longValues = new long[] {
+        0l,
+        -5l,
+        -Long.MIN_VALUE,
+        Long.MAX_VALUE,
+        1l};
 
-  @Test
-  public void test6() {
-    Assert.assertTrue(NotSimplifier.smallerOrEqualTo0(Character.MIN_VALUE));
-    Assert.assertFalse(NotSimplifier.smallerOrEqualTo0(Character.MAX_VALUE));
+    byte[] byteValues = new byte[] {
+        (byte) 0,
+        (byte) -5,
+        Byte.MIN_VALUE,
+        Byte.MAX_VALUE,
+        (byte) 1};
+
+    short[] shortValues = new short[] {
+        (short) 0,
+        (short) -5,
+        Short.MIN_VALUE,
+        Short.MAX_VALUE,
+        (short) 1};
+
+    char[] charValues = new char[] {
+        (char) 0,
+        Character.MIN_VALUE,
+        Character.MAX_VALUE};
+
+    boolean[][] resultForDoubleAndFloat =
+        new boolean[][] {
+        {true, true, true, true, true, false, false, false}, // GT
+        {true, false, true, true, true, false, false, false}, // GTE
+        {true, false, true, true, true, true, true, true}, // EQ
+        {false, true, false, false, false, false, false, false}, // NEQ
+        {true, true, false, false, false, true, true, true}, // LT
+        {true, false, false, false, false, true, true, true}, // LTE
+        };
+
+    boolean[][] resultForLongIntShortByte =
+        new boolean[][] {
+        {true, true, true, false, false}, // GT
+        {false, true, true, false, false}, // GTE
+        {false, true, true, true, true}, // EQ
+        {true, false, false, false, false}, // NEQ
+        {true, false, false, true, true}, // LT
+        {false, false, false, true, true}, // LTE
+        };
+
+    boolean[][] resultForChar =
+        new boolean[][] {
+        {true, true, false}, // GT
+        {false,false, false}, // GTE
+        {false, false, true}, // EQ
+        {true, true, false}, // NEQ
+        {true, true, true}, // LT
+        {false, false, true}, // LTE
+        };
+
+    for (int operatorIndex = 0; operatorIndex < operators.length; operatorIndex++) {
+      NotWithComparisonOperator operator = operators[operatorIndex];
+
+      for (int valueIndex = 0; valueIndex < doubleValues.length; valueIndex++) {
+        Assert.assertEquals(resultForDoubleAndFloat[operatorIndex][valueIndex],
+            operator.testWithDouble(doubleValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < floatValues.length; valueIndex++) {
+        Assert.assertEquals(resultForDoubleAndFloat[operatorIndex][valueIndex],
+            operator.testWithFloat(floatValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < intValues.length; valueIndex++) {
+        Assert.assertEquals(resultForLongIntShortByte[operatorIndex][valueIndex],
+            operator.testWithInt(intValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < longValues.length; valueIndex++) {
+        Assert.assertEquals(resultForLongIntShortByte[operatorIndex][valueIndex],
+            operator.testWithLong(longValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < byteValues.length; valueIndex++) {
+        Assert.assertEquals(resultForLongIntShortByte[operatorIndex][valueIndex],
+            operator.testWithByte(byteValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < shortValues.length; valueIndex++) {
+        Assert.assertEquals(resultForLongIntShortByte[operatorIndex][valueIndex],
+            operator.testWithShort(shortValues[valueIndex]));
+      }
+
+      for (int valueIndex = 0; valueIndex < charValues.length; valueIndex++) {
+        Assert.assertEquals(resultForChar[operatorIndex][valueIndex],
+            operator.testWithChar(charValues[valueIndex]));
+      }
+    }
   }
 }
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithComparisonOperator.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithComparisonOperator.java
new file mode 100644
index 00000000..15a4f39b
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithComparisonOperator.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public interface NotWithComparisonOperator {
+
+  public boolean testWithDouble(double n);
+
+  public boolean testWithFloat(float n);
+
+  public boolean testWithLong(long n);
+
+  public boolean testWithInt(int n);
+
+  public boolean testWithShort(short n);
+
+  public boolean testWithByte(byte n);
+
+  public boolean testWithChar(char n);
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithEQ.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithEQ.java
new file mode 100644
index 00000000..ff1c16bc
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithEQ.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public class NotWithEQ implements NotWithComparisonOperator {
+
+  @Override
+  public boolean testWithDouble(double n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithFloat(float n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithLong(long n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithInt(int n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithByte(byte n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n == 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
+    return !(n == 0);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotSimplifier.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGT.java
index bdd78444..4d6404d9 100644
--- a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotSimplifier.java
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGT.java
@@ -16,29 +16,40 @@
 
 package com.android.jack.optimizations.notsimplifier.test002.jack;
 
-public class NotSimplifier {
+public class NotWithGT implements NotWithComparisonOperator {
 
-  public static boolean smallerOrEqualTo0(double n) {
+  @Override
+  public boolean testWithDouble(double n) {
     return !(n > 0);
   }
 
-  public static boolean smallerOrEqualTo0(float n) {
+  @Override
+  public boolean testWithFloat(float n) {
     return !(n > 0);
   }
 
-  public static boolean smallerOrEqualTo0(long n) {
+  @Override
+  public boolean testWithLong(long n) {
     return !(n > 0);
   }
 
-  public static boolean smallerOrEqualTo0(int n) {
+  @Override
+  public boolean testWithInt(int n) {
     return !(n > 0);
   }
 
-  public static boolean smallerOrEqualTo0(byte n) {
+  @Override
+  public boolean testWithByte(byte n) {
     return !(n > 0);
   }
 
-  public static boolean smallerOrEqualTo0(char n) {
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n > 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
     return !(n > 0);
   }
 }
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGTE.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGTE.java
new file mode 100644
index 00000000..6d9e64c1
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGTE.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public class NotWithGTE implements NotWithComparisonOperator {
+
+  @Override
+  public boolean testWithDouble(double n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithFloat(float n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithLong(long n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithInt(int n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithByte(byte n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n >= 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
+    return !(n >= 0);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLT.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLT.java
new file mode 100644
index 00000000..4c6fbe51
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLT.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public class NotWithLT implements NotWithComparisonOperator {
+
+  @Override
+  public boolean testWithDouble(double n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithFloat(float n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithLong(long n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithInt(int n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithByte(byte n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n < 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
+    return !(n < 0);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLTE.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLTE.java
new file mode 100644
index 00000000..4ba0951e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLTE.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public class NotWithLTE implements NotWithComparisonOperator {
+
+  @Override
+  public boolean testWithDouble(double n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithFloat(float n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithLong(long n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithInt(int n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithByte(byte n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n <= 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
+    return !(n <= 0);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithNEQ.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithNEQ.java
new file mode 100644
index 00000000..fcca9f1a
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithNEQ.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.notsimplifier.test002.jack;
+
+public class NotWithNEQ implements NotWithComparisonOperator {
+
+  @Override
+  public boolean testWithDouble(double n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithFloat(float n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithLong(long n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithInt(int n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithByte(byte n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithChar(char n) {
+    return !(n != 0);
+  }
+
+  @Override
+  public boolean testWithShort(short n) {
+    return !(n != 0);
+  }
+}