/*******************************************************************************
* Copyright (c) 2006 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.xml.ui.tests;
import java.io.ByteArrayInputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import junit.framework.TestCase;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.reconciler.IReconciler;
import org.eclipse.jface.text.source.SourceViewerConfiguration;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.wst.sse.ui.StructuredTextEditor;
import org.eclipse.wst.sse.ui.internal.SSEUIPlugin;
import org.eclipse.wst.sse.ui.internal.provisional.preferences.CommonEditorPreferenceNames;
import org.eclipse.wst.sse.ui.internal.reconcile.DocumentRegionProcessor;
import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorMetaData;
import org.eclipse.wst.sse.ui.internal.reconcile.validator.ValidatorStrategy;
/**
* Tests reconciler in an open editor. The location of this class is awkward
* in that it refers to content types declared in plugins that aren't required
* to be present.
*/
public class TestSourceValidationFramework extends TestCase {
/**
* THIS SUBCLASS IS FOR TESTING ONLY
*/
public static class TestStructuredTextEditor extends StructuredTextEditor {
public SourceViewerConfiguration textViewerConfiguration = null;
protected void setSourceViewerConfiguration(SourceViewerConfiguration config) {
super.setSourceViewerConfiguration(config);
textViewerConfiguration = config;
}
}
private static final String PROJECT_NAME = "TestSourceValidationFramework";
private static final String SEPARATOR = String.valueOf(IPath.SEPARATOR);
private boolean fPreviousReconcilerPref;
public TestSourceValidationFramework() {
super("TestSourceValidationFramework");
}
private IFile ensureFileIsAccessible(String filePath, byte[] contents) {
IFile blankFile = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(filePath));
if (blankFile != null && !blankFile.isAccessible()) {
try {
byte[] bytes = contents;
if (bytes == null) {
bytes = new byte[0];
}
blankFile.create(new ByteArrayInputStream(bytes), true, new NullProgressMonitor());
}
catch (CoreException e) {
e.printStackTrace();
}
}
return blankFile;
}
private IContentType[] detectContentTypes(String fileName) {
IContentType[] types = null;
IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);
types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
if (types.length == 0) {
IContentDescription d = null;
try {
// optimized description lookup, might not succeed
d = file.getContentDescription();
if (d != null) {
types = new IContentType[]{d.getContentType()};
}
}
catch (CoreException e) {
/*
* should not be possible given the accessible and file type
* check above
*/
}
}
if (types == null) {
types = Platform.getContentTypeManager().findContentTypesFor(file.getName());
}
return types;
}
private String[] detectContentTypeIDs(String fileName) {
IContentType[] types = detectContentTypes(fileName);
String[] ids = new String[types.length];
for (int i = 0; i < types.length; i++) {
ids[i] = types[i].getId();
}
return ids;
}
private boolean identicalContents(Object o1[], Object o2[]) {
if (o1.length == 0 && o2.length == 0)
return true;
Object[] array1 = new Object[o1.length];
Object[] array2 = new Object[o2.length];
System.arraycopy(o1, 0, array1, 0, o1.length);
System.arraycopy(o2, 0, array2, 0, o2.length);
Arrays.sort(array1);
Arrays.sort(array2);
return Arrays.equals(array1, array2);
}
private void ensureProjectIsAccessible(String projName) {
IProjectDescription description = ResourcesPlugin.getWorkspace().newProjectDescription(projName);
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
try {
if (!project.exists())
project.create(description, new NullProgressMonitor());
if (!project.isAccessible())
project.open(new NullProgressMonitor());
}
catch (CoreException e) {
e.printStackTrace();
}
}
private List getSourceValidatorIDs(String fileName) throws Exception {
List validatorIds = new ArrayList(1);
IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
IWorkbenchPage page = workbenchWindow.getActivePage();
IFile file = ensureFileIsAccessible(PROJECT_NAME + SEPARATOR + fileName, null);
IEditorPart editor = IDE.openEditor(page, file, TestStructuredTextEditor.class.getName(), true);
ITextEditor textEditor = (ITextEditor) editor.getAdapter(ITextEditor.class);
TestStructuredTextEditor testTextEditor = (TestStructuredTextEditor) textEditor;
IReconciler reconciler = testTextEditor.textViewerConfiguration.getReconciler(testTextEditor.getTextViewer());
assertNotNull(reconciler);
assertTrue("unexpected IReconciler implementation: " + reconciler.getClass(), reconciler instanceof DocumentRegionProcessor);
Class reconcilerClass = reconciler.getClass();
Method method = null;
while (reconcilerClass != Object.class && method == null) {
Method[] methods = reconcilerClass.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
if (methods[i].getName().equals("getValidatorStrategy")) {
method = methods[i];
}
}
reconcilerClass = reconcilerClass.getSuperclass();
}
assertNotNull("no getValidatorStrategy method found on " + reconciler.getClass(), method);
method.setAccessible(true);
ValidatorStrategy strategy = (ValidatorStrategy) method.invoke(reconciler, new Object[0]);
assertNotNull(strategy);
Field fMetaData = strategy.getClass().getDeclaredField("fMetaData");
assertNotNull("validator metadata field \"fMetaData\" not found on strategy " + strategy.getClass(), fMetaData);
fMetaData.setAccessible(true);
List metadata = (List) fMetaData.get(strategy);
assertNotNull(metadata);
for (int i = 0; i < metadata.size(); i++) {
validatorIds.add(((ValidatorMetaData) metadata.get(i)).getValidatorId());
}
page.closeEditor(editor, false);
return validatorIds;
}
protected void setUp() throws Exception {
ensureProjectIsAccessible(PROJECT_NAME);
// turn on reconciling
IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
fPreviousReconcilerPref = store.getBoolean(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS);
if (!fPreviousReconcilerPref) {
store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, true);
}
}
protected void tearDown() throws Exception {
// restore reconciling preference
IPreferenceStore store = SSEUIPlugin.getDefault().getPreferenceStore();
store.setValue(CommonEditorPreferenceNames.EVALUATE_TEMPORARY_PROBLEMS, fPreviousReconcilerPref);
}
public void testSourceValidationEnablementWithInheritedValidators() throws Exception {
Object[] xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml").toArray();
assertTrue("No XML source validators found", xmlValidatorIDs.length > 0);
Object[] xml99ValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml99").toArray();
assertTrue("No XML99 source validators found", xml99ValidatorIDs.length > 0);
Arrays.sort(xmlValidatorIDs);
Arrays.sort(xml99ValidatorIDs);
assertEquals("validator lists should be the same length", xmlValidatorIDs.length, xml99ValidatorIDs.length);
for (int i = 0; i < xmlValidatorIDs.length; i++) {
assertEquals("validator IDs should be the same [" + i + "]", xmlValidatorIDs[i], xml99ValidatorIDs[i]);
}
}
public void testSourceValidationEnablementWithUniqueValidators() throws Exception {
String[] xmlContentTypes = detectContentTypeIDs("testValidatorConfigurations.xml");
String[] xsdContentTypes = detectContentTypeIDs("testValidatorConfigurations.xsd");
/*
* If the current configuration does not include a distinct XSD
* content type, skip the rest
*/
if (!identicalContents(xmlContentTypes, xsdContentTypes)) {
List xmlValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xml");
assertTrue("No XML source validators found", !xmlValidatorIDs.isEmpty());
List xsdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.xsd");
assertTrue("No XSD source validators found", !xsdValidatorIDs.isEmpty());
for (int i = 0; i < xmlValidatorIDs.size(); i++) {
assertTrue("XML Validator found on XSD input", !xsdValidatorIDs.contains(xmlValidatorIDs.get(i)));
}
}
else {
String message = "No distinct XSD content type found while running " + getClass().getName();
System.err.println(message);
Logger.log(Logger.WARNING, message);
}
}
public void testSourceValidationEnablementWithUnrelatedContentTypes() throws Exception {
String[] dtdContentTypes = detectContentTypeIDs("testValidatorConfigurations.dtd");
String[] jspContentTypes = detectContentTypeIDs("testValidatorConfigurations.jsp");
if (dtdContentTypes.length == 0) {
String message = "No DTD content type found while running " + getClass().getName();
System.err.println(message);
Logger.log(Logger.WARNING, message);
}
if (jspContentTypes.length == 0) {
String message = "No JSP content type found while running " + getClass().getName();
System.err.println(message);
Logger.log(Logger.WARNING, message);
}
if (dtdContentTypes.length > 0 && jspContentTypes.length > 0 && !identicalContents(dtdContentTypes, jspContentTypes)) {
List dtdValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.dtd");
assertTrue("No DTD source validators found", !dtdValidatorIDs.isEmpty());
List jspValidatorIDs = getSourceValidatorIDs("testValidatorConfigurations.jsp");
assertTrue("No JSP source validators found", !jspValidatorIDs.isEmpty());
int dtdValidatorCount = dtdValidatorIDs.size();
dtdValidatorIDs.removeAll(jspValidatorIDs);
assertEquals("validators found running on both CSS and DTD", dtdValidatorCount, dtdValidatorIDs.size());
}
}
}