From 533c619ee4135b8891eaf5fc70affafbe02803e0 Mon Sep 17 00:00:00 2001 From: mikaelpeltier Date: Thu, 21 May 2015 11:43:29 +0200 Subject: Add complementary test for not simplifier optimization Change-Id: Ie6918e1b069065b133657d19a60265202837c656 (cherry picked from commit 0d60e80a141b0b23bf2e1a0a4709dd14d1aa47e0) --- .../notsimplifier/test002/dx/Tests.java | 182 +++++++++++++++------ .../notsimplifier/test002/jack/NotSimplifier.java | 44 ----- .../test002/jack/NotWithComparisonOperator.java | 34 ++++ .../notsimplifier/test002/jack/NotWithEQ.java | 55 +++++++ .../notsimplifier/test002/jack/NotWithGT.java | 55 +++++++ .../notsimplifier/test002/jack/NotWithGTE.java | 55 +++++++ .../notsimplifier/test002/jack/NotWithLT.java | 55 +++++++ .../notsimplifier/test002/jack/NotWithLTE.java | 55 +++++++ .../notsimplifier/test002/jack/NotWithNEQ.java | 55 +++++++ 9 files changed, 496 insertions(+), 94 deletions(-) delete mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotSimplifier.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithComparisonOperator.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithEQ.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGT.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGTE.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLT.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithLTE.java create mode 100644 jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithNEQ.java (limited to 'jack-tests') 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/NotSimplifier.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotSimplifier.java deleted file mode 100644 index bdd78444..00000000 --- a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotSimplifier.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * 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 NotSimplifier { - - public static boolean smallerOrEqualTo0(double n) { - return !(n > 0); - } - - public static boolean smallerOrEqualTo0(float n) { - return !(n > 0); - } - - public static boolean smallerOrEqualTo0(long n) { - return !(n > 0); - } - - public static boolean smallerOrEqualTo0(int n) { - return !(n > 0); - } - - public static boolean smallerOrEqualTo0(byte n) { - return !(n > 0); - } - - public static boolean smallerOrEqualTo0(char n) { - return !(n > 0); - } -} 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/NotWithGT.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGT.java new file mode 100644 index 00000000..4d6404d9 --- /dev/null +++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/test002/jack/NotWithGT.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 NotWithGT 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/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); + } +} -- cgit v1.2.3