| /******************************************************************************* |
| * Copyright (c) 2004, 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.html.core.tests.parser; |
| |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.io.Writer; |
| |
| import junit.framework.TestCase; |
| |
| import org.eclipse.wst.html.core.tests.utils.DateUtil; |
| import org.eclipse.wst.html.core.tests.utils.FileUtil; |
| import org.eclipse.wst.html.core.tests.utils.StringCompareUtil; |
| import org.eclipse.wst.html.core.tests.utils.TestWriter; |
| import org.eclipse.wst.sse.core.StructuredModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IModelManager; |
| import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument; |
| import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion; |
| import org.eclipse.wst.sse.core.utils.StringUtils; |
| import org.eclipse.wst.xml.core.internal.document.StructuredDocumentRegionChecker; |
| import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel; |
| import org.w3c.dom.Node; |
| |
| public abstract class ModelTest extends TestCase { |
| |
| public final static String testResultsDirectoryPrefix = "ParserResults"; |
| private final static String fileExtension = ".txt"; |
| protected TestWriter fOutputWriter = new TestWriter(); |
| private int READ_BUFFER_SIZE = 4096; |
| |
| private boolean echoToSystemOut = false; |
| private boolean printedOnce; |
| private boolean printSummaryToSystemOut; |
| |
| /** |
| * Constructor for ModelTest. |
| * |
| * @param name |
| */ |
| public ModelTest(String name) { |
| super(name); |
| try { |
| printClass(); |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| public ModelTest() { |
| this("dummy"); |
| // try { |
| // printClass(); |
| // } catch (IOException e) { |
| // e.printStackTrace(); |
| // } |
| } |
| |
| public static IDOMModel createHTMLModel() { |
| |
| //return new XMLModelImpl(); |
| |
| IStructuredModel model = null; |
| try { |
| IModelManager modelManager = StructuredModelManager.getModelManager(); |
| |
| model = modelManager.getModelForEdit("test.html", new NullInputStream(), null); |
| |
| // always use the same line delimiter for these tests, regardless |
| // of |
| // plaform or preference settings |
| model.getStructuredDocument().setLineDelimiter(TestWriter.commonEOL); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| //assertTrue("basic XML empty model could not be created", model != |
| // null); |
| return (IDOMModel) model; |
| |
| } |
| |
| public static IDOMModel createXMLModel() { |
| |
| //return new XMLModelImpl(); |
| |
| IStructuredModel model = null; |
| try { |
| IModelManager modelManager = StructuredModelManager.getModelManager(); |
| //assertTrue("modelManager must not be null", modelManager != |
| // null); |
| |
| model = modelManager.getModelForEdit("test.xml", new NullInputStream(), null); |
| |
| // always use the same line delimiter for these tests, regardless |
| // of |
| // plaform or preference settings |
| model.getStructuredDocument().setLineDelimiter(TestWriter.commonEOL); |
| |
| |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| //assertTrue("basic XML empty model could not be created", model != |
| // null); |
| return (IDOMModel) model; |
| |
| } |
| |
| /** |
| */ |
| private void printClass() throws IOException { |
| fOutputWriter.writeln(getClass().getName()); |
| } |
| |
| public static void printException(Exception ex) { |
| ex.printStackTrace(); |
| } |
| |
| private void printNode(Node node, int indent) { |
| try { |
| StringBuffer buffer = new StringBuffer(10); |
| for (int i = 0; i < indent; i++) |
| buffer.append("--"); |
| buffer.append(StringUtils.escape(node.toString())); |
| fOutputWriter.writeln(buffer.toString()); |
| indent++; |
| Node child = node.getFirstChild(); |
| while (child != null) { |
| printNode(child, indent); |
| child = child.getNextSibling(); |
| } |
| } |
| catch (Exception ex) { |
| printException(ex); |
| } |
| } |
| |
| public void printSource(IDOMModel model) { |
| try { |
| fOutputWriter.writeln("Source :"); |
| fOutputWriter.writeln(model.getStructuredDocument().getText()); |
| fOutputWriter.writeln(""); |
| } |
| catch (Exception ex) { |
| printException(ex); |
| } |
| } |
| |
| public void printTree(IDOMModel model) { |
| try { |
| printFlatModel(model.getStructuredDocument()); |
| new StructuredDocumentRegionChecker(fOutputWriter).checkModel(model); |
| fOutputWriter.writeln("Tree :"); |
| printNode(model.getDocument(), 0); |
| fOutputWriter.writeln(""); |
| |
| } |
| catch (Exception ex) { |
| printException(ex); |
| } |
| |
| } |
| |
| protected void saveAndCompareTestResults() { |
| try { |
| String testOutputDirectory = testResultsDirectoryPrefix + DateUtil.now(); |
| String currentFilename = getClass().getName() + fileExtension; |
| File fileout = FileUtil.makeFileFor(testOutputDirectory, currentFilename, testResultsDirectoryPrefix); |
| Writer fileWriter = new FileWriter(fileout); |
| fileWriter.write(fOutputWriter.toString()); |
| fileWriter.close(); |
| compareWithPreviousResults(fOutputWriter, currentFilename); |
| |
| if (echoToSystemOut) { |
| System.out.println(fOutputWriter.toString()); |
| } |
| |
| fOutputWriter.close(); |
| } |
| catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * Method compareWithPreviousResults. |
| * |
| * @param outputWriter |
| * @param currentFilename |
| */ |
| private void compareWithPreviousResults(TestWriter outputWriter, String currentFilename) throws IOException { |
| boolean success = false; |
| File previousResultsDir = FileUtil.getPreviousResultsDirectory(testResultsDirectoryPrefix); |
| if (previousResultsDir != null) { |
| String currentResults = outputWriter.toString(); |
| File previousResultsFile = new File(previousResultsDir, currentFilename); |
| FileReader previousResultsFileReader = new FileReader(previousResultsFile); |
| String previousResults = readString(previousResultsFileReader); |
| StringCompareUtil stringCompare = new StringCompareUtil(); |
| // trying to "force" the same linedelimter didn't work well, |
| // I think since the line delimiter is input on some tests, |
| // and CVS is likely to change anyway (for ASCII files). |
| // so we'll ignore in our comparisons. Note: we wouldn't |
| // want to ignore whitespace. There might actually be some |
| // tests that are not as accurate if we ignore EOL, but there |
| // seems to be no easy way to handle, with out a lot of trouble. |
| if (!stringCompare.equalsIgnoreLineSeperator(previousResults, currentResults)) { |
| // previousResults.equals(currentResults)) { |
| // fail |
| success = false; |
| |
| System.out.println(); |
| System.out.println(currentFilename + " failed comparison to previous results"); |
| System.out.println("Previous: "); |
| System.out.println(previousResults); |
| System.out.println(); |
| System.out.println("Current: "); |
| System.out.println(currentResults); |
| System.out.println(); |
| } |
| else { |
| success = true; |
| if (printSummaryToSystemOut) { |
| System.out.println(); |
| System.out.println(currentFilename + " compared ok"); |
| System.out.println(); |
| } |
| } |
| } |
| else { |
| if (!printedOnce) { |
| System.out.println(); |
| System.out.println("No Previous Directory found ... couldn't compare " + currentFilename + " with previous results"); |
| printedOnce = true; |
| System.out.println(); |
| } |
| } |
| assertTrue("current is not equal to reference results for " + currentFilename, success); |
| } |
| |
| /** |
| * Method readString. |
| * |
| * @param previousResultsFileReader |
| * @return String |
| */ |
| private String readString(FileReader fileReader) throws IOException { |
| return readInputStream(fileReader); |
| } |
| |
| private String readInputStream(InputStreamReader inputStreamReader) throws IOException { |
| int numRead = 0; |
| StringBuffer buffer = new StringBuffer(); |
| char tBuff[] = new char[READ_BUFFER_SIZE]; |
| while ((numRead = inputStreamReader.read(tBuff, 0, tBuff.length)) != -1) { |
| buffer.append(tBuff, 0, numRead); |
| } |
| // remember -- we didn't open stream ... so we don't close it |
| return buffer.toString(); |
| } |
| |
| public abstract void testModel(); |
| |
| protected void printFlatModel(IStructuredDocument flatModel) { |
| fOutputWriter.writeln(""); |
| fOutputWriter.writeln("StructuredDocument Regions :"); |
| IStructuredDocumentRegion flatnode = flatModel.getFirstStructuredDocumentRegion(); |
| while (flatnode != null) { |
| |
| fOutputWriter.writeln(flatnode.toString()); |
| flatnode = flatnode.getNext(); |
| |
| } |
| fOutputWriter.writeln(""); |
| |
| } |
| } |