diff --git a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java
index f9bfceffa3ba..1f9444abfad1 100644
--- a/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java
+++ b/java/execution/impl/src/com/intellij/execution/application/ApplicationConfiguration.java
@@ -65,7 +65,11 @@ public class ApplicationConfiguration extends ModuleBasedConfiguration<JavaRunCo
   public boolean PASS_PARENT_ENVS = true;
 
   public ApplicationConfiguration(final String name, final Project project, ApplicationConfigurationType applicationConfigurationType) {
-    super(name, new JavaRunConfigurationModule(project, true), applicationConfigurationType.getConfigurationFactories()[0]);
+    this(name, project, applicationConfigurationType.getConfigurationFactories()[0]);
+  }
+
+  protected ApplicationConfiguration(final String name, final Project project, final ConfigurationFactory factory) {
+    super(name, new JavaRunConfigurationModule(project, true), factory);
   }
 
   public void setMainClass(final PsiClass psiClass) {
@@ -76,7 +80,7 @@ public class ApplicationConfiguration extends ModuleBasedConfiguration<JavaRunCo
   }
 
   public RunProfileState getState(@NotNull final Executor executor, @NotNull final ExecutionEnvironment env) throws ExecutionException {
-    final JavaCommandLineState state = new MyJavaCommandLineState(env);
+    final JavaCommandLineState state = new JavaApplicationCommandLineState(this, env);
     state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
     return state;
   }
@@ -243,20 +247,31 @@ public class ApplicationConfiguration extends ModuleBasedConfiguration<JavaRunCo
     PathMacroManager.getInstance(getProject()).collapsePathsRecursively(element);
   }
 
