src/test/java/org/apache/bcel/util/BCELifierTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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
 *
 *   https://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 org.apache.bcel.util;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.OutputStream;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.bcel.AbstractTest;
import org.apache.bcel.HelloWorldCreator;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Utility;
import org.apache.bcel.generic.BinaryOpCreator;
import org.apache.commons.lang3.SystemProperties;
import org.apache.commons.lang3.SystemUtils;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledForJreRange;
import org.junit.jupiter.api.condition.JRE;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

class BCELifierTest extends AbstractTest {

    private static Pattern CANON1 = Pattern.compile("#\\d+"); // numbers may vary in length
    private static Pattern CANON2 = Pattern.compile(" +"); // collapse spaces
    private static Pattern CANON3 = Pattern.compile("//.+");

    private static final String EOL = System.lineSeparator();
    public static final String CLASSPATH = "." + File.pathSeparator + SystemProperties.getJavaClassPath();

    // Canonicalise the javap output so it compares better
    private String canonHashRef(String input) {
        input = CANON1.matcher(input).replaceAll("#n");
        input = CANON2.matcher(input).replaceAll(" ");
        return CANON3.matcher(input).replaceAll("");
    }

    private String exec(final File workDir, final String... args) throws Exception {
        // System.out.print(workDir + ": ");
        // Stream.of(args).forEach(e -> System.out.print(e + " "));
        // System.out.println();
        final ProcessBuilder pb = new ProcessBuilder(args);
        pb.directory(workDir);
        pb.redirectErrorStream(true);
        final Process proc = pb.start();
        try (BufferedInputStream is = new BufferedInputStream(proc.getInputStream())) {
            final byte[] buff = new byte[2048];
            int len;

            final StringBuilder sb = new StringBuilder();
            while ((len = is.read(buff)) != -1) {
                sb.append(new String(buff, 0, len));
            }
            final String output = sb.toString();
            assertEquals(0, proc.waitFor(), output);
            return output;
        }
    }

    private String getAppJava() {
        return getJavaHomeApp("java");
    }

    private String getAppJavaC() {
        return getJavaHomeApp("javac");
    }

    private String getAppJavaP() {
        return getJavaHomeApp("javap");
    }

    private String getJavaHomeApp(final String app) {
        final Path path = getJavaHomeBinPath().resolve(app);
        if (Files.exists(path)) {
            return path.toAbsolutePath().toString();
        }
        if (SystemUtils.IS_OS_WINDOWS && Files.exists(getJavaHomeBinPath().resolve(app + ".exe"))) {
            return path.toAbsolutePath().toString();
        }
        return app;
    }

    private Path getJavaHomeBinPath() {
        return SystemUtils.getJavaHomePath().resolve("bin");
    }

    @ParameterizedTest
    @ValueSource(strings = {
    // @formatter:off
        "iadd 3 2 = 5",
        "isub 3 2 = 1",
        "imul 3 2 = 6",
        "idiv 3 2 = 1",
        "irem 3 2 = 1",
        "iand 3 2 = 2",
        "ior 3 2 = 3",
        "ixor 3 2 = 1",
        "ishl 4 1 = 8",
        "ishr 4 1 = 2",
        "iushr 4 1 = 2",
        "ladd 3 2 = 5",
        "lsub 3 2 = 1",
        "lmul 3 2 = 6",
        "ldiv 3 2 = 1",
        "lrem 3 2 = 1",
        "land 3 2 = 2",
        "lor 3 2 = 3",
        "lxor 3 2 = 1",
        "lshl 4 1 = 8",
        "lshr 4 1 = 2",
        "lushr 4 1 = 2",
        "fadd 3 2 = 5.0",
        "fsub 3 2 = 1.0",
        "fmul 3 2 = 6.0",
        "fdiv 3 2 = 1.5",
        "frem 3 2 = 1.0",
        "dadd 3 2 = 5.0",
        "dsub 3 2 = 1.0",
        "dmul 3 2 = 6.0",
        "ddiv 3 2 = 1.5",
        "drem 3 2 = 1.0"
    // @formatter:on
    })
    void testBinaryOp(final String exp) throws Exception {
        BinaryOpCreator.main(new String[] {});
        final File workDir = new File("target");
        final Pattern pattern = Pattern.compile("([a-z]{3,5}) ([-+]?\\d*\\.?\\d+) ([-+]?\\d*\\.?\\d+) = ([-+]?\\d*\\.?\\d+)");
        final Matcher matcher = pattern.matcher(exp);
        assertTrue(matcher.matches());
        final String op = matcher.group(1);
        final String a = matcher.group(2);
        final String b = matcher.group(3);
        final String expected = matcher.group(4);
        final String javaAgent = getJavaAgent();
        if (javaAgent == null) {
            assertEquals(expected + EOL, exec(workDir, getAppJava(), "-cp", CLASSPATH, "org.apache.bcel.generic.BinaryOp", op, a, b));
        } else {
            final String runtimeExecJavaAgent = javaAgent.replace("jacoco.exec", "jacoco_org.apache.bcel.generic.BinaryOp.exec");
            assertEquals(expected + EOL, exec(workDir, getAppJava(), runtimeExecJavaAgent, "-cp", CLASSPATH, "org.apache.bcel.generic.BinaryOp", op, a, b));
        }
    }

