diff --git a/java/java-runtime/java-runtime.iml b/java/java-runtime/java-runtime.iml
new file mode 100644
index 0000000..ba7b67b
--- /dev/null
+++ b/java/java-runtime/java-runtime.iml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module relativePaths="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_3" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="JUnit3" level="project" />
+    <orderEntry type="library" name="JUnit4" level="project" />
+    <orderEntry type="library" name="Ant" level="project" />
+  </component>
+</module>
+
diff --git a/java/java-runtime/src/FormPreviewFrame.java b/java/java-runtime/src/FormPreviewFrame.java
new file mode 100644
index 0000000..939c468
--- /dev/null
+++ b/java/java-runtime/src/FormPreviewFrame.java
@@ -0,0 +1,113 @@
+
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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.
+ */
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.text.MessageFormat;
+import java.util.ResourceBundle;
+
+public class FormPreviewFrame {
+  private JComponent myComponent;
+  private static final ResourceBundle ourBundle = ResourceBundle.getBundle("RuntimeBundle");
+
+  // Note: this class should not be obfuscated
+
+  public static void main(String[] args) {
+    FormPreviewFrame f = new FormPreviewFrame();
+
+    JFrame frame = new JFrame(ourBundle.getString("form.preview.title"));
+    frame.setContentPane(f.myComponent);
+    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+    // Add menu bar
+    final JMenuBar menuBar = new JMenuBar();
+    frame.setJMenuBar(menuBar);
+
+    final JMenu menuFile = new JMenu(ourBundle.getString("form.menu.preview"));
+    menuFile.setMnemonic(ourBundle.getString("form.menu.preview.mnemonic").charAt(0));
+    menuFile.add(new JMenuItem(new MyPackAction(frame)));
+    menuFile.add(new JMenuItem(new MyExitAction()));
+    menuBar.add(menuFile);
+
+    final JMenu viewMenu = new JMenu(ourBundle.getString("form.menu.laf"));
+    viewMenu.setMnemonic(ourBundle.getString("form.menu.laf.mnemonic").charAt(0));
+    menuBar.add(viewMenu);
+
+    final UIManager.LookAndFeelInfo[] lafs = UIManager.getInstalledLookAndFeels();
+    for(int i = 0; i < lafs.length; i++){
+      viewMenu.add(new MySetLafAction(frame, lafs[i]));
+    }
+
+    frame.pack();
+    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+    frame.setLocation((screenSize.width - frame.getWidth())/2, (screenSize.height - frame.getHeight())/2);
+    frame.setVisible(true);
+  }
+
+  private static final class MyExitAction extends AbstractAction{
+    public MyExitAction() {
+      super(ourBundle.getString("form.menu.file.exit"));
+    }
+
+    public void actionPerformed(final ActionEvent e) {
+      System.exit(0);
+    }
+  }
+
+  private static final class MyPackAction extends AbstractAction{
+    private final JFrame myFrame;
+
+    public MyPackAction(final JFrame frame) {
+      super(ourBundle.getString("form.menu.view.pack"));
+      myFrame = frame;
+    }
+
+    public void actionPerformed(final ActionEvent e) {
+      myFrame.pack();
+    }
+  }
+
+  private static final class MySetLafAction extends AbstractAction{
+    private final JFrame myFrame;
+    private final UIManager.LookAndFeelInfo myInfo;
+
+    public MySetLafAction(final JFrame frame, final UIManager.LookAndFeelInfo info) {
+      super(info.getName());
+      myFrame = frame;
+      myInfo = info;
+    }
+
+    public void actionPerformed(ActionEvent e) {
+      try{
+        UIManager.setLookAndFeel(myInfo.getClassName());
+        SwingUtilities.updateComponentTreeUI(myFrame);
+        Dimension prefSize = myFrame.getPreferredSize();
+        if(prefSize.width > myFrame.getWidth() || prefSize.height > myFrame.getHeight()){
+          myFrame.pack();
+        }
+      }
+      catch(Exception exc){
+        JOptionPane.showMessageDialog(
+          myFrame,
+          MessageFormat.format(ourBundle.getString("error.cannot.change.look.feel"), new Object[] {exc.getMessage()}),
+          ourBundle.getString("error.title"),
+          JOptionPane.ERROR_MESSAGE
+        );
+      }
+    }
+  }
+}
diff --git a/java/java-runtime/src/RuntimeBundle.properties b/java/java-runtime/src/RuntimeBundle.properties
new file mode 100644
index 0000000..337fa12
--- /dev/null
+++ b/java/java-runtime/src/RuntimeBundle.properties
@@ -0,0 +1,17 @@
+form.preview.title=Form Preview
+form.menu.preview=Preview
+form.menu.preview.mnemonic=P
+form.menu.file.exit=Exit
+form.menu.laf=Look and Feel
+form.menu.laf.mnemonic=L
+form.menu.view.pack=Pack
+error.cannot.change.look.feel=Cannot change LookAndFeel.\nReason: {0}
+error.title=Error
+junit.runner.error=Error: {0}
+junit.class.not.found=Class not found: "{0}"
+junit.cannot.instantiate.tests=Cannot instantiate test(s): {0}
+junit.class.not.derived={0} is not derived from TestCase. Do not provide method name.
+junit.suite.must.be.static=''{0}.suite()'' method must be static
+junit.failed.to.invoke.suite=Failed to invoke suite(): {0}
+junit.method.not.found=Method ''{0}'' not found
+tests.found.in.package={0} test {0, choice, 1#class|2#classes} found in package ''{1}''
\ No newline at end of file
diff --git a/java/java-runtime/src/com/intellij/rt/ant/execution/AntMain2.java b/java/java-runtime/src/com/intellij/rt/ant/execution/AntMain2.java
new file mode 100644
index 0000000..8b45dca
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/ant/execution/AntMain2.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.ant.execution;
+
+import java.lang.reflect.InvocationTargetException;
+
+public final class AntMain2 {
+
+  public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+    IdeaAntLogger2.guardStreams();
+
+    // first try to use the new way of launching ant
+    try {
+      final Class antLauncher = Class.forName("org.apache.tools.ant.launch.Launcher");
+      //noinspection HardCodedStringLiteral
+      antLauncher.getMethod("main", new Class[]{args.getClass()}).invoke(null, new Object[]{args});
+      return;
+    }
+    catch (ClassNotFoundException e) {
+      // ignore and try older variant
+    }
+
+    final Class antMain = Class.forName("org.apache.tools.ant.Main");
+    //noinspection HardCodedStringLiteral
+    antMain.getMethod("main", new Class[]{args.getClass()}).invoke(null, new Object[]{args});
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaAntLogger2.java b/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaAntLogger2.java
new file mode 100644
index 0000000..f30025e
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaAntLogger2.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.ant.execution;
+
+import com.intellij.rt.execution.junit.segments.PacketWriter;
+import com.intellij.rt.execution.junit.segments.SegmentedOutputStream;
+import org.apache.tools.ant.BuildEvent;
+import org.apache.tools.ant.DefaultLogger;
+import org.apache.tools.ant.Project;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+public final class IdeaAntLogger2 extends DefaultLogger {
+  static SegmentedOutputStream ourErr;
+  public static final char MESSAGE_CONTENT = 'M';
+  public static final char EXCEPTION_CONTENT = 'X';
+  public static final char INPUT_REQUEST = 'I';
+  public static final char BUILD_END = 'b';
+  public static final char BUILD = 'B';
+  public static final char TARGET = 'G';
+  public static final char TARGET_END = 'g';
+  public static final char TASK = 'T';
+  public static final char TASK_END = 't';
+  public static final char MESSAGE = 'M';
+  public static final char ERROR = 'E';
+  public static final char EXCEPTION = 'X';
+  public static final char EXCEPTION_LINE_SEPARATOR = 0;
+
+  /**
+   * @noinspection HardCodedStringLiteral
+   */
+  public static final String OUTPUT_PREFIX = "IDEA_ANT_INTEGRATION";
+
+  private final Priority myMessagePriority = new MessagePriority();
+  private final Priority myTargetPriority = new StatePriority(Project.MSG_INFO);
+  private final Priority myTaskPriority = new StatePriority(Project.MSG_INFO);
+  private final Priority myAlwaysSend = new Priority() {
+    public void setPriority(int level) {}
+
+    protected boolean shouldSend(int priority) {
+      return true;
+    }
+  };
+
+  public IdeaAntLogger2() {
+    guardStreams();
+  }
+
+  public synchronized void setMessageOutputLevel(int level) {
+    super.setMessageOutputLevel(level);
+    myMessagePriority.setPriority(level);
+    myTargetPriority.setPriority(level);
+    myTaskPriority.setPriority(level);
+    myAlwaysSend.setPriority(level);
+  }
+
+  public synchronized void buildStarted(BuildEvent event) {
+    myAlwaysSend.sendMessage(BUILD, event.getPriority(), "");
+  }
+
+  public synchronized void buildFinished(BuildEvent event) {
+    myAlwaysSend.sendMessage(BUILD_END, event.getPriority(), event.getException());
+  }
+
+  public synchronized void targetStarted(BuildEvent event) {
+    myTargetPriority.sendMessage(TARGET, event.getPriority(), event.getTarget().getName());
+  }
+
+  public synchronized void targetFinished(BuildEvent event) {
+    sendException(event);
+    myTargetPriority.sendMessage(TARGET_END, event.getPriority(), event.getException());
+  }
+
+  public synchronized void taskStarted(BuildEvent event) {
+    myTaskPriority.sendMessage(TASK, event.getPriority(), event.getTask().getTaskName());
+  }
+
+  public synchronized void taskFinished(BuildEvent event) {
+    sendException(event);
+    myTaskPriority.sendMessage(TASK_END, event.getPriority(), event.getException());
+  }
+
+  public synchronized void messageLogged(BuildEvent event) {
+    if (sendException(event)) return;
+    int priority = event.getPriority();
+    String message = event.getMessage();
+    if (priority == Project.MSG_ERR)
+      myMessagePriority.sendMessage(ERROR, priority, message);
+    else
+      myMessagePriority.sendMessage(MESSAGE, priority, message);
+  }
+
+  private boolean sendException(BuildEvent event) {
+    Throwable exception = event.getException();
+    if (exception != null) {
+      myAlwaysSend.sendMessage(EXCEPTION, event.getPriority(), exception);
+      return true;
+    }
+    return false;
+  }
+
+  public static void guardStreams() {
+    if (ourErr != null) {
+      return;
+    }
+    PrintStream err = System.err;
+    ourErr = new SegmentedOutputStream(err);
+    System.setErr(new PrintStream(ourErr));
+    ourErr.sendStart();
+  }
+
+  private void send(PacketWriter packet) {
+    packet.sendThrough(ourErr);
+  }
+
+  private PacketWriter createPacket(char id, int priority) {
+    PacketWriter packet = PacketFactory.ourInstance.createPacket(id);
+    packet.appendLong(priority);
+    return packet;
+  }
+
+  private abstract class Priority {
+    protected void peformSendMessage(char id, int priority, String text) {
+      PacketWriter packet = createPacket(id, priority);
+      packet.appendChar(MESSAGE_CONTENT);
+      packet.appendLimitedString(text);
+      send(packet);
+    }
+
+    protected void peformSendMessage(char id, int priority, Throwable throwable) {
+      if (throwable != null) {
+        PacketWriter packet = createPacket(id, priority);
+        StringWriter stackTrace = new StringWriter();
+        throwable.printStackTrace(new PrintWriter(stackTrace));
+        packet.appendChar(EXCEPTION_CONTENT);
+        packet.appendLimitedString(stackTrace.toString());
+        send(packet);
+      } else {
+        peformSendMessage(id, priority, "");
+      }
+    }
+
+    public void sendMessage(char id, int priority, String text) {
+      if (shouldSend(priority)) peformSendMessage(id, priority, text);
+    }
+
+    public void sendMessage(char id, int priority, Throwable throwable) {
+      if (shouldSend(priority)) peformSendMessage(id, priority, throwable);
+    }
+
+    public abstract void setPriority(int level);
+    protected abstract boolean shouldSend(int priority);
+  }
+
+  private class MessagePriority extends Priority {
+    private int myPriority = Project.MSG_ERR;
+
+    public void setPriority(int level) {
+      myPriority = level;
+    }
+
+    protected boolean shouldSend(int priority) {
+      return priority <= myPriority;
+    }
+  }
+
+  private class StatePriority extends Priority {
+    private boolean myEnabled = true;
+    private final int myMinLevel;
+
+    public StatePriority(int minLevel) {
+      myMinLevel = minLevel;
+    }
+
+    public void setPriority(int level) {
+      myEnabled = myMinLevel <= level;
+    }
+
+    protected boolean shouldSend(int priority) {
+      return myEnabled;
+    }
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaInputHandler.java b/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaInputHandler.java
new file mode 100644
index 0000000..3a1120a
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/ant/execution/IdeaInputHandler.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.ant.execution;
+
+import com.intellij.rt.execution.junit.segments.PacketWriter;
+import com.intellij.rt.execution.junit.segments.SegmentedOutputStream;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.input.InputHandler;
+import org.apache.tools.ant.input.InputRequest;
+import org.apache.tools.ant.input.MultipleChoiceInputRequest;
+
+import java.io.IOException;
+import java.util.Vector;
+
+/**
+ * @author dyoma
+ */
+public class IdeaInputHandler implements InputHandler {
+  public void handleInput(InputRequest request) throws BuildException {
+    final String prompt = request.getPrompt();
+    if (prompt == null) {
+      throw new BuildException("Prompt is null");
+    }
+    final SegmentedOutputStream err = IdeaAntLogger2.ourErr;
+    if (err == null) {
+      throw new BuildException("Selected InputHandler should be used by Intellij IDEA");
+    }
+    final PacketWriter packet = PacketFactory.ourInstance.createPacket(IdeaAntLogger2.INPUT_REQUEST);
+    packet.appendLimitedString(prompt);
+    if (request instanceof MultipleChoiceInputRequest) {
+      Vector choices = ((MultipleChoiceInputRequest)request).getChoices();
+      if (choices != null && choices.size() > 0) {
+        int count = choices.size();
+        packet.appendLong(count);
+        for (int i = 0; i < count; i++) {
+          packet.appendLimitedString((String)choices.elementAt(i));
+        }
+      }
+      else {
+        packet.appendLong(0);
+      }
+    }
+    else {
+      packet.appendLong(0);
+    }
+    packet.sendThrough(err);
+    try {
+      final byte[] replayLength = readBytes(4);
+      final int length = ((int)replayLength[0] << 24) | ((int)replayLength[1] << 16) | ((int)replayLength[2] << 8) | replayLength[3];
+      final byte[] replay = readBytes(length);
+      final String input = new String(replay);
+      request.setInput(input);
+      if (!request.isInputValid()) {
+        throw new BuildException("Invalid input: " + input);
+      }
+    }
+    catch (IOException e) {
+      throw new BuildException(e);
+    }
+  }
+
+  private byte[] readBytes(int count) throws IOException {
+    byte[] replayLength = new byte[count];
+    int read = System.in.read(replayLength);
+    if (read != count) throw new IOException("End of input stream");
+    return replayLength;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/ant/execution/PacketFactory.java b/java/java-runtime/src/com/intellij/rt/ant/execution/PacketFactory.java
new file mode 100644
index 0000000..2768b63
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/ant/execution/PacketFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.ant.execution;
+
+import com.intellij.rt.execution.junit.segments.PacketWriter;
+
+/**
+ * @author dyoma
+ */
+class PacketFactory {
+  private int myLastMessageId = -1;
+  public static final PacketFactory ourInstance = new PacketFactory();
+
+  public synchronized PacketWriter createPacket(char id) {
+    PacketWriter writer = new PacketWriter();
+    myLastMessageId++;
+    writer.appendLong(myLastMessageId);
+    writer.appendChar(id);
+    return writer;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/compiler/JavacResourcesReader.java b/java/java-runtime/src/com/intellij/rt/compiler/JavacResourcesReader.java
new file mode 100644
index 0000000..0a1a3d4
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/compiler/JavacResourcesReader.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.compiler;
+
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+  * MUST BE COMPILED WITH JDK 1.1 IN ORDER TO SUPPORT JAVAC LAUNCHING FOR ALL JDKs
+  * @author Eugene Zhuravlev
+  *         Date: Oct 10, 2005
+  */
+public class JavacResourcesReader {
+  public static final String MSG_PATTERNS_START = "__patterns_start";
+  public static final String MSG_PATTERNS_END = "__patterns_end";
+  public static final String MSG_PARSING_STARTED = "MSG_PARSING_STARTED";
+  public static final String MSG_PARSING_COMPLETED = "MSG_PARSING_COMPLETED";
+  public static final String MSG_LOADING = "MSG_LOADING";
+  public static final String MSG_CHECKING = "MSG_CHECKING";
+  public static final String MSG_WROTE = "MSG_WROTE";
+  public static final String MSG_WARNING = "MSG_WARNING";
+  public static final String MSG_NOTE = "MSG_NOTE";
+  public static final String MSG_STATISTICS = "MSG_STATISTICS";
+  public static final String MSG_IGNORED = "MSG_IGNORED";
+
+  private static final String[] BUNDLE_NAMES = new String[] {
+    "com.sun.tools.javac.resources.compiler",    // v1.5
+    "com.sun.tools.javac.v8.resources.compiler", // v1.3-1.4
+    "sun.tools.javac.resources.javac"            // v1.1-1.2
+  };
+
+  private static final BundleKey[] MSG_NAME_KEY_PAIRS = new BundleKey[] {
+    new BundleKey(MSG_PARSING_STARTED, "compiler.misc.verbose.parsing.started"),
+    new BundleKey(MSG_PARSING_COMPLETED, "compiler.misc.verbose.parsing.done"),
+    new BundleKey(MSG_PARSING_COMPLETED, "benv.parsed_in"), // jdk 1.1-1.2
+    new BundleKey(MSG_LOADING, "compiler.misc.verbose.loading"),
+    new BundleKey(MSG_LOADING, "benv.loaded_in"), // jdk 1.1-1.2
+    new BundleKey(MSG_CHECKING, "compiler.misc.verbose.checking.attribution"),
+    new BundleKey(MSG_WROTE,"compiler.misc.verbose.wrote.file"),
+    new BundleKey(MSG_WROTE,"main.wrote"), // jdk 1.1-1.2
+    new BundleKey(MSG_WARNING,"compiler.warn.warning"),
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.deprecated.filename"}),  // jdk 1.5
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.deprecated.plural"}),  // jdk 1.5
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.deprecated.recompile"}),  // jdk 1.5
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.unchecked.filename"}),  // jdk 1.5
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.unchecked.plural"}),  // jdk 1.5
+    new BundleKey(MSG_NOTE,new String[] {"compiler.note.note", "compiler.note.unchecked.recompile"}),  // jdk 1.5
+    new BundleKey(MSG_STATISTICS,"compiler.misc.count.error"),
+    new BundleKey(MSG_STATISTICS,"compiler.misc.count.error.plural"),
+    new BundleKey(MSG_STATISTICS,"compiler.misc.count.warn"),
+    new BundleKey(MSG_STATISTICS,"compiler.misc.count.warn.plural"),
+    new BundleKey(MSG_STATISTICS,"main.errors"), //jdk 1.1 - 1.2
+    new BundleKey(MSG_STATISTICS,"main.warnings"), //jdk 1.1 - 1.2
+    new BundleKey(MSG_STATISTICS,"main.1error"), //jdk 1.1 - 1.2
+    new BundleKey(MSG_STATISTICS,"main.1warning"), //jdk 1.1 - 1.2
+    new IgnoredWarningBundleKey("compiler.warn.dir.path.element.not.found"), //jdk 1.5
+    new IgnoredWarningBundleKey("compiler.warn.path.element.not.found"), //jdk 1.5
+  };
+
+  public static final String CATEGORY_VALUE_DIVIDER = "=";
+
+  public static void main(String[] args) {
+    dumpPatterns();
+  }
+
+  // for debug purposes
+  /*
+  public static void printPatterns() {
+    final ResourceBundle messagesBundle = getMessagesBundle();
+    if (messagesBundle == null) {
+      System.out.println("No bundles found");
+      return;
+    }
+    final Enumeration keys = messagesBundle.getKeys();
+    while (keys.hasMoreElements()) {
+      final Object key = keys.nextElement();
+      System.out.println(key + "->" + messagesBundle.getObject((String)key));
+    }
+  }
+  */
+  
+  public static boolean dumpPatterns() {
+    final ResourceBundle messagesBundle = getMessagesBundle();
+    if (messagesBundle == null) {
+      return false;
+    }
+    System.err.println(MSG_PATTERNS_START);
+    for (int idx = 0; idx < MSG_NAME_KEY_PAIRS.length; idx++) {
+      BundleKey bundleKey = MSG_NAME_KEY_PAIRS[idx];
+      try {
+        System.err.println(bundleKey.category + CATEGORY_VALUE_DIVIDER + bundleKey.getCategoryValue(messagesBundle));
+      }
+      catch (MissingResourceException ignored) {
+      }
+    }
+    System.err.println(MSG_PATTERNS_END);
+    return true;
+  }
+
+  private static ResourceBundle getMessagesBundle() {
+    for (int i = 0; i < BUNDLE_NAMES.length; i++) {
+      try {
+        return ResourceBundle.getBundle(BUNDLE_NAMES[i]);
+      }
+      catch (MissingResourceException ignored) {
+        continue;
+      }
+    }
+    return null;
+  }
+
+  private static class BundleKey {
+    public final String category;
+    public final String[] keys;
+
+    public BundleKey(final String category, final String key) {
+      this(category, new String[] {key});
+    }
+
+    public BundleKey(final String category, final String[] composite) {
+      this.category = category;
+      this.keys = composite;
+    }
+
+    public String getCategoryValue(ResourceBundle messagesBundle) {
+      if (keys.length == 1) {
+        return messagesBundle.getString(keys[0]);
+      }
+      final StringBuffer buf = new StringBuffer();
+      for (int idx = 0; idx < keys.length; idx++) {
+        buf.append(messagesBundle.getString(keys[idx]));
+      }
+      return buf.toString();
+    }
+  }
+
+  private static class IgnoredWarningBundleKey extends BundleKey {
+    public IgnoredWarningBundleKey(final String messageKey) {
+      super(JavacResourcesReader.MSG_IGNORED, new String[]{"compiler.warn.warning", messageKey});
+    }
+
+    public String getCategoryValue(ResourceBundle messagesBundle) {
+      return messagesBundle.getString(keys[0]) + MessageFormat.format(messagesBundle.getString(keys[1]), new Object[] {""});
+    }
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/compiler/JavacRunner.java b/java/java-runtime/src/com/intellij/rt/compiler/JavacRunner.java
new file mode 100644
index 0000000..a454146
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/compiler/JavacRunner.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.compiler;
+
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Vector;
+
+/**
+ * MUST BE COMPILED WITH JDK 1.1 IN ORDER TO SUPPORT JAVAC LAUNCHING FOR ALL JDKs
+ */
+public class JavacRunner {
+
+  /**
+   * @param args - params
+   *  0. jdk version string
+   *  1. javac main class
+   *  2. javac parameters
+   */
+  public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, IOException {
+
+    if (!JavacResourcesReader.dumpPatterns()) {
+      return;
+    }
+
+    final String versionString = args[0];
+    final Class aClass = Class.forName(args[1]);
+    //noinspection HardCodedStringLiteral
+    final Method mainMethod = aClass.getMethod("main", new Class[] {String[].class});
+    String[] newArgs;
+    if (versionString.indexOf("1.1") > -1) {
+      // expand the file
+      final Vector arguments = new Vector();
+      boolean isClasspath = false;
+      for (int idx = 3; idx < args.length; idx++) {
+        final String arg = args[idx];
+        if (arg.startsWith("@") && !isClasspath) {
+          String path = arg.substring(1);
+          addFilesToCompile(arguments, path);
+        }
+        else {
+          isClasspath = "-classpath".equals(arg) || "-cp".equals(arg) || "-bootclasspath".equals(arg);
+          arguments.addElement(arg);
+        }
+      }
+      newArgs = new String[arguments.size()];
+      for (int idx = 0; idx < newArgs.length; idx++) {
+        newArgs[idx] = (String)arguments.elementAt(idx);
+      }
+    }
+    else {
+      newArgs = new String[args.length - 2];
+      System.arraycopy(args, 2, newArgs, 0, newArgs.length);
+    }
+    expandClasspath(newArgs);
+    try {
+      mainMethod.invoke(null, new Object[] {newArgs});
+    }
+    catch (Throwable e) {
+      System.err.print(e.getMessage());
+      e.printStackTrace(System.err);
+    }
+  }
+
+  private static void addFilesToCompile(Vector arguments, String path) throws IOException {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new FileReader(new File(path)));
+      for (String filePath = reader.readLine(); filePath != null; filePath = reader.readLine()) {
+        arguments.addElement(filePath.replace('/', File.separatorChar));
+      }
+    }
+    finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  private static void expandClasspath(String[] args) throws IOException {
+    for (int idx = 0; idx < args.length; idx++) {
+      final String arg = args[idx];
+      //noinspection HardCodedStringLiteral
+      if ("-classpath".equals(arg) || "-cp".equals(arg) || "-bootclasspath".equals(arg)) {
+        final String cpValue = args[idx + 1];
+        if (cpValue.startsWith("@")) {
+          args[idx + 1] = readClasspath(cpValue.substring(1));
+        }
+      }
+    }
+  }
+
+  public static String readClasspath(String filePath) throws IOException {
+    final DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(new File(filePath))));
+    try {
+      return readString(in);
+    }
+    finally {
+      in.close();
+    }
+  }
+
+  private static String readString(DataInput stream) throws IOException {
+    int length = stream.readInt();
+    if (length == -1) return null;
+
+    char[] chars = new char[length];
+    byte[] bytes = new byte[length*2];
+    stream.readFully(bytes);
+
+    for (int i = 0, i2 = 0; i < length; i++, i2+=2) {
+      chars[i] = (char)((bytes[i2] << 8) + (bytes[i2 + 1] & 0xFF));
+    }
+
+    return new String(chars);
+  }
+
+}
diff --git a/java/java-runtime/src/com/intellij/rt/debugger/BatchEvaluatorServer.java b/java/java-runtime/src/com/intellij/rt/debugger/BatchEvaluatorServer.java
new file mode 100644
index 0000000..6895f02
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/debugger/BatchEvaluatorServer.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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.
+ */
+
+/*
+ * @author: Eugene Zhuravlev
+ * Date: Sep 16, 2002
+ * Time: 10:56:58 PM
+ */
+package com.intellij.rt.debugger;
+
+public class BatchEvaluatorServer {
+  Object[] myObjects;
+
+  public Object[] evaluate(Object[] objects) {
+    myObjects = objects;
+    Object[] result = new Object[objects.length];
+    for (int idx = 0; idx < objects.length; idx++) {
+      try {
+        result[idx] = objects[idx].toString();
+      }
+      catch (Throwable e) {
+        result[idx] = e;
+      }
+    }
+    return result;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/CommandLineWrapper.java b/java/java-runtime/src/com/intellij/rt/execution/CommandLineWrapper.java
new file mode 100644
index 0000000..b5cfc47
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/CommandLineWrapper.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author anna
+ * @since 12-Aug-2008
+ */
+public class CommandLineWrapper {
+  private static final String PREFIX = "-D";
+
+  public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
+                                                IllegalAccessException, IOException, InstantiationException {
+    final List urls = new ArrayList();
+    final File file = new File(args[0]);
+    final BufferedReader reader = new BufferedReader(new FileReader(file));
+    try {
+      while(reader.ready()) {
+        final String fileName = reader.readLine();
+        try {
+          //noinspection Since15
+          urls.add(new File(fileName).toURI().toURL());
+        }
+        catch (NoSuchMethodError e) {
+          //noinspection deprecation
+          urls.add(new File(fileName).toURL());
+        }
+      }
+    }
+    finally {
+      reader.close();
+    }
+    if (!file.delete()) file.deleteOnExit();
+
+    int startArgsIdx = 2;
+    if (args[1].equals("@vm_params")) {
+      startArgsIdx = 4;
+      final File vmParamsFile = new File(args[2]);
+      final BufferedReader vmParamsReader = new BufferedReader(new FileReader(vmParamsFile));
+      try {
+        while (vmParamsReader.ready()) {
+          final String vmParam = vmParamsReader.readLine().trim();
+          final int eqIdx = vmParam.indexOf("=");
+          String vmParamName;
+          String vmParamValue;
+          
+          if (eqIdx > -1 && eqIdx < vmParam.length() - 1) {
+            vmParamName = vmParam.substring(0, eqIdx);
+            vmParamValue = vmParam.substring(eqIdx + 1);
+          } else {
+            vmParamName = vmParam;
+            vmParamValue = "";
+          }
+          vmParamName = vmParamName.trim();
+          if (vmParamName.startsWith(PREFIX)) {
+            vmParamName = vmParamName.substring(PREFIX.length());
+            System.setProperty(vmParamName, vmParamValue);
+          }
+        }
+      }
+      finally {
+        vmParamsReader.close();
+      }
+      if (!vmParamsFile.delete()) vmParamsFile.deleteOnExit();
+    }
+
+    String mainClassName = args[startArgsIdx - 1];
+    String[] mainArgs = new String[args.length - startArgsIdx];
+    System.arraycopy(args, startArgsIdx, mainArgs, 0, mainArgs.length);
+
+    ClassLoader loader = new URLClassLoader((URL[])urls.toArray(new URL[urls.size()]), null);
+    final String classLoader = System.getProperty("java.system.class.loader");
+    if (classLoader != null) {
+      try {
+        loader = (ClassLoader)Class.forName(classLoader).getConstructor(new Class[]{ClassLoader.class}).newInstance(new Object[]{loader});
+      }
+      catch (Exception e) {
+        //leave URL class loader
+      }
+    }
+
+    Class mainClass = loader.loadClass(mainClassName);
+    Thread.currentThread().setContextClassLoader(loader);
+    //noinspection SSBasedInspection
+    Class mainArgType = (new String[0]).getClass();
+    Method main = mainClass.getMethod("main", new Class[]{mainArgType});
+    ensureAccess(main);
+    main.invoke(null, new Object[]{mainArgs});
+  }
+
+   private static void ensureAccess(Object reflectionObject) {
+    // need to call setAccessible here in order to be able to launch package-local classes
+    // calling setAccessible() via reflection because the method is missing from java version 1.1.x
+    final Class aClass = reflectionObject.getClass();
+    try {
+      final Method setAccessibleMethod = aClass.getMethod("setAccessible", new Class[] {boolean.class});
+      setAccessibleMethod.invoke(reflectionObject, new Object[] {Boolean.TRUE});
+    }
+    catch (Exception e) {
+      // the method not found
+    }
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/application/AppMain.java b/java/java-runtime/src/com/intellij/rt/execution/application/AppMain.java
new file mode 100644
index 0000000..1319956
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/application/AppMain.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.application;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * @author ven
+ * @noinspection HardCodedStringLiteral
+ */
+public class AppMain {
+  private static final String PROPERTY_PORT_NUMBER = "idea.launcher.port";
+  private static final String PROPERTY_BINPATH = "idea.launcher.bin.path";
+
+  private static native void triggerControlBreak();
+
+  static {
+    String binPath = System.getProperty(PROPERTY_BINPATH) + File.separator;
+    final String osName = System.getProperty("os.name").toLowerCase();
+    String arch = System.getProperty("os.arch").toLowerCase();
+    String libPath = null;
+    if (osName.startsWith("windows")) {
+      if (arch.equals("amd64")) {
+        libPath = binPath + "breakgen64.dll";
+      }
+      else {
+        libPath = binPath + "breakgen.dll";
+      }
+    } else if (osName.startsWith("linux")) {
+      if (arch.equals("amd64")) {
+        libPath = binPath + "libbreakgen64.so";
+      } else {
+        libPath = binPath + "libbreakgen.so";
+      }
+    } else if (osName.startsWith("mac")) {
+      if (arch.endsWith("64")) {
+        libPath = binPath + "libbreakgen64.jnilib";
+      } else {
+        libPath = binPath + "libbreakgen.jnilib";
+      }
+    }
+
+    try {
+      if (libPath != null) {
+        System.load(libPath);
+      }
+    }
+    catch (UnsatisfiedLinkError e) {
+      //Do nothing, unknown os or some other error => no ctrl-break is available
+    }
+  }
+
+  public static void main(String[] args) throws Throwable {
+
+    final int portNumber = Integer.getInteger(PROPERTY_PORT_NUMBER).intValue();
+    Thread t = new Thread(
+      new Runnable() {
+        public void run() {
+          try {
+            ServerSocket socket = new ServerSocket(portNumber);
+            Socket client = socket.accept();
+            BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
+            while (true) {
+              String msg = reader.readLine();
+
+              if ("TERM".equals(msg)){
+                return;
+              }
+              else if ("BREAK".equals(msg)) {
+                triggerControlBreak();
+              }
+              else if ("STOP".equals(msg)) {
+                System.exit(1);
+              }
+            }
+          } catch (IOException ignored) {
+          } catch (IllegalArgumentException ignored) {
+          } catch (SecurityException ignored) {
+          }
+        }
+      }, "Monitor Ctrl-Break");
+    try {
+      t.setDaemon(true);
+      t.start();
+    } catch (Exception ignored) {}
+
+    String mainClass = args[0];
+    String[] parms = new String[args.length - 1];
+    for (int j = 1; j < args.length; j++) {
+      parms[j - 1] = args[j];
+    }
+    Method m = Class.forName(mainClass).getMethod("main", new Class[]{parms.getClass()});
+    if (!Modifier.isStatic(m.getModifiers())) {
+      System.err.println("main method should be static");
+      return;
+    }
+    try {
+      ensureAccess(m);
+      m.invoke(null, new Object[]{parms});
+    } catch (InvocationTargetException ite) {
+      throw ite.getTargetException();
+    }
+  }
+
+  private static void ensureAccess(Object reflectionObject) {
+    // need to call setAccessible here in order to be able to launch package-local classes
+    // calling setAccessible() via reflection because the method is missing from java version 1.1.x
+    final Class aClass = reflectionObject.getClass();
+    try {
+      final Method setAccessibleMethod = aClass.getMethod("setAccessible", new Class[] {boolean.class});
+      setAccessibleMethod.invoke(reflectionObject, new Object[] {Boolean.TRUE});
+    }
+    catch (Exception e) {
+      // the method not found
+    }
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/application/MainAppClassLoader.java b/java/java-runtime/src/com/intellij/rt/execution/application/MainAppClassLoader.java
new file mode 100644
index 0000000..402c1d6
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/application/MainAppClassLoader.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.application;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+/**
+ * @author ven
+ */
+public class MainAppClassLoader  extends URLClassLoader {
+  /**
+   * @noinspection HardCodedStringLiteral
+   */
+  private static final String USER_CLASSPATH = "idea.user.classpath";
+  private final Class myAppMainClass;
+
+  private static URL[] makeUrls() {
+    List classpath = new ArrayList();
+    try {
+      String userClassPath = System.getProperty(USER_CLASSPATH, "");
+      StringTokenizer tokenizer = new StringTokenizer(userClassPath, File.pathSeparator, false);
+      while (tokenizer.hasMoreTokens()) {
+        String pathItem = tokenizer.nextToken();
+        classpath.add(new File(pathItem).toURL());
+      }
+    } catch (MalformedURLException e) {
+      e.printStackTrace();
+    }
+    return (URL[]) classpath.toArray(new URL[classpath.size()]);
+  }
+
+  public MainAppClassLoader(ClassLoader loader) {
+    super(makeUrls(), null);
+    myAppMainClass = AppMain.class;
+  }
+
+  protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
+    if (name.equals(myAppMainClass.getName())) {
+      return myAppMainClass;
+    }
+    return super.loadClass(name, resolve);
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/ComparisonDetailsExtractor.java b/java/java-runtime/src/com/intellij/rt/execution/junit/ComparisonDetailsExtractor.java
new file mode 100644
index 0000000..78ce51b
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/ComparisonDetailsExtractor.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit;
+
+import com.intellij.rt.execution.junit.segments.OutputObjectRegistry;
+import com.intellij.rt.execution.junit.segments.Packet;
+import com.intellij.rt.execution.junit.states.PoolOfTestStates;
+import junit.framework.ComparisonFailure;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @noinspection HardCodedStringLiteral
+ */
+public class ComparisonDetailsExtractor extends ExceptionPacketFactory {
+  private static Map EXPECTED = new HashMap();
+  private static Map ACTUAL = new HashMap();
+  protected String myActual = "";
+  protected String myExpected = "";
+
+  static {
+    try {
+      init(ComparisonFailure.class);
+      init(org.junit.ComparisonFailure.class);
+    } catch (Throwable e) {}
+  }
+
+  private static void init(Class exceptionClass) throws NoSuchFieldException {
+    final Field expectedField = exceptionClass.getDeclaredField("fExpected");
+    expectedField.setAccessible(true);
+    EXPECTED.put(exceptionClass, expectedField);
+
+    final Field actualField = exceptionClass.getDeclaredField("fActual");
+    actualField.setAccessible(true);
+    ACTUAL.put(exceptionClass, actualField);
+  }
+
+  public ComparisonDetailsExtractor(Throwable assertion, String expected, String actual) {
+    super(PoolOfTestStates.COMPARISON_FAILURE, assertion);
+    myActual = actual;
+    myExpected = expected;
+  }
+
+  public static ExceptionPacketFactory create(Throwable assertion) {
+    try {
+      return create(assertion, getExpected(assertion), getActual(assertion));
+    }
+    catch (Throwable e) {
+      return new ExceptionPacketFactory(PoolOfTestStates.FAILED_INDEX, assertion);
+    }
+  }
+
+  public static String getActual(Throwable assertion) throws IllegalAccessException, NoSuchFieldException {
+    return get(assertion, ACTUAL, "fActual");
+  }
+
+  public static String getExpected(Throwable assertion) throws IllegalAccessException, NoSuchFieldException {
+    return get(assertion, EXPECTED, "fExpected");
+  }
+
+  private static String get(final Throwable assertion, final Map staticMap, final String fieldName) throws IllegalAccessException, NoSuchFieldException {
+    String actual;
+    if (assertion instanceof ComparisonFailure) {
+      actual = (String)((Field)staticMap.get(ComparisonFailure.class)).get(assertion);
+    }
+    else if (assertion instanceof org.junit.ComparisonFailure) {
+      actual = (String)((Field)staticMap.get(org.junit.ComparisonFailure.class)).get(assertion);
+    }
+    else {
+      Field field = assertion.getClass().getDeclaredField(fieldName);
+      field.setAccessible(true);
+      actual = (String)field.get(assertion);
+    }
+    return actual;
+  }
+
+  public static ExceptionPacketFactory create(Throwable assertion, final String expected, String actual) {
+    return new ComparisonDetailsExtractor(assertion, expected, actual);
+  }
+
+  public Packet createPacket(OutputObjectRegistry registry, Object test) {
+    Packet packet = super.createPacket(registry, test);
+    packet.
+        addLimitedString(myExpected).
+        addLimitedString(myActual);
+    return packet;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/ExceptionPacketFactory.java b/java/java-runtime/src/com/intellij/rt/execution/junit/ExceptionPacketFactory.java
new file mode 100644
index 0000000..0d577cb
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/ExceptionPacketFactory.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit;
+
+import com.intellij.rt.execution.junit.segments.OutputObjectRegistry;
+import com.intellij.rt.execution.junit.segments.Packet;
+
+public class ExceptionPacketFactory implements PacketFactory {
+  private final Throwable myAssertion;
+  private int myState;
+
+  public ExceptionPacketFactory(int state, Throwable assertion) {
+    myState = state;
+    myAssertion = assertion;
+  }
+
+  public Packet createPacket(OutputObjectRegistry registry, Object test) {
+    return registry.createPacket().
+        setTestState(test, myState).
+        addThrowable(myAssertion);
+  }
+
+  protected void setState(int state) { myState = state; }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/FileComparisonFailure.java b/java/java-runtime/src/com/intellij/rt/execution/junit/FileComparisonFailure.java
new file mode 100644
index 0000000..0a66a53
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/FileComparisonFailure.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit;
+
+import com.intellij.rt.execution.junit.segments.OutputObjectRegistry;
+import com.intellij.rt.execution.junit.segments.Packet;
+import junit.framework.ComparisonFailure;
+
+public class FileComparisonFailure extends ComparisonFailure implements KnownException {
+  private final String myExpected;
+  private final String myActual;
+  private final String myFilePath;
+
+  public FileComparisonFailure(String message, String expected, String actual, String filePath) {
+    super(message, expected, actual);
+    myExpected = expected;
+    myActual = actual;
+    myFilePath = filePath;
+  }
+
+  public PacketFactory getPacketFactory() {
+    return new MyPacketFactory(this, myExpected, myActual, myFilePath);
+  }
+
+  private static class MyPacketFactory extends ComparisonDetailsExtractor {
+    private final String myFilePath;
+
+    public MyPacketFactory(ComparisonFailure assertion, String expected, String actual, String filePath) {
+      super(assertion, expected, actual);
+      myFilePath = filePath;
+    }
+
+    public Packet createPacket(OutputObjectRegistry registry, Object test) {
+      Packet packet = super.createPacket(registry, test);
+      packet.addLimitedString(myFilePath);
+      return packet;
+    }
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/KnownException.java b/java/java-runtime/src/com/intellij/rt/execution/junit/KnownException.java
new file mode 100644
index 0000000..b5d35bd
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/KnownException.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit;
+
+public interface KnownException {
+  PacketFactory getPacketFactory();
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/PacketFactory.java b/java/java-runtime/src/com/intellij/rt/execution/junit/PacketFactory.java
new file mode 100644
index 0000000..25f536e
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/PacketFactory.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit;
+
+import com.intellij.rt.execution.junit.segments.OutputObjectRegistry;
+import com.intellij.rt.execution.junit.segments.Packet;
+
+public interface PacketFactory {
+  Packet createPacket(OutputObjectRegistry registry, Object test);
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/OutputObjectRegistry.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/OutputObjectRegistry.java
new file mode 100644
index 0000000..ec194dc
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/OutputObjectRegistry.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+import java.util.Collection;
+import java.util.Hashtable;
+
+public abstract class OutputObjectRegistry  {
+  private final Hashtable myKnownKeys = new Hashtable();
+  private int myLastIndex = 0;
+  private PacketProcessor myMainTransport;
+
+  protected OutputObjectRegistry(PacketProcessor mainTransport, int lastIndex) {
+    myLastIndex = lastIndex;
+    myMainTransport = mainTransport;
+  }
+
+  public String referenceTo(Object test) {
+    if (containsKey(test)) return getKey(test);
+    return sendObject(test);
+  }
+
+  public String referenceTo(Object test, Collection packets) {
+    if (containsKey(test)) return getKey(test);
+    return sendObject(test, packets);
+  }
+
+  private boolean containsKey(Object test) {
+    return myKnownKeys.containsKey(createObjectWrapper(test));
+  }
+
+  private String getKey(Object test) {
+    return (String)myKnownKeys.get(createObjectWrapper(test));
+  }
+
+  private void putKey(Object test, String key) {
+    myKnownKeys.put(createObjectWrapper(test), key);
+  }
+
+  public void forget(Object test) {
+    myKnownKeys.remove(createObjectWrapper(test));
+  }
+
+  private String sendObject(Object test, Collection packets) {
+    final String key = String.valueOf(myLastIndex++);
+    putKey(test, key);
+    final Packet packet = createPacket();
+    packet.addString(PoolOfDelimiters.OBJECT_PREFIX).addReference(key);
+    addStringRepresentation(test, packet);
+    packet.addLong(getTestCont(test));
+    packet.addString(PoolOfDelimiters.REFERENCE_END_STR);
+    packets.add(packet);
+    return key;
+  }
+
+  public Packet createPacket() {
+    return new Packet(myMainTransport, this);
+  }
+
+  private String sendObject(Object test) {
+    final String key = String.valueOf(myLastIndex++);
+    putKey(test, key);
+    Packet packet = createPacket().addString(PoolOfDelimiters.OBJECT_PREFIX).addReference(key);
+    addStringRepresentation(test, packet);
+    packet.addLong(getTestCont(test));
+    packet.send();
+    return key;
+  }
+
+  protected abstract int getTestCont(Object test);
+  protected abstract void addStringRepresentation(Object test, Packet packet);
+
+  protected static void addTestClass(Packet packet, String className) {
+    packet.
+        addLimitedString(PoolOfTestTypes.TEST_CLASS).
+        addLimitedString(className);
+  }
+
+  protected void addUnknownTest(Packet packet, Object test) {
+    packet.
+        addLimitedString(PoolOfTestTypes.UNKNOWN).
+        addLong(getTestCont(test)).
+        addLimitedString(test.getClass().getName());
+  }
+
+  protected static void addAllInPackage(Packet packet, String name) {
+    packet.
+        addLimitedString(PoolOfTestTypes.ALL_IN_PACKAGE).
+        addLimitedString(name);
+  }
+
+  protected static void addTestMethod(Packet packet, String methodName, String className) {
+    packet.
+        addLimitedString(PoolOfTestTypes.TEST_METHOD).
+        addLimitedString(methodName).
+        addLimitedString(className);
+  }
+
+  public int getKnownObject(Object description) {
+    final Object o = getKey(description);
+    if (o instanceof String) {
+      return Integer.parseInt((String)o);
+    }
+    return 0;
+  }
+
+  protected Object createObjectWrapper(Object object) {
+    return object;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/Packet.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/Packet.java
new file mode 100644
index 0000000..30e9dae
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/Packet.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+import junit.runner.BaseTestRunner;
+
+import java.io.*;
+import java.util.Collection;
+import java.util.Vector;
+
+public class Packet extends PacketWriter {
+  private final OutputObjectRegistry myRegistry;
+  private final PacketProcessor myTransport;
+  public static final char ourSpecialSymbol = '$';
+  public static final char[] ourSymbolsToEncode = new char[] {'\n', '\r', SegmentedStream.SPECIAL_SYMBOL};
+  public static final int CODE_LENGTH = 2;
+
+  public Packet(PacketProcessor transport, OutputObjectRegistry registry) {
+    myTransport = transport;
+    myRegistry = registry;
+  }
+
+  public Packet addObject(Object test) {
+    return addReference(myRegistry.referenceTo(test));
+  }
+
+  public Packet addObject(Object test, Collection packet) {
+    return addReference(myRegistry.referenceTo(test, packet));
+  }
+
+  public Packet addReference(String reference) {
+    appendString(reference + PoolOfDelimiters.REFERENCE_END);
+    return this;
+  }
+
+  public Packet switchInputTo(Object test) {
+    appendString(PoolOfDelimiters.INPUT_COSUMER);
+    return addObject(test);
+  }
+
+  public Packet addString(String string) {
+    appendString(string);
+    return this;
+  }
+
+  public void send() {
+    sendThrough(myTransport);
+  }
+
+  public Packet addLong(long integer) {
+    appendLong(integer);
+    return this;
+  }
+
+  public Packet setTestState(Object test, int state) {
+    return addString(PoolOfDelimiters.CHANGE_STATE).addObject(test).addLong(state);
+  }
+
+  public Packet addLimitedString(String message) {
+    appendLimitedString(message);
+    return this;
+  }
+
+  public Packet addThrowable(Throwable throwable) {
+    String filteredTrace;
+    try {
+      filteredTrace = BaseTestRunner.getFilteredTrace(throwable);
+    }
+    catch (Throwable e) {
+      filteredTrace = BaseTestRunner.getFilteredTrace(e);
+    }
+
+    String message;
+    try {
+      message = BaseTestRunner.getPreference("filterstack").equals("true") ? makeNewLinesCompatibleWithJUnit(throwableToString(throwable)) : throwableToString(throwable);
+    }
+    catch (Throwable e) {
+      message = throwableToString(e);
+    }
+
+    addLimitedString(message);
+    if (filteredTrace.startsWith(message))
+      filteredTrace = filteredTrace.substring(message.length());
+    addLimitedString(new TraceFilter(filteredTrace).execute());
+    return this;
+  }
+
+  private static String throwableToString(final Throwable throwable) {
+    final String tostring = throwable.toString();
+    return tostring == null ? throwable.getClass().getName() : tostring;
+  }
+
+  private static String makeNewLinesCompatibleWithJUnit(String string) {
+    try {
+      StringWriter buffer = new StringWriter();
+      PrintWriter writer = new PrintWriter(buffer);
+      BufferedReader reader = new BufferedReader(new StringReader(string));
+      String line;
+      while ((line = reader.readLine()) != null)
+        writer.println(line);
+      return buffer.getBuffer().toString();
+    } catch (IOException e) {return null;}
+  }
+
+  public static String encode(String packet) {
+    StringBuffer buffer = new StringBuffer(packet.length());
+    for (int i = 0; i < packet.length(); i++) {
+      char chr = packet.charAt(i);
+      if (chr == ourSpecialSymbol) {
+        buffer.append(chr);
+        buffer.append(chr);
+        continue;
+      }
+      boolean appendChar = true;
+      for (int j = 0; j < ourSymbolsToEncode.length; j++) {
+        if (ourSymbolsToEncode[j] == chr) {
+          buffer.append(ourSpecialSymbol);
+          final String code = String.valueOf((int)chr);
+          for (int count = CODE_LENGTH - code.length(); count > 0; count--) {
+            buffer.append("0");
+          }
+          buffer.append(code);
+          appendChar = false;
+          break;
+        }
+      }
+      if (appendChar) {
+        buffer.append(chr);
+      }
+    }
+    return buffer.toString();
+  }
+
+  public Packet addStrings(Vector vector) {
+    int size = vector.size();
+    addLong(size);
+    for (int i = 0; i < size; i++) {
+      addLimitedString((String)vector.elementAt(i));
+    }
+    return this;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketProcessor.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketProcessor.java
new file mode 100644
index 0000000..e214a0e
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketProcessor.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+public interface PacketProcessor {
+
+  void processPacket(String packet);
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketWriter.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketWriter.java
new file mode 100644
index 0000000..5ae08b6
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PacketWriter.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+public class PacketWriter {
+  private final StringBuffer myBody = new StringBuffer();
+
+  public void appendString(String string) {
+    myBody.append(string);
+  }
+
+  public void appendLong(long integer) {
+    myBody.append(integer);
+    myBody.append(PoolOfDelimiters.INTEGER_DELIMITER);
+  }
+
+  public void appendLimitedString(String message) {
+    if (message == null)
+      appendLimitedString("");
+    else {
+      appendLong(message.length());
+      appendString(message);
+    }
+  }
+
+  public String getString() {
+    return myBody.toString();
+  }
+
+  public void sendThrough(PacketProcessor transport) {
+    transport.processPacket(getString());
+  }
+
+  public void appendChar(char aChar) {
+    myBody.append(aChar);
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfDelimiters.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfDelimiters.java
new file mode 100644
index 0000000..6f87e8c
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfDelimiters.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+/**
+ * @noinspection HardCodedStringLiteral
+ */
+public interface PoolOfDelimiters {
+  char REFERENCE_END = ':';
+  String REFERENCE_END_STR = ":";
+  char INTEGER_DELIMITER = ' ';
+
+  String OBJECT_PREFIX = "O";
+  String TREE_PREFIX = "T";
+  String INPUT_COSUMER = "I";
+  String CHANGE_STATE = "S";
+  String TESTS_DONE = "D";
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfTestTypes.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfTestTypes.java
new file mode 100644
index 0000000..773413d
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/PoolOfTestTypes.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+/**
+ * @noinspection HardCodedStringLiteral
+ */
+public interface PoolOfTestTypes {
+  String TEST_METHOD = "TM";
+  String TEST_CLASS = "TC";
+  String ALL_IN_PACKAGE = "TN";
+
+  String UNKNOWN = "TU";
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedOutputStream.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedOutputStream.java
new file mode 100644
index 0000000..f6f8127
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedOutputStream.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+
+public class SegmentedOutputStream extends OutputStream implements PacketProcessor {
+  private final PrintStream myPrintStream;
+  private boolean myStarted = false;
+
+  public SegmentedOutputStream(PrintStream transportStream) {
+    this(transportStream, false);
+  }
+
+  public SegmentedOutputStream(PrintStream transportStream, boolean started) {
+    myPrintStream = transportStream;
+    myStarted = started;
+    try {
+      flush();
+    }
+    catch (IOException e) {
+      throw new RuntimeException(e.getLocalizedMessage());
+    }
+  }
+
+  public synchronized void write(int b) throws IOException {
+    if (b == SegmentedStream.SPECIAL_SYMBOL && myStarted) writeNext(b);
+    writeNext(b);
+    flush();
+  }
+
+  public synchronized void flush() throws IOException {
+    myPrintStream.flush();
+  }
+
+  public synchronized void close() throws IOException {
+    myPrintStream.close();
+  }
+
+  private void writeNext(int b) {
+    myPrintStream.write(b);
+  }
+
+  public synchronized void processPacket(String packet) {
+    if (!myStarted)
+      sendStart();
+    writeNext(SegmentedStream.MARKER_PREFIX);
+    String encodedPacket = Packet.encode(packet);
+    writeNext(String.valueOf(encodedPacket.length())+SegmentedStream.LENGTH_DELIMITER+encodedPacket);
+  }
+
+  private void writeNext(String string) {
+    try {
+      myPrintStream.write(string.getBytes());
+    } catch (IOException e) {
+      throw new RuntimeException(e.getMessage());
+    }
+  }
+
+  public void sendStart() {
+    writeNext(SegmentedStream.STARTUP_MESSAGE);
+    myStarted = true;
+  }
+
+  public PrintStream getPrintStream() {
+    return myPrintStream;
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedStream.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedStream.java
new file mode 100644
index 0000000..0248402
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/SegmentedStream.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+/**
+ * @noinspection HardCodedStringLiteral
+ */
+public interface SegmentedStream {
+  char SPECIAL_SYMBOL = '/';
+  String SPECIAL_SYMBOL_STRING = String.valueOf(SPECIAL_SYMBOL);
+  String MARKER_PREFIX = SPECIAL_SYMBOL_STRING + '\u0001';
+  String LENGTH_DELIMITER = " ";
+  String STARTUP_MESSAGE = "@#IJIDEA#JUnitSupport#@";
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/segments/TraceFilter.java b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/TraceFilter.java
new file mode 100644
index 0000000..95fdb5b
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/segments/TraceFilter.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.segments;
+
+import java.io.*;
+import java.util.Vector;
+
+class TraceFilter {
+  private final String myTrace;
+  private final Vector myLines = new Vector();
+
+  public TraceFilter(String trace) {
+    myTrace = trace;
+  }
+
+  public String execute() {
+    try {
+      readLines();
+    } catch (IOException e) {
+      return myTrace;
+    }
+    int traceLastLine = firstJUnitLine(myLines.size() - 1, true);
+    if (traceLastLine < 0) return "";
+    int traceFirstLine = firstJUnitLine(traceLastLine, false);
+    StringWriter buffer = new StringWriter();
+    PrintWriter writer = new PrintWriter(buffer);
+    for (int i = 0; i < traceFirstLine; i++) writer.println(myLines.elementAt(i));
+    for (int i = traceLastLine; i < myLines.size(); i++) writer.println(myLines.elementAt(i));
+    writer.flush();
+    return buffer.toString();
+  }
+
+  private int firstJUnitLine(int startFrom, boolean searchForJUnitLines) {
+    for (int i = startFrom; i >= 0; i--) {
+      String line = (String) myLines.elementAt(i);
+      if (isIdeaJUnit(line) == searchForJUnitLines) return i;
+    }
+    return startFrom;
+  }
+
+  /**
+   * @noinspection HardCodedStringLiteral
+   */
+  private boolean isIdeaJUnit(String line) {
+    return line.indexOf("com.intellij.rt") >= 0;
+  }
+
+  private void readLines() throws IOException {
+    BufferedReader reader = new BufferedReader(new StringReader(myTrace));
+    String line;
+    while ((line = reader.readLine()) != null) { myLines.addElement(line); }
+    reader.close();
+  }
+}
diff --git a/java/java-runtime/src/com/intellij/rt/execution/junit/states/PoolOfTestStates.java b/java/java-runtime/src/com/intellij/rt/execution/junit/states/PoolOfTestStates.java
new file mode 100644
index 0000000..f4f931c
--- /dev/null
+++ b/java/java-runtime/src/com/intellij/rt/execution/junit/states/PoolOfTestStates.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2000-2009 JetBrains s.r.o.
+ *
+ * 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 com.intellij.rt.execution.junit.states;
+
+public interface PoolOfTestStates {
+  int SKIPPED_INDEX = 0;
+  int COMPLETE_INDEX = 1;
+  int NOT_RUN_INDEX = 2;
+  int RUNNING_INDEX = 3;
+  int TERMINATED_INDEX = 4;
+  int IGNORED_INDEX = 5;
+  int FAILED_INDEX = 6;
+  int COMPARISON_FAILURE = 7;
+  int ERROR_INDEX = 8;
+  int PASSED_INDEX = COMPLETE_INDEX;
+}