001: /*
002: * Copyright (C) Chaperon. All rights reserved.
003: * -------------------------------------------------------------------------
004: * This software is published under the terms of the Apache Software License
005: * version 1.1, a copy of which has been included with this distribution in
006: * the LICENSE file.
007: */
008:
009: package net.sourceforge.chaperon.test;
010:
011: import junit.framework.*;
012:
013: import net.sourceforge.chaperon.build.LexicalAutomatonBuilder;
014: import net.sourceforge.chaperon.common.ConsoleLog;
015: import net.sourceforge.chaperon.model.lexicon.Lexicon;
016: import net.sourceforge.chaperon.model.lexicon.LexiconFactory;
017: import net.sourceforge.chaperon.process.*;
018:
019: import org.custommonkey.xmlunit.Diff;
020:
021: import org.w3c.dom.*;
022:
023: import org.xml.sax.*;
024:
025: import java.io.*;
026:
027: import javax.xml.parsers.*;
028: import javax.xml.transform.*;
029: import javax.xml.transform.dom.*;
030: import javax.xml.transform.sax.*;
031: import javax.xml.transform.stream.*;
032:
033: public class LexicalProcessorTestCase extends TestCase {
034: private String name;
035: private Element step;
036:
037: public LexicalProcessorTestCase(String name) {
038: super (name);
039: this .name = name;
040: }
041:
042: public LexicalProcessorTestCase(String name, Element step) {
043: super (name);
044: this .name = name;
045: this .step = step;
046: }
047:
048: public void runTest() throws Throwable {
049: System.out.println("======================= " + name
050: + " =======================");
051:
052: Lexicon lexicon = getLexicon(step);
053:
054: LexicalProcessor processor = getLexicalProcessor(lexicon);
055:
056: Document result = process(processor, step);
057: Document expected = getResult(step);
058:
059: assertEqual(expected, result);
060: }
061:
062: private LexicalProcessor getLexicalProcessor(Lexicon lexicon) {
063: LexicalProcessor processor = new LexicalProcessor();
064: processor.setLog(new ConsoleLog());
065:
066: LexicalAutomaton automaton =
067: // (new LexicalAutomatonBuilder(getLexicon(), new ConsoleLog())).getLexicalAutomaton();
068: (new LexicalAutomatonBuilder(lexicon)).getLexicalAutomaton();
069:
070: assertNotNull("Test if automaton is generated", automaton);
071:
072: processor.setLexicalAutomaton(automaton);
073:
074: NodeList list = step.getElementsByTagName("parameter");
075: for (int i = 0; i < list.getLength(); i++) {
076: Element element = (Element) list.item(i);
077: if (element.getAttribute("name").equals("grouping"))
078: processor.setGrouping(Boolean.valueOf(
079: element.getAttribute("value")).booleanValue());
080: }
081:
082: return processor;
083: }
084:
085: private Document process(LexicalProcessor processor, Element step)
086: throws Exception {
087: NodeList list = step.getElementsByTagNameNS(
088: LexicalProcessor.NS, LexicalProcessor.TEXT);
089: Node node = list.item(0);
090:
091: TransformerFactory streamerfactory = TransformerFactory
092: .newInstance();
093: Transformer streamer = streamerfactory.newTransformer();
094:
095: SAXTransformerFactory serializerfactory = (SAXTransformerFactory) SAXTransformerFactory
096: .newInstance();
097: TransformerHandler serializer = serializerfactory
098: .newTransformerHandler();
099: DOMResult result = new DOMResult();
100: serializer.setResult(result);
101:
102: processor.setContentHandler(new WhitespaceFilter(serializer));
103:
104: streamer.transform(new DOMSource(node),
105: new SAXResult(processor));
106:
107: return (Document) result.getNode();
108: }
109:
110: private Lexicon getLexicon(Element step) throws Exception {
111: NodeList list = step.getElementsByTagNameNS(
112: "http://chaperon.sourceforge.net/schema/lexicon/1.0",
113: "lexicon");
114: Node node = list.item(0);
115:
116: TransformerFactory streamerfactory = TransformerFactory
117: .newInstance();
118: Transformer streamer = streamerfactory.newTransformer();
119:
120: LexiconFactory lexiconfactory = new LexiconFactory();
121:
122: streamer.transform(new DOMSource(node), new SAXResult(
123: lexiconfactory));
124: return lexiconfactory.getLexicon();
125: }
126:
127: private Document getResult(Element step) throws Exception {
128: NodeList list = step.getElementsByTagNameNS(
129: LexicalProcessor.NS_OUTPUT, LexicalProcessor.OUTPUT);
130: Node node = list.item(0);
131:
132: TransformerFactory streamerfactory = TransformerFactory
133: .newInstance();
134: Transformer streamer = streamerfactory.newTransformer();
135:
136: DOMResult result = new DOMResult();
137:
138: streamer.transform(new DOMSource(node), result);
139:
140: return (Document) result.getNode();
141: }
142:
143: private static Document getDocument(String filename, InputStream in)
144: throws Exception {
145: SAXParserFactory parserfactory = SAXParserFactory.newInstance();
146: parserfactory.setNamespaceAware(true);
147:
148: XMLReader parser = parserfactory.newSAXParser().getXMLReader();
149:
150: SAXTransformerFactory serializerfactory = (SAXTransformerFactory) SAXTransformerFactory
151: .newInstance();
152: TransformerHandler handler = serializerfactory
153: .newTransformerHandler();
154: DOMResult result = new DOMResult();
155: handler.setResult(result);
156:
157: parser.setContentHandler(new WhitespaceFilter(handler));
158:
159: InputSource inputsource = new InputSource(in);
160: inputsource.setSystemId(filename);
161: parser.parse(inputsource);
162:
163: return (Document) result.getNode();
164: }
165:
166: public final void print(Document document) throws Exception {
167: TransformerFactory factory = TransformerFactory.newInstance();
168: javax.xml.transform.Transformer serializer = factory
169: .newTransformer();
170: serializer.transform(new DOMSource(document), new StreamResult(
171: System.out));
172: System.out.println();
173: }
174:
175: /**
176: * Compare two XML documents provided as strings
177: *
178: * @param control Control document
179: * @param test Document to test
180: *
181: * @return Diff object describing differences in documents
182: */
183: public final Diff compareXML(Document control, Document test) {
184: return new Diff(control, test);
185: }
186:
187: /**
188: * Assert that the result of an XML comparison is similar.
189: *
190: * @param msg The assertion message
191: * @param expected The expected XML document
192: * @param actual The actual XML Document
193: */
194: public final void assertEqual(String msg, Document expected,
195: Document actual) {
196: expected.getDocumentElement().normalize();
197: actual.getDocumentElement().normalize();
198:
199: Diff diff = compareXML(expected, actual);
200:
201: if (!diff.similar()) {
202: try {
203: System.out.println("expected:");
204: print(expected);
205: System.out.println("actual:");
206: print(actual);
207: } catch (Exception e) {
208: e.printStackTrace();
209: }
210: }
211:
212: assertEquals(msg + ", " + diff.toString(), true, diff.similar());
213: }
214:
215: /**
216: * Assert that the result of an XML comparison is similar.
217: *
218: * @param msg The assertion message
219: * @param expected The expected XML document
220: * @param actual The actual XML Document
221: */
222: public final void assertEqual(Document expected, Document actual) {
223: expected.getDocumentElement().normalize();
224: actual.getDocumentElement().normalize();
225:
226: Diff diff = compareXML(expected, actual);
227:
228: if (!diff.similar()) {
229: try {
230: System.out.println("expected:");
231: print(expected);
232: System.out.println("actual:");
233: print(actual);
234: } catch (Exception e) {
235: e.printStackTrace();
236: }
237: }
238:
239: assertEquals("Test if the assertion document is equal, "
240: + diff.toString(), true, diff.similar());
241: }
242:
243: public static Test suite() {
244: TestSuite suite = new TestSuite("LexicalProcessorTest");
245:
246: try {
247: File directory = new File(LexicalProcessorTestCase.class
248: .getResource("lexer").getFile());
249: File[] files = directory.listFiles();
250:
251: for (int i = 0; i < files.length; i++)
252: if ((files[i].getName().endsWith(".xml")) /* && (files[i].getName().startsWith("recursion"))*/) {
253: Document test = getDocument(files[i].toString(),
254: new FileInputStream(files[i]));
255:
256: NodeList list = test.getDocumentElement()
257: .getElementsByTagName("step");
258: for (int j = 0; j < list.getLength(); j++) {
259: Element step = (Element) list.item(j);
260:
261: suite.addTest(new LexicalProcessorTestCase(
262: "LexicalProcessorTest "
263: + files[i].getName() + ":"
264: + step.getAttribute("name"),
265: step));
266: }
267: }
268: } catch (Exception e) {
269: e.printStackTrace();
270: }
271:
272: return suite;
273: }
274: }
|