-  private class MyJavaCommandLineState extends JavaCommandLineState {
-    public MyJavaCommandLineState(final ExecutionEnvironment environment) {
+  public static class JavaApplicationCommandLineState extends JavaCommandLineState {
+
+    private final ApplicationConfiguration myConfiguration;
+
+    public JavaApplicationCommandLineState(@NotNull final ApplicationConfiguration configuration,
+                                           final ExecutionEnvironment environment) {
       super(environment);
+      myConfiguration = configuration;
     }
 
     protected JavaParameters createJavaParameters() throws ExecutionException {
       final JavaParameters params = new JavaParameters();
-      final int classPathType = JavaParametersUtil.getClasspathType(getConfigurationModule(), MAIN_CLASS_NAME, false);
-      JavaParametersUtil.configureModule(getConfigurationModule(), params, classPathType, ALTERNATIVE_JRE_PATH_ENABLED ? ALTERNATIVE_JRE_PATH : null);
-      JavaParametersUtil.configureConfiguration(params, ApplicationConfiguration.this);
+      final JavaRunConfigurationModule module = myConfiguration.getConfigurationModule();
+      
+      final int classPathType = JavaParametersUtil.getClasspathType(module,
+                                                                    myConfiguration.MAIN_CLASS_NAME, 
+                                                                    false);
+      final String jreHome = myConfiguration.ALTERNATIVE_JRE_PATH_ENABLED ? myConfiguration.ALTERNATIVE_JRE_PATH 
+                                                                          : null;
+      JavaParametersUtil.configureModule(module, params, classPathType, jreHome);
+      JavaParametersUtil.configureConfiguration(params, myConfiguration);
 
-      params.setMainClass(MAIN_CLASS_NAME);
+      params.setMainClass(myConfiguration.MAIN_CLASS_NAME);
       for(RunConfigurationExtension ext: Extensions.getExtensions(RunConfigurationExtension.EP_NAME)) {
-        ext.updateJavaParameters(ApplicationConfiguration.this, params, getRunnerSettings());
+        ext.updateJavaParameters(myConfiguration, params, getRunnerSettings());
       }
 
       return params;
@@ -267,8 +282,12 @@ public class ApplicationConfiguration extends ModuleBasedConfiguration<JavaRunCo
     protected OSProcessHandler startProcess() throws ExecutionException {
       final OSProcessHandler handler = super.startProcess();
       RunnerSettings runnerSettings = getRunnerSettings();
-      JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(ApplicationConfiguration.this, handler, runnerSettings);
+      JavaRunConfigurationExtensionManager.getInstance().attachExtensionsToProcess(myConfiguration, handler, runnerSettings);
       return handler;
     }
+
+    protected ApplicationConfiguration getConfiguration() {
+      return myConfiguration;
+    }
   }
 }
diff --git a/platform/lang-api/src/com/intellij/execution/configurations/CommandLineState.java b/platform/lang-api/src/com/intellij/execution/configurations/CommandLineState.java
index 5d983a7f5bdb..a8d12914c73d 100644
--- a/platform/lang-api/src/com/intellij/execution/configurations/CommandLineState.java
+++ b/platform/lang-api/src/com/intellij/execution/configurations/CommandLineState.java
@@ -31,6 +31,7 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.DumbAware;
 import com.intellij.openapi.util.IconLoader;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 public abstract class CommandLineState implements RunnableState {
   private static final Logger LOG = Logger.getInstance("#com.intellij.execution.configurations.CommandLineState");
@@ -50,16 +51,23 @@ public abstract class CommandLineState implements RunnableState {
     return myEnvironment.getConfigurationSettings();
   }
 
-  public ExecutionResult execute(@NotNull final Executor executor, @NotNull ProgramRunner runner) throws ExecutionException {
+  public ExecutionResult execute(@NotNull final Executor executor, @NotNull final ProgramRunner runner) throws ExecutionException {
     final ProcessHandler processHandler = startProcess();
-    final TextConsoleBuilder builder = getConsoleBuilder();
-    final ConsoleView console = builder != null ? builder.getConsole() : null;
+    final ConsoleView console = createConsole(executor);
     if (console != null) {
       console.attachToProcess(processHandler);
     }
     return new DefaultExecutionResult(console, processHandler, createActions(console, processHandler, executor));
   }
 
+  @Nullable
+  protected ConsoleView createConsole(@NotNull final Executor executor) throws ExecutionException {
+    final TextConsoleBuilder builder = getConsoleBuilder();
+    
+    return builder != null ? builder.getConsole() 
+                           : null;
+  }
+
   @NotNull
   protected abstract ProcessHandler startProcess() throws ExecutionException;
 
diff --git a/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java b/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java
index 9b3b2b91c728..d5990a41826b 100644
--- a/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java
+++ b/platform/smRunner/src/com/intellij/execution/testframework/sm/SMTestRunnerConnectionUtil.java
@@ -71,11 +71,11 @@ public class SMTestRunnerConnectionUtil {
    * @throws ExecutionException If IDEA cannot execute process this Exception will
    * be caught and shown in error message box
    */
-  public static BaseTestsOutputConsoleView attachRunner(@NotNull final String testFrameworkName,
-                                                        @NotNull final ProcessHandler processHandler,
-                                                        @NotNull final TestConsoleProperties consoleProperties,
-                                                        final RunnerSettings runnerSettings,
-                                                        final ConfigurationPerRunnerSettings configurationSettings
+  public static BaseTestsOutputConsoleView createAndAttachConsole(@NotNull final String testFrameworkName,
+                                                                  @NotNull final ProcessHandler processHandler,
+                                                                  @NotNull final TestConsoleProperties consoleProperties,
+                                                                  final RunnerSettings runnerSettings,
+                                                                  final ConfigurationPerRunnerSettings configurationSettings
   ) throws ExecutionException {
     BaseTestsOutputConsoleView console = createConsole(testFrameworkName, consoleProperties, runnerSettings, configurationSettings);
     console.attachToProcess(processHandler);
@@ -158,17 +158,31 @@ public class SMTestRunnerConnectionUtil {
    * @throws ExecutionException If IDEA cannot execute process this Exception will
    * be caught and shown in error message box
    */
-  public static ConsoleView attachRunner(@NotNull final String testFrameworkName, @NotNull final ProcessHandler processHandler,
-                                         @NotNull final CommandLineState commandLineState,
-                                         @NotNull final RuntimeConfiguration config,
-                                         @NotNull final Executor executor
+  public static ConsoleView createAndAttachConsole(@NotNull final String testFrameworkName, @NotNull final ProcessHandler processHandler,
+                                                   @NotNull final CommandLineState commandLineState,
+                                                   @NotNull final RuntimeConfiguration config,
+                                                   @NotNull final Executor executor
   ) throws ExecutionException {
     // final String testFrameworkName
     final TestConsoleProperties consoleProperties = new SMTRunnerConsoleProperties(config, testFrameworkName, executor);
 
-    return attachRunner(testFrameworkName, processHandler, consoleProperties,
-                        commandLineState.getRunnerSettings(),
-                        commandLineState.getConfigurationSettings());
+    return createAndAttachConsole(testFrameworkName, processHandler, consoleProperties,
+                                  commandLineState.getRunnerSettings(),
+                                  commandLineState.getConfigurationSettings());
+  }
+
+  public static ConsoleView createConsole(@NotNull final String testFrameworkName,
+                                          @NotNull final CommandLineState commandLineState,
+                                          @NotNull final RuntimeConfiguration config,
+                                          @NotNull final Executor executor
+  ) throws ExecutionException {
+    // final String testFrameworkName
+    final TestConsoleProperties consoleProperties = new SMTRunnerConsoleProperties(config, testFrameworkName, executor);
+
+    return createConsole(testFrameworkName,
+                         consoleProperties,
+                         commandLineState.getRunnerSettings(),
+                         commandLineState.getConfigurationSettings());
   }
 
   /**
diff --git a/plugins/android/src/org/jetbrains/android/run/testing/AndroidTestRunConfiguration.java b/plugins/android/src/org/jetbrains/android/run/testing/AndroidTestRunConfiguration.java
index 5e7408ce4810..b93726c6670a 100644
--- a/plugins/android/src/org/jetbrains/android/run/testing/AndroidTestRunConfiguration.java
+++ b/plugins/android/src/org/jetbrains/android/run/testing/AndroidTestRunConfiguration.java
@@ -161,7 +161,7 @@ public class AndroidTestRunConfiguration extends AndroidRunConfigurationBase {
   protected ConsoleView attachConsole(AndroidRunningState state, Executor executor) throws ExecutionException {
     TestConsoleProperties properties = new AndroidTestConsoleProperties(this, executor);
     BaseTestsOutputConsoleView consoleView = SMTestRunnerConnectionUtil
-      .attachRunner("Android", state.getProcessHandler(), properties, state.getRunnerSettings(), state.getConfigurationSettings()
+      .createAndAttachConsole("Android", state.getProcessHandler(), properties, state.getRunnerSettings(), state.getConfigurationSettings()
       );
     Disposer.register(state.getAndroidFacet().getModule().getProject(), consoleView);
     return consoleView;