| // Copyright 2017 The Bazel Authors. All rights reserved. |
| // |
| // 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 testsubjects; |
| |
| import java.io.BufferedReader; |
| import java.io.Closeable; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.sql.Connection; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.util.List; |
| import java.util.function.BinaryOperator; |
| import java.util.regex.Pattern; |
| import java.util.regex.PatternSyntaxException; |
| |
| /** |
| * Test subject for testing bytecode type inference {@link |
| * com.google.devtools.build.android.desugar.BytecodeTypeInference} |
| */ |
| public class TestSubject { |
| |
| private static int VALUE_ONE = 1; |
| private static int VALUE_TWO = 2; |
| |
| static int catchTest(Object key, Object value) { |
| if (!(key instanceof String)) { |
| return VALUE_ONE; |
| } |
| try { |
| Pattern.compile((String) key); |
| } catch (PatternSyntaxException e) { |
| return VALUE_TWO; |
| } |
| return VALUE_ONE; |
| } |
| |
| public static void assertEquals(String message, double expected, double actual, double delta) { |
| if (Double.compare(expected, actual) == 0) { |
| return; |
| } |
| if (!(Math.abs(expected - actual) <= delta)) { |
| throw new RuntimeException(message + new Double(expected) + new Double(actual)); |
| } |
| } |
| |
| /** |
| * A simple resource implementation which implements Closeable. |
| */ |
| public static class SimpleResource implements Closeable { |
| |
| public void call(boolean throwException) { |
| if (throwException) { |
| throw new RuntimeException("exception in call()"); |
| } |
| } |
| |
| @Override |
| public void close() throws IOException { |
| throw new IOException("exception in close()."); |
| } |
| } |
| |
| public static void simpleTryWithResources() throws Exception { |
| // Throwable.addSuppressed(Throwable) should be called in the following block. |
| try (SimpleResource resource = new SimpleResource()) { |
| resource.call(true); |
| } |
| } |
| |
| private static long internalCompare(long a, long b, BinaryOperator<Long> func) { |
| return func.apply(a, b); |
| } |
| |
| public void closeResourceArray(Statement[] resources) throws Exception { |
| for (Statement stmt : resources) { |
| closeResource(stmt, null); |
| } |
| } |
| |
| public void closeResourceMultiArray(Statement[][] resources) throws Exception { |
| for (Statement[] stmts : resources) { |
| for (Statement stmt : stmts) { |
| closeResource(stmt, null); |
| } |
| } |
| } |
| |
| public void closeResourceArrayList(List<Statement> resources) throws Exception { |
| for (Statement stmt : resources) { |
| closeResource(stmt, null); |
| } |
| } |
| |
| public void closeSqlStmt(Connection connection) throws Exception { |
| Statement stmt = null; |
| |
| try { |
| stmt = connection.createStatement(); |
| } catch (SQLException e) { |
| closeResource(stmt, e); |
| } |
| closeResource(stmt, null); |
| } |
| |
| public void closeResource(AutoCloseable resource, Throwable suppressor) throws Exception { |
| if (resource == null) { |
| return; |
| } |
| try { |
| resource.close(); |
| } catch (Exception e) { |
| if (suppressor != null) { |
| suppressor.addSuppressed(e); |
| } |
| throw e; |
| } |
| } |
| |
| public static int intAdd(int i, int j) { |
| int tmp = i; |
| tmp++; |
| ++tmp; |
| tmp += j; |
| tmp--; |
| --tmp; |
| tmp -= j; |
| tmp *= j; |
| tmp /= j; |
| tmp = tmp % j; |
| tmp = tmp << 2; |
| tmp = tmp >> j; |
| tmp = tmp >>> 3; |
| long longTemp = tmp; |
| longTemp = longTemp << j; |
| return (int) longTemp; |
| } |
| |
| public static Number createNumberWithDiamond(boolean flag) { |
| Number n = null; |
| if (flag) { |
| n = new Integer(1); |
| } else { |
| n = new Double(1); |
| } |
| return n; |
| } |
| |
| public static Object[][] createMultiObjectArray() { |
| return new Object[0][0]; |
| } |
| |
| public static Object[] createObjectArray() { |
| return new Object[0]; |
| } |
| |
| public static int[] createIntArray() { |
| return new int[0]; |
| } |
| |
| public static void staticEmpty1() {} |
| |
| public void instanceEmpty1() {} |
| |
| public static boolean identity(boolean result) { |
| return result; |
| } |
| |
| public static boolean identity2(boolean result) { |
| boolean temp = result; |
| return temp; |
| } |
| |
| public void readFile(File file) throws Exception { |
| try (AutoCloseable reader = new BufferedReader(new FileReader(file)); |
| AutoCloseable reader2 = new BufferedReader(new FileReader(file)); |
| AutoCloseable reader3 = new BufferedReader(new FileReader(file)); |
| AutoCloseable reader4 = new BufferedReader(new FileReader(file))) { |
| |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| public double testWithDoubleTypes() { |
| double result = 1; |
| for (double i = 1; i < 22; i = i + 1) { |
| System.out.println(i); |
| result += i; |
| } |
| return result; |
| } |
| |
| public float testWithFloatAndDoubleTypes() { |
| float result = 1; |
| for (double i = 1; i < 22; i = i + 1) { |
| System.out.println(i); |
| result += (float) i; |
| } |
| return result; |
| } |
| } |