Quelle  Main.java

/*
 * Copyright 2019 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.
 */

public class Main {
    public static void main(String[] args) {
        testAppendStringAndLong();
        testAppendStringAndInt();
        testAppendStringAndFloat();
        testAppendStringAndDouble();
        testAppendDoubleAndFloat();
        testAppendStringAndString();
        testMiscelaneous();
        testNoArgs();
        testInline();
        testEquals();
        System.out.println("passed");
    }

    private static final String APPEND_LONG_PREFIX = "Long/";
    private static final String[] APPEND_LONG_TEST_CASES = {
        "Long/0",
        "Long/1",
        "Long/9",
        "Long/10",
        "Long/99",
        "Long/100",
        "Long/999",
        "Long/1000",
        "Long/9999",
        "Long/10000",
        "Long/99999",
        "Long/100000",
        "Long/999999",
        "Long/1000000",
        "Long/9999999",
        "Long/10000000",
        "Long/99999999",
        "Long/100000000",
        "Long/999999999",
        "Long/1000000000",
        "Long/9999999999",
        "Long/10000000000",
        "Long/99999999999",
        "Long/100000000000",
        "Long/999999999999",
        "Long/1000000000000",
        "Long/9999999999999",
        "Long/10000000000000",
        "Long/99999999999999",
        "Long/100000000000000",
        "Long/999999999999999",
        "Long/1000000000000000",
        "Long/9999999999999999",
        "Long/10000000000000000",
        "Long/99999999999999999",
        "Long/100000000000000000",
        "Long/999999999999999999",
        "Long/1000000000000000000",
        "Long/9223372036854775807",  // Long.MAX_VALUE
        "Long/-1",
        "Long/-9",
        "Long/-10",
        "Long/-99",
        "Long/-100",
        "Long/-999",
        "Long/-1000",
        "Long/-9999",
        "Long/-10000",
        "Long/-99999",
        "Long/-100000",
        "Long/-999999",
        "Long/-1000000",
        "Long/-9999999",
        "Long/-10000000",
        "Long/-99999999",
        "Long/-100000000",
        "Long/-999999999",
        "Long/-1000000000",
        "Long/-9999999999",
        "Long/-10000000000",
        "Long/-99999999999",
        "Long/-100000000000",
        "Long/-999999999999",
        "Long/-1000000000000",
        "Long/-9999999999999",
        "Long/-10000000000000",
        "Long/-99999999999999",
        "Long/-100000000000000",
        "Long/-999999999999999",
        "Long/-1000000000000000",
        "Long/-9999999999999999",
        "Long/-10000000000000000",
        "Long/-99999999999999999",
        "Long/-100000000000000000",
        "Long/-999999999999999999",
        "Long/-1000000000000000000",
        "Long/-9223372036854775808",  // Long.MIN_VALUE
    };

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndLong(java.lang.String, long) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndLong(java.lang.String, long) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendStringAndLong(String s, long l) {
        return new StringBuilder().append(s).append(l).toString();
    }

    public static void testAppendStringAndLong() {
        for (String expected : APPEND_LONG_TEST_CASES) {
            long l = Long.valueOf(expected.substring(APPEND_LONG_PREFIX.length()));
            String result = $noinline$appendStringAndLong(APPEND_LONG_PREFIX, l);
            assertEquals(expected, result);
        }
    }

    private static final String APPEND_INT_PREFIX = "Int/";
    private static final String[] APPEND_INT_TEST_CASES = {
        "Int/0",
        "Int/1",
        "Int/9",
        "Int/10",
        "Int/99",
        "Int/100",
        "Int/999",
        "Int/1000",
        "Int/9999",
        "Int/10000",
        "Int/99999",
        "Int/100000",
        "Int/999999",
        "Int/1000000",
        "Int/9999999",
        "Int/10000000",
        "Int/99999999",
        "Int/100000000",
        "Int/999999999",
        "Int/1000000000",
        "Int/2147483647",  // Integer.MAX_VALUE
        "Int/-1",
        "Int/-9",
        "Int/-10",
        "Int/-99",
        "Int/-100",
        "Int/-999",
        "Int/-1000",
        "Int/-9999",
        "Int/-10000",
        "Int/-99999",
        "Int/-100000",
        "Int/-999999",
        "Int/-1000000",
        "Int/-9999999",
        "Int/-10000000",
        "Int/-99999999",
        "Int/-100000000",
        "Int/-999999999",
        "Int/-1000000000",
        "Int/-2147483648",  // Integer.MIN_VALUE
    };

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndInt(java.lang.String, int) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndInt(java.lang.String, int) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendStringAndInt(String s, int i) {
        return new StringBuilder().append(s).append(i).toString();
    }

    public static void testAppendStringAndInt() {
        for (String expected : APPEND_INT_TEST_CASES) {
            int i = Integer.valueOf(expected.substring(APPEND_INT_PREFIX.length()));
            String result = $noinline$appendStringAndInt(APPEND_INT_PREFIX, i);
            assertEquals(expected, result);
        }
    }

