src/test/java/org/apache/bcel/verifier/VerifyBadClassesTestCase.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
 *
 *   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 org.apache.bcel.verifier;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.bcel.classfile.JavaClass;
import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecuteResultHandler;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteException;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.SystemProperties;
import org.junit.jupiter.api.Test;

/**
 * Test a number of BCEL issues related to running the Verifier on a bad or malformed .class file and having it die with
 * an exception rather than report a verification failure.
 */
public class VerifyBadClassesTestCase {

    private List<String> buildVerifyCommand(final String className, final String testDir) {
        final List<String> command = new ArrayList<>();
        command.add("java");
        command.add("-ea");

        command.add("-classpath");
        command.add(SystemProperties.getJavaClassPath() + ":" + testDir);

        command.add("org.apache.bcel.verifier.Verifier");
        command.add(className);

        return command;
    }

    /**
     * Runs the given command synchronously in the given directory. If the command completes normally, returns a
     * {@link Status} object capturing the command, exit status, and output from the process.
     *
     * @param command the command to be run in the process
     * @return a String capturing the error output of executing the command
     * @throws ExecuteException if executor fails
     * @throws IOException if executor fails
     */
    private String run(final List<String> command) throws ExecuteException, IOException {

        /** The process timeout in milliseconds. Defaults to 30 seconds. */
        final long timeout = 30 * 1000;

        final String[] args = command.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
        final CommandLine cmdLine = new CommandLine(args[0]); // constructor requires executable name
        cmdLine.addArguments(Arrays.copyOfRange(args, 1, args.length));

        final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler();
        final DefaultExecutor executor = new DefaultExecutor();

        final ExecuteWatchdog watchdog = new ExecuteWatchdog(timeout);
        executor.setWatchdog(watchdog);

        final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        final ByteArrayOutputStream errStream = new ByteArrayOutputStream();
        final PumpStreamHandler streamHandler = new PumpStreamHandler(outStream, errStream);
        executor.setStreamHandler(streamHandler);
        executor.execute(cmdLine, resultHandler);

        int exitValue = -1;
        try {
            resultHandler.waitFor();
            exitValue = resultHandler.getExitValue();
        } catch (final InterruptedException e) {
            // Ignore exception, but watchdog.killedProcess() records that the process timed out.
        }
        final boolean timedOut = executor.isFailure(exitValue) && watchdog.killedProcess();
        if (timedOut) {
            return "Command timed out.";
        }

        // return "stdout: " + outStream.toString() + "\nstderr: " + errStream.toString();
        return errStream.toString();
    }

    /**
     * BCEL-303: AssertionViolatedException in Pass 3A Verification of invoke instructions
     */
    @Test
    public void testB303() {
        testVerify("issue303/example", "A");
    }

    /**
     * BCEL-307: ClassFormatException thrown in Pass 3A verification
     */
    @Test
    public void testB307() {
        testVerify("issue307/example", "A");
    }

    /**
     * BCEL-308: NullPointerException in Verifier Pass 3A
     */
    @Test
    public void testB308() {
        testVerify("issue308", "Hello");
    }

    /**
     * BCEL-309: NegativeArraySizeException when Code attribute length is negative
     */
    @Test
    public void testB309() {
        testVerify("issue309", "Hello");
    }

    /**
     * BCEL-310: ArrayIndexOutOfBounds in Verifier Pass 3A
     */
    @Test
    public void testB310() {
        testVerify("issue310", "Hello");
    }

    /**
     * BCEL-311: ClassCastException in Verifier Pass 2
     */
    @Test
    public void testB311() {
        testVerify("issue311", "Hello");
    }

    /**
     * BCEL-312: AssertionViolation: INTERNAL ERROR Please adapt StringRepresentation to deal with ConstantPackage in
     * Verifier Pass 2
     */
    @Test
    public void testB312() {
        testVerify("issue312", "Hello");
    }

    /**
     * BCEL-313: ClassFormatException: Invalid signature: Ljava/lang/String)V in Verifier Pass 3A
     */
    @Test
    public void testB313() {
        testVerify("issue313", "Hello");
    }

    /**
     * BCEL-337: StringIndexOutOfBounds in Pass 2 Verification of empty method names in the constant pool
     */
    @Test
    public void testB337() {
        testVerify("issue337/example", "A");
    }

    /**
     * Note that the test classes are bad or malformed and this causes the animal-sniffer-maven-plugin to fail during the
     * build/verification process. I was not able to figure out the right incantations to get it to ignore these files.
     * Hence, their file extension is '.classx' to avoid this problem. As part of the test process we rename them to
     * '.class' and then back to '.classx' after the test. If we can get animal-sniffer to ignore the files, these steps
     * could be omitted.
     */
    private void testVerify(final String directory, final String className) {
        final String baseDir = "target/test-classes";
        final String testDir = baseDir + (directory.isEmpty() ? "" : File.separator + directory);

        final File origFile = new File(testDir, className + ".classx");
        final File testFile = new File(testDir, className + JavaClass.EXTENSION);

        if (!origFile.renameTo(testFile)) {
            fail("Failed to rename orig file");
        }

        String result;
        try {
            result = run(buildVerifyCommand(className, testDir));
        } catch (final Exception e) {
            result = e.getMessage();
        }

        if (!testFile.renameTo(origFile)) {
            fail("Failed to rename test file");
        }

        assertTrue(result.isEmpty(), result);
    }
}