    private void testClassOnPath(final String javaClassFileName) throws Exception {
        final File workDir = new File("target", getClass().getSimpleName());
        Files.createDirectories(workDir.getParentFile().toPath());
        final File inFile = new File(javaClassFileName);
        final JavaClass javaClass = BCELifier.getJavaClass(inFile.getName().replace(JavaClass.EXTENSION, ""));
        assertNotNull(javaClass);
        // Gets javap output of the input class
        // System.out.println(exec(null, getJavaP(), "-version"));
        final String javaClassName = javaClass.getClassName();
        final String javapOutInital = exec(null, getAppJavaP(), "-cp", CLASSPATH, "-p", "-c", javaClassName);
        final String outCreatorFileName = javaClass.getSourceFilePath().replace(".java", "Creator.java");
        final File outCreatorFile = new File(workDir, outCreatorFileName);
        Files.createDirectories(outCreatorFile.getParentFile().toPath());
        final String javaAgent = getJavaAgent();
        final String bcelifierClassName = BCELifier.class.getName();
        final String creatorJavaSource;
        // Creates the BCEL Java app source in creatorJavaSource
        if (javaAgent == null) {
            creatorJavaSource = exec(workDir, getAppJava(), "-cp", CLASSPATH, bcelifierClassName, javaClassName);
        } else {
            final String runtimeExecJavaAgent = javaAgent.replace("jacoco.exec", "jacoco_" + inFile.getName() + ".exec");
            creatorJavaSource = exec(workDir, getAppJava(), runtimeExecJavaAgent, "-cp", CLASSPATH, bcelifierClassName, javaClassName);
        }
        // Write the BCEL Java app source to a file
        Files.write(outCreatorFile.toPath(), creatorJavaSource.getBytes(StandardCharsets.UTF_8));
        // Compiles the BCEL Java app
        assertEquals("", exec(workDir, getAppJavaC(), "-cp", CLASSPATH, outCreatorFileName.toString()));
        final String creatorClassName = javaClassName + "Creator";
        // Runs the BCEL Java app to create a class file
        if (javaAgent == null) {
            assertEquals("", exec(workDir, getAppJava(), "-cp", CLASSPATH, creatorClassName));
        } else {
            final String runtimeExecJavaAgent = javaAgent.replace("jacoco.exec", "jacoco_" + Utility.pathToPackage(outCreatorFileName) + ".exec");
            assertEquals("", exec(workDir, getAppJava(), runtimeExecJavaAgent, "-cp", CLASSPATH, creatorClassName));
        }
        // Runs javap on the BCEL generated class file
        final String javapOutput = exec(workDir, getAppJavaP(), "-p", "-c", inFile.getName());
        // Finally compares the output of the roundtrip
        assertEquals(canonHashRef(javapOutInital), canonHashRef(javapOutput));
    }

    @Test
    void testHelloWorld() throws Exception {
        HelloWorldCreator.main(new String[] {});
        final File workDir = new File("target");
        final String javaAgent = getJavaAgent();
        if (javaAgent == null) {
            assertEquals("Hello World!" + EOL, exec(workDir, getAppJava(), "-cp", CLASSPATH, "org.apache.bcel.HelloWorld"));
        } else {
            final String runtimeExecJavaAgent = javaAgent.replace("jacoco.exec", "jacoco_org.apache.bcel.HelloWorld.exec");
            assertEquals("Hello World!" + EOL, exec(workDir, getAppJava(), runtimeExecJavaAgent, "-cp", CLASSPATH, "org.apache.bcel.HelloWorld"));
        }
    }

    /*
     * Dumps a class using "javap" and compare with the same class recreated using BCELifier, "javac", "java" and dumped with "javap".
     *
     * TODO: detect if JDK present and skip test if not
     */
    @ParameterizedTest
    @ValueSource(strings = {
    // @formatter:off
        "org.apache.commons.lang.math.Fraction.class",
        "org.apache.commons.lang.exception.NestableDelegate.class",
        "org.apache.commons.lang.builder.CompareToBuilder.class",
        "org.apache.commons.lang.builder.ToStringBuilder.class",
        "org.apache.commons.lang.SerializationUtils.class",
        "org.apache.commons.lang.ArrayUtils.class",
        "target/test-classes/Java4Example.class"
    // @formatter:on
    })
    void testJavapCompare(final String pathToClass) throws Exception {
        testClassOnPath(pathToClass);
    }

    /*
     * See https://issues.apache.org/jira/browse/BCEL-378
     */
    @ParameterizedTest
    @ValueSource(strings = {
    // @formatter:off
        "target/test-classes/Java8Example.class",
        "target/test-classes/Java8Example2.class",
    // @formatter:on
    })
    @DisabledForJreRange(min = JRE.JAVA_25)
    void testJavapCompareJava25KnownBroken(final String pathToClass) throws Exception {
        testClassOnPath(pathToClass);
    }

    @Test
    void testMainNoArg() throws Exception {
        final PrintStream sysout = System.out;
        try {
            final ByteArrayOutputStream out = new ByteArrayOutputStream();
            System.setOut(new PrintStream(out));
            BCELifier.main(new String[0]);
            final String outputNoArgs = new String(out.toByteArray());
            assertEquals("Usage: BCELifier className" + EOL + "\tThe class must exist on the classpath" + EOL, outputNoArgs);
        } finally {
            System.setOut(sysout);
        }
    }

    @ParameterizedTest
    @ValueSource(strings = { "StackMapExample", "StackMapExample2" })
    void testStackMap(final String className) throws Exception {
        testJavapCompare(className);
        final File workDir = new File("target");
        assertEquals("Hello World" + EOL, exec(workDir, getAppJava(), "-cp", CLASSPATH, className, "Hello"));
    }

    @Test
    void testStart() throws Exception {
        final OutputStream os = new ByteArrayOutputStream();
        final JavaClass javaClass = BCELifier.getJavaClass("Java8Example");
        assertNotNull(javaClass);
        final BCELifier bcelifier = new BCELifier(javaClass, os);
        bcelifier.start();
    }
}