    private static final String APPEND_FLOAT_PREFIX = "Float/";
    private static final String[] APPEND_FLOAT_TEST_CASES = {
        // We're testing only exact values here, i.e. values that do not require rounding.
        "Float/1.0",
        "Float/9.0",
        "Float/10.0",
        "Float/99.0",
        "Float/100.0",
        "Float/999.0",
        "Float/1000.0",
        "Float/9999.0",
        "Float/10000.0",
        "Float/99999.0",
        "Float/100000.0",
        "Float/999999.0",
        "Float/1000000.0",
        "Float/9999999.0",
        "Float/1.0E7",
        "Float/1.0E10",
        "Float/-1.0",
        "Float/-9.0",
        "Float/-10.0",
        "Float/-99.0",
        "Float/-100.0",
        "Float/-999.0",
        "Float/-1000.0",
        "Float/-9999.0",
        "Float/-10000.0",
        "Float/-99999.0",
        "Float/-100000.0",
        "Float/-999999.0",
        "Float/-1000000.0",
        "Float/-9999999.0",
        "Float/-1.0E7",
        "Float/-1.0E10",
        "Float/0.25",
        "Float/1.625",
        "Float/9.3125",
        "Float/-0.25",
        "Float/-1.625",
        "Float/-9.3125",
    };

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndFloat(java.lang.String, float) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndFloat(java.lang.String, float) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendStringAndFloat(String s, float f) {
        return new StringBuilder().append(s).append(f).toString();
    }

    public static void testAppendStringAndFloat() {
        for (String expected : APPEND_FLOAT_TEST_CASES) {
            float f = Float.valueOf(expected.substring(APPEND_FLOAT_PREFIX.length()));
            String result = $noinline$appendStringAndFloat(APPEND_FLOAT_PREFIX, f);
            assertEquals(expected, result);
        }
        // Special values.
        assertEquals("Float/NaN", $noinline$appendStringAndFloat(APPEND_FLOAT_PREFIX, Float.NaN));
        assertEquals("Float/Infinity",
                     $noinline$appendStringAndFloat(APPEND_FLOAT_PREFIX, Float.POSITIVE_INFINITY));
        assertEquals("Float/-Infinity",
                     $noinline$appendStringAndFloat(APPEND_FLOAT_PREFIX, Float.NEGATIVE_INFINITY));
    }

    private static final String APPEND_DOUBLE_PREFIX = "Double/";
    private static final String[] APPEND_DOUBLE_TEST_CASES = {
        // We're testing only exact values here, i.e. values that do not require rounding.
        "Double/1.0",
        "Double/9.0",
        "Double/10.0",
        "Double/99.0",
        "Double/100.0",
        "Double/999.0",
        "Double/1000.0",
        "Double/9999.0",
        "Double/10000.0",
        "Double/99999.0",
        "Double/100000.0",
        "Double/999999.0",
        "Double/1000000.0",
        "Double/9999999.0",
        "Double/1.0E7",
        "Double/1.0E24",
        "Double/-1.0",
        "Double/-9.0",
        "Double/-10.0",
        "Double/-99.0",
        "Double/-100.0",
        "Double/-999.0",
        "Double/-1000.0",
        "Double/-9999.0",
        "Double/-10000.0",
        "Double/-99999.0",
        "Double/-100000.0",
        "Double/-999999.0",
        "Double/-1000000.0",
        "Double/-9999999.0",
        "Double/-1.0E7",
        "Double/-1.0E24",
        "Double/0.25",
        "Double/1.625",
        "Double/9.3125",
        "Double/-0.25",
        "Double/-1.625",
        "Double/-9.3125",
    };

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndDouble(java.lang.String, double) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendStringAndDouble(java.lang.String, double) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendStringAndDouble(String s, double d) {
        return new StringBuilder().append(s).append(d).toString();
    }

    public static void testAppendStringAndDouble() {
        for (String expected : APPEND_DOUBLE_TEST_CASES) {
            double f = Double.valueOf(expected.substring(APPEND_DOUBLE_PREFIX.length()));
            String result = $noinline$appendStringAndDouble(APPEND_DOUBLE_PREFIX, f);
            assertEquals(expected, result);
        }
        // Special values.
        assertEquals(
            "Double/NaN",
            $noinline$appendStringAndDouble(APPEND_DOUBLE_PREFIX, Double.NaN));
        assertEquals(
            "Double/Infinity",
            $noinline$appendStringAndDouble(APPEND_DOUBLE_PREFIX, Double.POSITIVE_INFINITY));
        assertEquals(
            "Double/-Infinity",
            $noinline$appendStringAndDouble(APPEND_DOUBLE_PREFIX, Double.NEGATIVE_INFINITY));
    }

