jmockit.assist.JunitLaunchListener.java Source code

Introduction

Here is the source code for jmockit.assist.JunitLaunchListener.java

Source

/*
 * Copyright (c) 2012 Andrejs Jermakovics.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Andrejs Jermakovics - initial implementation
 */
package jmockit.assist;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

import jmockit.assist.prefs.Prefs;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.IValueVariable;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchesListener2;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.junit.JUnitCorePlugin;

/**
 * Listens for JUnit launches and adds JMockit javaagent JVM argument
 */
@SuppressWarnings("restriction")
final class JunitLaunchListener implements ILaunchesListener2 {
    public static final String VM_ARGS = "org.eclipse.jdt.launching.VM_ARGUMENTS";
    public static final String PROJ_ATTR = "org.eclipse.jdt.launching.PROJECT_ATTR";

    public static final String JMOCKIT_VAR_NAME = "jmockit_javaagent";
    public static final String JMOCKIT_VAR = "${" + JMOCKIT_VAR_NAME + "}";

    private final List<ILaunch> modifiedLaunches = new ArrayList<ILaunch>();

    @Override
    public void launchesTerminated(final ILaunch[] launches) {
        for (ILaunch iLaunch : launches) {
            if (modifiedLaunches.contains(iLaunch)) {
                modifiedLaunches.remove(iLaunch);
                try {
                    removeJavaAgentVmArg(iLaunch.getLaunchConfiguration());
                } catch (CoreException e) {
                    Activator.log(e);
                }
            }
        }
    }

    @Override
    public void launchesRemoved(final ILaunch[] launches) {
    }

    @Override
    public void launchesChanged(final ILaunch[] launches) {
    }

    @Override
    public void launchesAdded(final ILaunch[] launches) {
        if (Activator.getPrefStore().contains(Prefs.PROP_ADD_JAVAAGENT)
                && !Activator.getPrefStore().getBoolean(Prefs.PROP_ADD_JAVAAGENT)) {
            return;
        }

        for (ILaunch launch : launches) {
            ILaunchConfiguration conf = launch.getLaunchConfiguration();
            try {
                String pluginId = conf.getType().getPluginIdentifier();

                if (JUnitCorePlugin.getPluginId().equals(pluginId)) {
                    if (addJavaAgentVmArg(conf)) {
                        modifiedLaunches.add(launch);
                    }
                }
            } catch (CoreException e) {
                Activator.log(e);
            }
        }
    }

    public void setRunConfVmArgs(final ILaunchConfiguration conf, final String vmargs) throws CoreException {
        ILaunchConfigurationWorkingCopy confWc = conf.getWorkingCopy();
        confWc.setAttribute(JunitLaunchListener.VM_ARGS, vmargs);
        confWc.doSave();
    }

    public void setOrCreateVariable(final String value) throws CoreException {
        IStringVariableManager varMan = VariablesPlugin.getDefault().getStringVariableManager();
        IValueVariable var = varMan.getValueVariable(JunitLaunchListener.JMOCKIT_VAR_NAME);

        if (var == null) {
            var = varMan.newValueVariable(JunitLaunchListener.JMOCKIT_VAR_NAME, value, false, value);
            varMan.addVariables(new IValueVariable[] { var });
        } else {
            var.setValue(value);
            var.setDescription(value);
        }
    }

    public void removeJavaAgentVmArg(final ILaunchConfiguration conf) throws CoreException {
        String vmargs = conf.getAttribute(JunitLaunchListener.VM_ARGS, "");
        if (vmargs.endsWith(JunitLaunchListener.JMOCKIT_VAR)) {
            vmargs = vmargs.substring(0, vmargs.length() - JunitLaunchListener.JMOCKIT_VAR.length() - 1);
            setRunConfVmArgs(conf, vmargs);
        }
    }

    public boolean addJavaAgentVmArg(final ILaunchConfiguration conf) throws CoreException {
        boolean added = false;
        String vmargs = conf.getAttribute(JunitLaunchListener.VM_ARGS, "");
        String project = conf.getAttribute(JunitLaunchListener.PROJ_ATTR, "");

        IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
        IJavaProject jproj = javaModel.getJavaProject(project);

        IType mockitType = jproj.findType(MockUtil.MOCK);
        if (mockitType == null) {
            mockitType = jproj.findType(MockUtil.MOCKIT);
        }

        if (mockitType != null) {
            IPackageFragmentRoot root = (IPackageFragmentRoot) mockitType
                    .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);

            if (root != null && root.isArchive()) // its a jar
            {
                String jarPath = root.getPath().toOSString();
                if (root.getResource() != null) {
                    jarPath = root.getResource().getRawLocation().toString();
                }

                if (new File(jarPath).exists()) {
                    String javaagentArg = "-javaagent:\"" + jarPath + "\"";
                    setOrCreateVariable(javaagentArg);

                    if (!vmargs.contains(JunitLaunchListener.JMOCKIT_VAR) && !vmargs.contains("-javaagent")) {
                        setRunConfVmArgs(conf, vmargs + " " + JunitLaunchListener.JMOCKIT_VAR);
                        added = true;
                    }
                } else {
                    Activator.log(new FileNotFoundException(jarPath));
                }
            }
        }

        return added;
    }
}