diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/.classpath b/tests/org.eclipse.wst.jsdt.ui.tests/.classpath
new file mode 100644
index 0000000..f1b3ad8
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/.cvsignore b/tests/org.eclipse.wst.jsdt.ui.tests/.cvsignore
new file mode 100644
index 0000000..0551845
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/.cvsignore
@@ -0,0 +1,2 @@
+build.xml
+javaCompiler...args
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/.project b/tests/org.eclipse.wst.jsdt.ui.tests/.project
new file mode 100644
index 0000000..a5efba6
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.wst.jsdt.ui.tests</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/META-INF/MANIFEST.MF b/tests/org.eclipse.wst.jsdt.ui.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..fe366a3
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,20 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %pluginName
+Bundle-SymbolicName: org.eclipse.wst.jsdt.ui.tests; singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: %providerName
+Bundle-Localization: plugin
+Require-Bundle: org.eclipse.core.resources;bundle-version="[3.4.0,4.0.0)",
+ org.eclipse.core.runtime;bundle-version="[3.4.0,4.0.0)",
+ org.eclipse.wst.jsdt.core,
+ org.eclipse.wst.jsdt.ui,
+ org.eclipse.ui.editors,
+ org.eclipse.jface,
+ org.eclipse.jface.text,
+ org.eclipse.ui.workbench.texteditor,
+ org.eclipse.ui.ide,
+ org.junit;bundle-version="[3.8.2,4.0.0)"
+Bundle-RequiredExecutionEnvironment: J2SE-1.4
+Bundle-ActivationPolicy: lazy
+Bundle-Activator: org.eclipse.wst.jsdt.ui.tests.internal.Activator
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/about.html b/tests/org.eclipse.wst.jsdt.ui.tests/about.html
new file mode 100644
index 0000000..e52bf6e
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/about.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
+<title>About</title>
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>June 2, 2006</p>	
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise 
+indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 1.0 (&quot;EPL&quot;).  A copy of the EPL is available 
+at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is 
+being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was 
+provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content
+and such source code may be obtained at <a href="http://www.eclipse.org">http://www.eclipse.org</a>.</p>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/build.properties b/tests/org.eclipse.wst.jsdt.ui.tests/build.properties
new file mode 100644
index 0000000..3b9e28d
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/build.properties
@@ -0,0 +1,18 @@
+###############################################################################
+# Copyright (c) 2005, 2007 IBM Corporation and others.
+# 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:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+bin.includes = test.xml,\
+               .,\
+               plugin.properties,\
+               META-INF/,\
+               about.html
+src.includes = test.xml
+source.. = src/
+jars.compile.order = .
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/plugin.properties b/tests/org.eclipse.wst.jsdt.ui.tests/plugin.properties
new file mode 100644
index 0000000..23d022a
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/plugin.properties
@@ -0,0 +1,16 @@
+###############################################################################
+# Copyright (c) 2007,2009 IBM Corporation and others.
+# 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:
+#     IBM Corporation - initial API and implementation
+###############################################################################
+
+#
+# Messages in plugin.xml.
+#
+pluginName=JSDT Tests - UI
+providerName=Eclipse.org
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/EditorTests.java b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/EditorTests.java
new file mode 100644
index 0000000..2268093
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/EditorTests.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2009 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.wst.jsdt.ui.tests;
+
+import junit.framework.TestCase;
+
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.text.source.IAnnotationModel;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.ide.IDE;
+import org.eclipse.ui.texteditor.ITextEditor;
+import org.eclipse.wst.jsdt.internal.ui.javaeditor.JavaEditor;
+import org.eclipse.wst.jsdt.ui.JavaScriptUI;
+import org.eclipse.wst.jsdt.ui.tests.internal.JsStorageEditorInput;
+
+/**
+ * @author nitin
+ * 
+ */
+public class EditorTests extends TestCase {
+
+	/**
+	 * 
+	 */
+	public EditorTests() {
+	}
+
+	/**
+	 * @param name
+	 */
+	public EditorTests(String name) {
+		super(name);
+	}
+
+	public void testOpenEditorWithStorageEditorInput() throws PartInitException {
+		IEditorInput input = new JsStorageEditorInput("var a = {};", new Path("/" + getName() + "/testfile.js"));
+
+		IEditorPart editor = IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), input, JavaScriptUI.ID_CU_EDITOR, true);
+		// Now add the problems we found
+		assertTrue("unexpected editor opened", editor instanceof JavaEditor && editor instanceof ITextEditor);
+		IAnnotationModel annotationModel = ((ITextEditor) editor).getDocumentProvider().getAnnotationModel(input);
+		assertNotNull("no annotation model present", annotationModel);
+
+		PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().closeEditor(editor, false);
+	}
+	
+	public void testOpenEditorWithEmptyStorageEditorInput() throws PartInitException {
+		IEditorInput input = new JsStorageEditorInput("", new Path("/" + getName() + "/testfile.js"));
+
+		IEditorPart editor = IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), input, JavaScriptUI.ID_CU_EDITOR, true);
+		// Now add the problems we found
+		assertTrue("unexpected editor opened", editor instanceof JavaEditor && editor instanceof ITextEditor);
+		IAnnotationModel annotationModel = ((ITextEditor) editor).getDocumentProvider().getAnnotationModel(input);
+		assertNotNull("no annotation model present", annotationModel);
+
+		PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().closeEditor(editor, false);
+	}
+}
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/JSDTUITests.java b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/JSDTUITests.java
new file mode 100644
index 0000000..6b586d8
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/JSDTUITests.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2009 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.wst.jsdt.ui.tests;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.eclipse.wst.jsdt.core.JavaScriptCore;
+
+/**
+ * @author nitin
+ *
+ */
+public class JSDTUITests extends TestSuite {
+
+	/**
+	 * @param name
+	 */
+	public JSDTUITests(String name) {
+		super(name);
+		// TODO Auto-generated constructor stub
+	}
+
+	static {
+		JavaScriptCore.getPlugin().getPluginPreferences().setValue("semanticValidation", true);
+	}
+
+	public JSDTUITests() {
+		this("JSDT UI Tests");
+	}
+
+	public static Test suite() {
+
+		ArrayList standardTests = new ArrayList();
+		
+		standardTests.add(EditorTests.class);
+
+		TestSuite all = new TestSuite("JSDT UI Tests");
+		for (Iterator iter = standardTests.iterator(); iter.hasNext();) {
+			Class test = (Class) iter.next();
+			all.addTestSuite(test); 
+		}
+		return all;
+	} 
+	}
\ No newline at end of file
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/Activator.java b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/Activator.java
new file mode 100644
index 0000000..c4587cc
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/Activator.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2009 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.wst.jsdt.ui.tests.internal;
+
+import org.eclipse.core.runtime.Plugin;
+
+/**
+ * @author nitin
+ *
+ */
+public class Activator extends Plugin {
+
+	/**
+	 * 
+	 */
+	public Activator() {
+		// TODO Auto-generated constructor stub
+	}
+
+}
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/JsStorageEditorInput.java b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/JsStorageEditorInput.java
new file mode 100644
index 0000000..9b2f942
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/src/org/eclipse/wst/jsdt/ui/tests/internal/JsStorageEditorInput.java
@@ -0,0 +1,164 @@
+/*******************************************************************************
+ * Copyright (c) 2008, 2009 IBM Corporation and others.
+ * 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:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.wst.jsdt.ui.tests.internal;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+
+import org.eclipse.core.resources.IStorage;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.ui.IPersistableElement;
+import org.eclipse.ui.IStorageEditorInput;
+
+/**
+ * @author nitin
+ * 
+ */
+public class JsStorageEditorInput implements IStorageEditorInput {
+	private static class JSStorage implements IStorage {
+		private String fContents;
+		private IPath fPath;
+
+		/**
+		 * 
+		 */
+		public JSStorage(String contents, IPath path) {
+			fContents = contents;
+			fPath = path;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see
+		 * org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
+		 */
+		public Object getAdapter(Class adapter) {
+			return Platform.getAdapterManager().getAdapter(this, adapter);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see org.eclipse.core.resources.IStorage#getContents()
+		 */
+		public InputStream getContents() throws CoreException {
+			return new ByteArrayInputStream(fContents.getBytes());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see org.eclipse.core.resources.IStorage#getFullPath()
+		 */
+		public IPath getFullPath() {
+			return fPath;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see org.eclipse.core.resources.IStorage#getName()
+		 */
+		public String getName() {
+			return fPath.lastSegment();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see org.eclipse.core.resources.IStorage#isReadOnly()
+		 */
+		public boolean isReadOnly() {
+			return true;
+		}
+	}
+
+	IStorage fStorage;
+
+	/**
+	 * 
+	 */
+	public JsStorageEditorInput(IStorage storage) {
+		fStorage = storage;
+	}
+
+	public JsStorageEditorInput(String contents, IPath path) {
+		this(new JSStorage(contents, path));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IEditorInput#exists()
+	 */
+	public boolean exists() {
+		return false;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
+	 */
+	public Object getAdapter(Class adapter) {
+		return Platform.getAdapterManager().getAdapter(this, adapter);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IEditorInput#getImageDescriptor()
+	 */
+	public ImageDescriptor getImageDescriptor() {
+		return null;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IEditorInput#getName()
+	 */
+	public String getName() {
+		return fStorage.getName();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IEditorInput#getPersistable()
+	 */
+	public IPersistableElement getPersistable() {
+		return null;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IStorageEditorInput#getStorage()
+	 */
+	public IStorage getStorage() throws CoreException {
+		return fStorage;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see org.eclipse.ui.IEditorInput#getToolTipText()
+	 */
+	public String getToolTipText() {
+		return fStorage.getFullPath().toString();
+	}
+}
diff --git a/tests/org.eclipse.wst.jsdt.ui.tests/test.xml b/tests/org.eclipse.wst.jsdt.ui.tests/test.xml
new file mode 100644
index 0000000..4460333
--- /dev/null
+++ b/tests/org.eclipse.wst.jsdt.ui.tests/test.xml
@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project
+    name="testsuite"
+    default="run"
+    basedir=".">
+    
+    <!-- The following properties should be passed into this script -->
+    <!-- ${eclipse-home}   -->
+    <!-- ${buildDirectory}  -->
+    <!-- ${buildLabel}        -->
+
+    <!-- should be little need to change what's above  -->
+    <property
+        name="plugin-name"
+        value="org.eclipse.wst.jsdt.ui.tests" />
+    <property
+        name="classname"
+        value="org.eclipse.wst.jsdt.ui.tests.JSDTUITests" />
+    <property
+        name="testType"
+        value="ui-test" />
+
+    <!-- should be little need to change what's below -->
+
+    <echo message="basedir: ${basedir}" />
+    <echo message="eclipse-home: ${eclipse-home}" />
+    <echo message="buildDirectory: ${buildDirectory}" />
+    <echo message="plugin-name: ${plugin-name}" />
+    <echo message="classname: ${classname}" />
+    <echo message="testType ${testType}" />
+
+
+    <property
+        name="library-file"
+        value="${eclipse-home}/plugins/org.eclipse.test_3.1.0/library.xml" />
+    <property
+        name="workspace"
+        value="${eclipse-home}/junitworkspaces/${plugin-name}" />
+        
+    <!-- This target holds all initialization code that needs to be done for -->
+    <!-- all tests that are to be run. Initialization for individual tests -->
+    <!-- should be done within the body of the suite target. -->
+    <target name="init">
+        <tstamp />
+        <delete>
+            <fileset
+                dir="${eclipse-home}"
+                includes="${plugin-name}.*xml" />
+        </delete>
+        <!-- make directory, in case path doesn't exist yet -->
+        <mkdir dir="${workspace}" />
+        <!--  but delete to make sure fresh contents-->
+        <delete
+            dir="${workspace}"
+            quiet="true" />
+
+    </target>
+
+    <!-- This target defines the tests that need to be run. -->
+    <target name="suite">
+
+        <ant
+            target="${testType}"
+            antfile="${library-file}"
+            dir="${eclipse-home}">
+            <property
+                name="data-dir"
+                value="${workspace}" />
+            <property
+                name="plugin-name"
+                value="${plugin-name}" />
+            <property
+                name="classname"
+                value="${classname}" />
+            <property
+                name="plugin-path"
+                value="${eclipse-home}/plugins/${plugin-name}" />
+        </ant>
+
+        <copy
+            failonerror="false"
+            file="${workspace}/.metadata/.log"
+            tofile="${buildDirectory}/${buildLabel}/testResults/consolelogs/${plugin-name}.consolelog.txt" />
+
+    </target>
+
+    <!-- This target holds code to cleanup the testing environment after -->
+    <!-- after all of the tests have been run. You can use this target to -->
+    <!-- delete temporary files that have been created. -->
+    <target name="cleanup">
+        <!-- usually no need to delete workspace until next run, and leaving it allows inspection -->
+        <!-- <delete dir="${workspace}" quiet="true" /> -->
+    </target>
+
+    <!-- This target runs the test suite. Any actions that need to happen -->
+    <!-- after all the tests have been run should go here. -->
+    <target
+        name="run"
+        depends="init,suite,cleanup">
+        <ant
+            target="collect"
+            antfile="${library-file}"
+            dir="${eclipse-home}">
+            <property
+                name="includes"
+                value="${plugin-name}.*xml" />
+            <property
+                name="output-file"
+                value="${plugin-name}.xml" />
+        </ant>
+    </target>
+
+</project>
\ No newline at end of file