    /// CHECK-START: java.lang.String Main.$noinline$appendDoubleAndFloat(double, float) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendDoubleAndFloat(double, float) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendDoubleAndFloat(double d, float f) {
        return new StringBuilder().append(d).append(f).toString();
    }

    public static void testAppendDoubleAndFloat() {
        assertEquals("1.50.325", $noinline$appendDoubleAndFloat(1.5, 0.325f));
        assertEquals("1.5E170.3125", $noinline$appendDoubleAndFloat(1.5E17, 0.3125f));
        assertEquals("1.0E8NaN", $noinline$appendDoubleAndFloat(1.0E8, Float.NaN));
        assertEquals("Infinity0.5", $noinline$appendDoubleAndFloat(Double.POSITIVE_INFINITY, 0.5f));
        assertEquals("2.5-Infinity", $noinline$appendDoubleAndFloat(2.5, Float.NEGATIVE_INFINITY));
    }

    public static String $noinline$appendStringAndString(String s1, String s2) {
        return new StringBuilder().append(s1).append(s2).toString();
    }

    public static void testAppendStringAndString() {
        assertEquals("nullnull", $noinline$appendStringAndString(null, null));
        assertEquals("nullTEST", $noinline$appendStringAndString(null, "TEST"));
        assertEquals("TESTnull", $noinline$appendStringAndString("TEST", null));
        assertEquals("abcDEFGH", $noinline$appendStringAndString("abc", "DEFGH"));
        // Test with a non-ASCII character.
        assertEquals("test\u0131", $noinline$appendStringAndString("test", "\u0131"));
        assertEquals("\u0131test", $noinline$appendStringAndString("\u0131", "test"));
        assertEquals("\u0131test\u0131", $noinline$appendStringAndString("\u0131", "test\u0131"));
    }

    /// CHECK-START: java.lang.String Main.$noinline$appendSLILC(java.lang.String, long, int, long, char) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendSLILC(java.lang.String, long, int, long, char) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$appendSLILC(String s,
                                               long l1,
                                               int i,
                                               long l2,
                                               char c) {
        return new StringBuilder().append(s)
                                  .append(l1)
                                  .append(i)
                                  .append(l2)
                                  .append(c).toString();
    }

    public static void testMiscelaneous() {
        assertEquals("x17-1q",
                     $noinline$appendSLILC("x", 1L, 7, -1L, 'q'));
        assertEquals("null17-1q",
                     $noinline$appendSLILC(null, 1L, 7, -1L, 'q'));
        assertEquals("x\u013117-1q",
                     $noinline$appendSLILC("x\u0131", 1L, 7, -1L, 'q'));
        assertEquals("x427-1q",
                     $noinline$appendSLILC("x", 42L, 7, -1L, 'q'));
        assertEquals("x1-42-1q",
                     $noinline$appendSLILC("x", 1L, -42, -1L, 'q'));
        assertEquals("x17424242q",
                     $noinline$appendSLILC("x", 1L, 7, 424242L, 'q'));
        assertEquals("x17-1\u0131",
                     $noinline$appendSLILC("x", 1L, 7, -1L, '\u0131'));
    }

    public static String $inline$testInlineInner(StringBuilder sb, String s, int i) {
        return sb.append(s).append(i).toString();
    }

    /// CHECK-START: java.lang.String Main.$noinline$testInlineOuter(java.lang.String, int) instruction_simplifier$after_inlining (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$testInlineOuter(java.lang.String, int) instruction_simplifier$after_inlining (after)
    /// CHECK:                  StringBuilderAppend
    public static String $noinline$testInlineOuter(String s, int i) {
        StringBuilder sb = new StringBuilder();
        return $inline$testInlineInner(sb, s, i);
    }

    public static void testInline() {
        assertEquals("x42", $noinline$testInlineOuter("x", 42));
    }

    /// CHECK-START: java.lang.String Main.$noinline$appendNothing() instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: java.lang.String Main.$noinline$appendNothing() instruction_simplifier (after)
    /// CHECK-NOT:              StringBuilderAppend
    public static String $noinline$appendNothing() {
        return new StringBuilder().toString();
    }

    public static void testNoArgs() {
        assertEquals("", $noinline$appendNothing());
    }

    /// CHECK-START: boolean Main.$noinline$testAppendEquals(java.lang.String, int) instruction_simplifier (before)
    /// CHECK-NOT:              StringBuilderAppend

    /// CHECK-START: boolean Main.$noinline$testAppendEquals(java.lang.String, int) instruction_simplifier (after)
    /// CHECK:                  StringBuilderAppend
    public static boolean $noinline$testAppendEquals(String s, int i) {
      // Regression test for b/151107293 .
      // When a string is used as both receiver and argument of String.equals(), we DCHECK()
      // that it cannot be null. However, when replacing the call to StringBuilder.toString()
      // with the HStringBuilderAppend(), the former reported CanBeNull() as false and
      // therefore no explicit null checks were needed, but the replacement reported
      // CanBeNull() as true, so when the result was used in String.equals() for both
      // receiver and argument, the DCHECK() failed. This was fixed by overriding
      // CanBeNull() in HStringBuilderAppend to correctly return false; the string that
      // previously didn't require null check still does not require it.
      String str = new StringBuilder().append(s).append(i).toString();
      return str.equals(str);
    }

    public static void testEquals() {
      if (!$noinline$testAppendEquals("Test", 42)) {
        throw new Error("str.equals(str) is false");
      }
    }

    public static void assertEquals(String expected, String actual) {
        if (!expected.equals(actual)) {
            throw new AssertionError("Expected: " + expected + ", actual: " + actual);
        }
    }
}