From 970c6cd2779e6f7299cdedc0aaac7049442b9d76 Mon Sep 17 00:00:00 2001 From: Rolf Date: Tue, 31 Jan 2012 07:32:36 -0500 Subject: [PATCH] Add CloneBase to simplify clone() method calls which in turn cleans up the coverage reports. Fix some JavaDoc issues and lots of small coverage improvements --- .../java/org/jdom2/contrib/perf/PerfDoc.java | 6 +- core/src/java/org/jdom2/Attribute.java | 13 +-- core/src/java/org/jdom2/CloneBase.java | 31 ++++++ core/src/java/org/jdom2/Content.java | 15 +-- core/src/java/org/jdom2/Document.java | 10 +- .../java/org/jdom2/ProcessingInstruction.java | 4 +- core/src/java/org/jdom2/SlimJDOMFactory.java | 6 + .../org/jdom2/filter/PassThroughFilter.java | 2 +- .../java/org/jdom2/input/sax/SAXHandler.java | 3 +- .../org/jdom2/TestJDOMRuntimeExceptn.java | 31 ++++++ .../org/jdom2/test/cases/TestElement.java | 2 +- .../jdom2/test/cases/TestSlimJDOMFactory.java | 28 ++++- .../test/cases/TestSlimJDOMFactoryNoText.java | 40 +++++++ .../test/cases/filter/AbstractTestFilter.java | 14 +++ .../jdom2/test/cases/filter/TestFilters.java | 6 + .../cases/filter/TestPassThroughFilter.java | 104 ++++++++++++++++++ .../test/cases/input/TestSAXBuilder.java | 38 ++++++- .../input/sax/TestXMLReaderSchemaFactory.java | 11 ++ .../cases/util/TestReflectionConstructor.java | 52 +++++++++ 19 files changed, 377 insertions(+), 39 deletions(-) create mode 100644 core/src/java/org/jdom2/CloneBase.java create mode 100644 test/src/java/org/jdom2/TestJDOMRuntimeExceptn.java create mode 100644 test/src/java/org/jdom2/test/cases/TestSlimJDOMFactoryNoText.java create mode 100644 test/src/java/org/jdom2/test/cases/filter/TestPassThroughFilter.java create mode 100644 test/src/java/org/jdom2/test/cases/util/TestReflectionConstructor.java diff --git a/contrib/src/java/org/jdom2/contrib/perf/PerfDoc.java b/contrib/src/java/org/jdom2/contrib/perf/PerfDoc.java index 998005636..40f20c098 100644 --- a/contrib/src/java/org/jdom2/contrib/perf/PerfDoc.java +++ b/contrib/src/java/org/jdom2/contrib/perf/PerfDoc.java @@ -33,7 +33,6 @@ import org.jdom2.EntityRef; import org.jdom2.Namespace; import org.jdom2.ProcessingInstruction; -import org.jdom2.SlimJDOMFactory; import org.jdom2.Text; import org.jdom2.UncheckedJDOMFactory; import org.jdom2.filter.ElementFilter; @@ -197,7 +196,7 @@ public File getFile() { public long saxLoad() throws Exception { final long startmem = PerfTest.usedMem(); - saxTime = PerfTest.timeRun(new SAXLoadRunnable(0) ); + saxTime = PerfTest.timeRun(new SAXLoadRunnable(12) ); loadMem = PerfTest.usedMem() - startmem; saxDTime = PerfTest.timeRun(new SAXLoadRunnable(8) ); return saxTime; @@ -278,7 +277,8 @@ public Document subload(int type) throws Exception { return null; case 12: SAXBuilder slimsax = new SAXBuilder(); - slimsax.setJDOMFactory(new SlimJDOMFactory()); + //slimsax.setJDOMFactory(new SlimJDOMFactory()); + //slimsax.setFeature("http://xml.org/sax/features/string-interning", true); return slimsax.build(car); } return null; diff --git a/core/src/java/org/jdom2/Attribute.java b/core/src/java/org/jdom2/Attribute.java index 72a7e9f17..15cd5a632 100644 --- a/core/src/java/org/jdom2/Attribute.java +++ b/core/src/java/org/jdom2/Attribute.java @@ -74,7 +74,8 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * @author Victor Toni * @author Rolf Lear */ -public class Attribute implements NamespaceAware, Serializable, Cloneable { +public class Attribute extends CloneBase + implements NamespaceAware, Serializable, Cloneable { // Keep the old constant names for one beta cycle to help migration @@ -552,13 +553,9 @@ public String toString() { @Override public Attribute clone() { - try { - Attribute clone = (Attribute) super.clone(); - clone.parent = null; - return clone; - } catch (CloneNotSupportedException e) { - throw new IllegalStateException("Clone not supported!", e); - } + final Attribute clone = (Attribute) super.clone(); + clone.parent = null; + return clone; } /** diff --git a/core/src/java/org/jdom2/CloneBase.java b/core/src/java/org/jdom2/CloneBase.java new file mode 100644 index 000000000..0a1fa7d90 --- /dev/null +++ b/core/src/java/org/jdom2/CloneBase.java @@ -0,0 +1,31 @@ +package org.jdom2; + +/** + * This simple class just tidies up any cloneable classes. + * This method deals with any CloneNotSupported exceptions. + * THis class is package private only. + * @author Rolf Lear + * + */ +class CloneBase implements Cloneable { + + /** + * This convenience method simply deals with the irritating + * CloneNotSupportedException, and wraps it in IllegalStateException. + * This should never, ever, ever happen. But, it is a pain to deal with + * ugly clone code in some classes. + * Subclasses of this should still call super.clone() in their clone method. + */ + @Override + protected Object clone() { + try { + return super.clone(); + } catch (CloneNotSupportedException e) { + throw new IllegalStateException(String.format( + "Unable to clone class %s which should always support it.", + this.getClass().getName()), + e); + } + } + +} diff --git a/core/src/java/org/jdom2/Content.java b/core/src/java/org/jdom2/Content.java index 814d6cf90..5262dede5 100644 --- a/core/src/java/org/jdom2/Content.java +++ b/core/src/java/org/jdom2/Content.java @@ -73,7 +73,8 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * @author Bradley S. Huffman * @author Jason Hunter */ -public abstract class Content implements Cloneable, Serializable, NamespaceAware { +public abstract class Content extends CloneBase + implements Cloneable, Serializable, NamespaceAware { /** * An enumeration useful for identifying content types without @@ -237,15 +238,9 @@ public Document getDocument() { */ @Override public Content clone() { - try { - Content c = (Content)super.clone(); - c.parent = null; - return c; - } catch (CloneNotSupportedException e) { - //Can not happen .... - //e.printStackTrace(); - return null; - } + Content c = (Content)super.clone(); + c.parent = null; + return c; } /** diff --git a/core/src/java/org/jdom2/Document.java b/core/src/java/org/jdom2/Document.java index 354106925..9c343e6c5 100644 --- a/core/src/java/org/jdom2/Document.java +++ b/core/src/java/org/jdom2/Document.java @@ -67,7 +67,7 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * @author Jools Enticknap * @author Bradley S. Huffman */ -public class Document implements Parent { +public class Document extends CloneBase implements Parent { /** * This document's content including comments, PIs, a possible @@ -672,13 +672,7 @@ public final int hashCode() { */ @Override public Document clone() { - Document doc = null; - - try { - doc = (Document) super.clone(); - } catch (CloneNotSupportedException ce) { - // Can't happen - } + final Document doc = (Document) super.clone(); // The clone has a reference to this object's content list, so // owerwrite with a empty list diff --git a/core/src/java/org/jdom2/ProcessingInstruction.java b/core/src/java/org/jdom2/ProcessingInstruction.java index d83a7aa16..a1eae57bd 100644 --- a/core/src/java/org/jdom2/ProcessingInstruction.java +++ b/core/src/java/org/jdom2/ProcessingInstruction.java @@ -469,9 +469,7 @@ public ProcessingInstruction clone() { // Object.clone() // Create a new Map object for the clone (since Map isn't Cloneable) - if (mapData != null) { - pi.mapData = parseData(rawData); - } + pi.mapData = parseData(rawData); return pi; } diff --git a/core/src/java/org/jdom2/SlimJDOMFactory.java b/core/src/java/org/jdom2/SlimJDOMFactory.java index 6a89e6559..3ce7949cf 100644 --- a/core/src/java/org/jdom2/SlimJDOMFactory.java +++ b/core/src/java/org/jdom2/SlimJDOMFactory.java @@ -92,6 +92,12 @@ public SlimJDOMFactory(boolean cachetext) { } + /** + * Reset any Cached String instance data from this SlimJDOMFaxctory cache. + */ + public void clearCache() { + cache = new StringBin(); + } @Override public Attribute attribute(String name, String value, Namespace namespace) { diff --git a/core/src/java/org/jdom2/filter/PassThroughFilter.java b/core/src/java/org/jdom2/filter/PassThroughFilter.java index d2b25a6c1..8af419f11 100644 --- a/core/src/java/org/jdom2/filter/PassThroughFilter.java +++ b/core/src/java/org/jdom2/filter/PassThroughFilter.java @@ -79,7 +79,7 @@ public List filter(List content) { for (Iterator it = content.iterator(); it.hasNext(); ) { ret.add(it.next()); } - return Collections.unmodifiableList(content); + return Collections.unmodifiableList(ret); } } diff --git a/core/src/java/org/jdom2/input/sax/SAXHandler.java b/core/src/java/org/jdom2/input/sax/SAXHandler.java index f180ece69..181631b37 100644 --- a/core/src/java/org/jdom2/input/sax/SAXHandler.java +++ b/core/src/java/org/jdom2/input/sax/SAXHandler.java @@ -212,6 +212,7 @@ public final void reset() { externalEntities.clear(); ignoringWhite = false; ignoringBoundaryWhite = false; + resetSubCLass(); } /** @@ -295,7 +296,7 @@ public void setIgnoringElementContentWhitespace(boolean ignoringWhite) { } /** - * Specifies whether or not the parser should elminate text() nodes + * Specifies whether or not the parser should eliminate text() nodes * containing only whitespace when building the document. See * {@link SAXBuilder#setIgnoringBoundaryWhitespace(boolean)}. * diff --git a/test/src/java/org/jdom2/TestJDOMRuntimeExceptn.java b/test/src/java/org/jdom2/TestJDOMRuntimeExceptn.java new file mode 100644 index 000000000..e8a436613 --- /dev/null +++ b/test/src/java/org/jdom2/TestJDOMRuntimeExceptn.java @@ -0,0 +1,31 @@ +package org.jdom2; + +import static org.junit.Assert.*; + +import org.junit.Test; + +@SuppressWarnings("javadoc") +public class TestJDOMRuntimeExceptn { + + @Test + public void testJDOMRuntimeException() { + assertTrue (null != new JDOMRuntimeException().getMessage()); + assertEquals (null, new JDOMRuntimeException().getCause()); + + } + + @Test + public void testJDOMRuntimeExceptionString() { + assertEquals ("reason", new JDOMRuntimeException("reason").getMessage()); + + } + + @Test + public void testJDOMRuntimeExceptionStringExn() { + Throwable t = new Throwable(); + Exception e = new JDOMRuntimeException("reason", t); + assertTrue (t == e.getCause()); + assertEquals("reason", e.getMessage()); + } + +} diff --git a/test/src/java/org/jdom2/test/cases/TestElement.java b/test/src/java/org/jdom2/test/cases/TestElement.java index c51e2246c..fc0f1402c 100644 --- a/test/src/java/org/jdom2/test/cases/TestElement.java +++ b/test/src/java/org/jdom2/test/cases/TestElement.java @@ -2111,7 +2111,7 @@ public void testGetNamespace() { assertTrue(emt.getNamespace(null) == null); assertTrue(emt.getNamespace("none") == null); assertTrue(emt.getNamespace("xml") == Namespace.XML_NAMESPACE); - assertTrue(emt.getNamespace("nsa") == nsa); + assertTrue(emt.getNamespace("tstada") == nsa); } @Test diff --git a/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactory.java b/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactory.java index 39c778677..c760df0be 100644 --- a/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactory.java +++ b/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactory.java @@ -1,7 +1,11 @@ package org.jdom2.test.cases; +import static org.junit.Assert.*; +import org.junit.Test; + import org.jdom2.JDOMFactory; import org.jdom2.SlimJDOMFactory; +import org.jdom2.Text; @SuppressWarnings("javadoc") public class TestSlimJDOMFactory extends AbstractTestJDOMFactory { @@ -10,5 +14,27 @@ public class TestSlimJDOMFactory extends AbstractTestJDOMFactory { protected JDOMFactory buildFactory() { return new SlimJDOMFactory(); } - + + @Test + public void testCaching() { + SlimJDOMFactory fac = new SlimJDOMFactory(); + Text ta = fac.text("hi"); + String hi = ta.getText(); + // we expect the StringBin to compact a string value... should no longer + // be the intern value. + assertTrue("hi" != hi); + assertTrue("hi" == hi.intern()); + + Text tb = fac.text("hi"); + assertTrue("hi" != tb.getText()); + assertTrue(hi == tb.getText()); + + fac.clearCache(); + + Text tc = fac.text("hi"); + assertTrue("hi" != tc.getText()); + assertTrue(hi != tc.getText()); + + assertTrue(hi.equals(tc.getText())); + } } diff --git a/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactoryNoText.java b/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactoryNoText.java new file mode 100644 index 000000000..76aacb92d --- /dev/null +++ b/test/src/java/org/jdom2/test/cases/TestSlimJDOMFactoryNoText.java @@ -0,0 +1,40 @@ +package org.jdom2.test.cases; + +import static org.junit.Assert.*; +import org.junit.Test; + +import org.jdom2.JDOMFactory; +import org.jdom2.SlimJDOMFactory; +import org.jdom2.Text; + +@SuppressWarnings("javadoc") +public class TestSlimJDOMFactoryNoText extends AbstractTestJDOMFactory { + + @Override + protected JDOMFactory buildFactory() { + return new SlimJDOMFactory(false); + } + + @Test + public void testCaching() { + SlimJDOMFactory fac = new SlimJDOMFactory(false); + Text ta = fac.text("hi"); + String hi = ta.getText(); + // we expect the StringBin to compact a string value... should no longer + // be the intern value. + assertTrue("hi" == hi); + assertTrue("hi" == hi.intern()); + + Text tb = fac.text("hi"); + assertTrue("hi" == tb.getText()); + assertTrue(hi == tb.getText()); + + fac.clearCache(); + + Text tc = fac.text("hi"); + assertTrue("hi" == tc.getText()); + assertTrue(hi == tc.getText()); + + assertTrue(hi.equals(tc.getText())); + } +} diff --git a/test/src/java/org/jdom2/test/cases/filter/AbstractTestFilter.java b/test/src/java/org/jdom2/test/cases/filter/AbstractTestFilter.java index 64f535bf8..7be563c0b 100644 --- a/test/src/java/org/jdom2/test/cases/filter/AbstractTestFilter.java +++ b/test/src/java/org/jdom2/test/cases/filter/AbstractTestFilter.java @@ -7,7 +7,9 @@ import java.util.ArrayList; import java.util.Iterator; +import java.util.LinkedList; import java.util.List; +import java.util.RandomAccess; import org.jdom2.Attribute; import org.jdom2.CDATA; @@ -294,8 +296,11 @@ protected void exercise(Filter af, Parent parent, CallBac private final void exerciseCore(Filter ef, Parent parent, CallBack callback) { // exercise the toString() assertTrue(ef.toString() != null); + LinkedList oc = new LinkedList(); + ArrayList mc = new ArrayList(); List cont = parent.getContent(); for (Content c : cont) { + oc.add(c); assertTrue(parent == c.getParent()); if (parent instanceof Document) { assertTrue(null == c.getParentElement()); @@ -303,6 +308,9 @@ private final void exerciseCore(Filter ef, Parent parent, Cal assertTrue(parent == c.getParentElement()); } boolean mat = ef.matches(c); + if (mat) { + mc.add(c); + } boolean cbv = callback.isValid(c); if (mat != cbv) { fail ("Filter " + ef + " returned " + mat @@ -310,6 +318,12 @@ private final void exerciseCore(Filter ef, Parent parent, Cal + " for value " + c); } } + List fc = ef.filter(oc); + assertTrue(fc instanceof RandomAccess); + assertTrue(fc.size() == mc.size()); + for (int i = 0; i < fc.size(); i++) { + assertTrue(fc.get(i) == mc.get(i)); + } Filter cf = UnitTestUtil.deSerialize(ef); assertFilterEquals(cf, ef); ContentFilter xf = new ContentFilter(); diff --git a/test/src/java/org/jdom2/test/cases/filter/TestFilters.java b/test/src/java/org/jdom2/test/cases/filter/TestFilters.java index ba757e1eb..6286d98ed 100644 --- a/test/src/java/org/jdom2/test/cases/filter/TestFilters.java +++ b/test/src/java/org/jdom2/test/cases/filter/TestFilters.java @@ -9,6 +9,7 @@ import org.jdom2.CDATA; import org.jdom2.Comment; import org.jdom2.DocType; +import org.jdom2.Document; import org.jdom2.Element; import org.jdom2.EntityRef; import org.jdom2.Namespace; @@ -50,6 +51,11 @@ public void testContent() { checkFilter(Filters.content(), new Element("tag"), null); } + @Test + public void testDocument() { + checkFilter(Filters.document(), new Document(), new Object()); + } + @Test public void testAttribute() { checkFilter(Filters.attribute(), new Attribute("tag", "val"), new Object()); diff --git a/test/src/java/org/jdom2/test/cases/filter/TestPassThroughFilter.java b/test/src/java/org/jdom2/test/cases/filter/TestPassThroughFilter.java new file mode 100644 index 000000000..f6dcb0c00 --- /dev/null +++ b/test/src/java/org/jdom2/test/cases/filter/TestPassThroughFilter.java @@ -0,0 +1,104 @@ +package org.jdom2.test.cases.filter; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.RandomAccess; + +import org.jdom2.filter.Filter; +import org.jdom2.filter.Filters; +import org.jdom2.test.util.UnitTestUtil; + +import org.junit.Test; + +@SuppressWarnings("javadoc") +public class TestPassThroughFilter { + + @Test + public void testPassThroughFilterRandom() { + Filter ef = Filters.fpassthrough(); + + List lst = new ArrayList(3); + lst.add("hello"); + lst.add("there"); + lst.add("world"); + List filtered = ef.filter(lst); + assertTrue(filtered instanceof RandomAccess); + assertTrue(filtered.size() == 3); + assertEquals("hello", filtered.get(0)); + assertEquals("there", filtered.get(1)); + assertEquals("world", filtered.get(2)); + + try { + filtered.add("boo"); + UnitTestUtil.failNoException(UnsupportedOperationException.class); + } catch (Exception e) { + UnitTestUtil.checkException(UnsupportedOperationException.class, e); + } + + } + + + @Test + public void testPassThroughFilterLinked() { + Filter ef = Filters.fpassthrough(); + + List lst = new LinkedList(); + lst.add("hello"); + lst.add("there"); + lst.add("world"); + List filtered = ef.filter(lst); + assertTrue(filtered instanceof RandomAccess); + assertTrue(filtered.size() == 3); + assertEquals("hello", filtered.get(0)); + assertEquals("there", filtered.get(1)); + assertEquals("world", filtered.get(2)); + + try { + filtered.add("boo"); + UnitTestUtil.failNoException(UnsupportedOperationException.class); + } catch (Exception e) { + UnitTestUtil.checkException(UnsupportedOperationException.class, e); + } + + } + + + @Test + public void testPassThroughFilterNull() { + Filter ef = Filters.fpassthrough(); + + List lst = null; + List filtered = ef.filter(lst); + assertTrue(filtered instanceof RandomAccess); + assertTrue(filtered.size() == 0); + + try { + filtered.add("boo"); + UnitTestUtil.failNoException(UnsupportedOperationException.class); + } catch (Exception e) { + UnitTestUtil.checkException(UnsupportedOperationException.class, e); + } + + } + + @Test + public void testPassThroughFilterEmpty() { + Filter ef = Filters.fpassthrough(); + + List lst = new LinkedList(); + List filtered = ef.filter(lst); + assertTrue(filtered instanceof RandomAccess); + assertTrue(filtered.size() == 0); + + try { + filtered.add("boo"); + UnitTestUtil.failNoException(UnsupportedOperationException.class); + } catch (Exception e) { + UnitTestUtil.checkException(UnsupportedOperationException.class, e); + } + + } +} diff --git a/test/src/java/org/jdom2/test/cases/input/TestSAXBuilder.java b/test/src/java/org/jdom2/test/cases/input/TestSAXBuilder.java index 3fa18b66c..b95ba796f 100644 --- a/test/src/java/org/jdom2/test/cases/input/TestSAXBuilder.java +++ b/test/src/java/org/jdom2/test/cases/input/TestSAXBuilder.java @@ -103,10 +103,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT import org.jdom2.UncheckedJDOMFactory; import org.jdom2.input.SAXBuilder; import org.jdom2.input.sax.BuilderErrorHandler; +import org.jdom2.input.sax.SAXEngine; import org.jdom2.input.sax.SAXHandler; import org.jdom2.input.sax.SAXHandlerFactory; import org.jdom2.input.sax.XMLReaderJDOMFactory; import org.jdom2.input.sax.XMLReaderSAX2Factory; +import org.jdom2.input.sax.XMLReaders; import org.jdom2.output.Format; import org.jdom2.output.XMLOutputter; @@ -438,6 +440,17 @@ public void unparsedEntityDecl(String arg0, String arg1, sb.setDTDHandler(dtd); assertTrue(dtd == sb.getDTDHandler()); } + + @Test + public void testGetSetXMLReaderFactory() { + SAXBuilder sb = new SAXBuilder(); + XMLReaderJDOMFactory xrjf = sb.getXMLReaderFactory(); + assertTrue(xrjf == XMLReaders.NONVALIDATING); + sb.setXMLReaderFactory(XMLReaders.XSDVALIDATING); + assertTrue(sb.getXMLReaderFactory() == XMLReaders.XSDVALIDATING); + sb.setXMLReaderFactory(null); + assertTrue(xrjf == XMLReaders.NONVALIDATING); + } @Test public void testXMLFilter() { @@ -489,7 +502,7 @@ public void endElement(String arg0, String arg1, String arg2) throws SAXExceptio @SuppressWarnings("deprecation") @Test - public void testGetIgnoringElementContentWhitespace() { + public void testGetIgnoringElementContentWhitespace() throws JDOMException { SAXBuilder sb = new SAXBuilder(true); assertNull(sb.getDriverClass()); assertTrue(sb.getEntityResolver() == null); @@ -498,18 +511,27 @@ public void testGetIgnoringElementContentWhitespace() { assertTrue(sb.getXMLFilter() == null); assertTrue(sb.isValidating()); assertTrue(sb.isExpandEntities()); + + SAXEngine se = sb.buildEngine(); + assertFalse(se.isIgnoringBoundaryWhitespace()); + sb.setIgnoringElementContentWhitespace(true); assertTrue(sb.getIgnoringElementContentWhitespace()); assertTrue(sb.isIgnoringElementContentWhitespace()); + se = sb.buildEngine(); + assertTrue(se.isIgnoringElementContentWhitespace()); sb.setIgnoringElementContentWhitespace(false); assertFalse(sb.getIgnoringElementContentWhitespace()); assertFalse(sb.isIgnoringElementContentWhitespace()); + se = sb.buildEngine(); + assertFalse(se.isIgnoringElementContentWhitespace()); } @SuppressWarnings("deprecation") @Test - public void testGetIgnoringBoundaryWhitespace() { + public void testGetIgnoringBoundaryWhitespace() throws JDOMException { SAXBuilder sb = new SAXBuilder(true); + SAXEngine se = sb.buildEngine(); assertNull(sb.getDriverClass()); assertTrue(sb.getEntityResolver() == null); assertTrue(sb.getErrorHandler() == null); @@ -517,12 +539,22 @@ public void testGetIgnoringBoundaryWhitespace() { assertTrue(sb.getXMLFilter() == null); assertTrue(sb.isValidating()); assertTrue(sb.isExpandEntities()); + assertTrue(se.getEntityResolver() == null); + assertTrue(se.getErrorHandler() != null); + assertTrue(se.getDTDHandler() != null); + assertTrue(se.isValidating()); + assertTrue(se.isExpandEntities()); sb.setIgnoringBoundaryWhitespace(true); assertTrue(sb.getIgnoringBoundaryWhitespace()); assertTrue(sb.isIgnoringBoundaryWhitespace()); + se = sb.buildEngine(); + assertTrue(se.isIgnoringBoundaryWhitespace()); sb.setIgnoringBoundaryWhitespace(false); assertFalse(sb.getIgnoringBoundaryWhitespace()); - assertFalse(sb.isIgnoringBoundaryWhitespace()); + assertFalse(sb.isIgnoringBoundaryWhitespace()); + + se = sb.buildEngine(); + assertFalse(se.isIgnoringBoundaryWhitespace()); } @SuppressWarnings("deprecation") diff --git a/test/src/java/org/jdom2/test/cases/input/sax/TestXMLReaderSchemaFactory.java b/test/src/java/org/jdom2/test/cases/input/sax/TestXMLReaderSchemaFactory.java index 6f0ea6644..7ca165092 100644 --- a/test/src/java/org/jdom2/test/cases/input/sax/TestXMLReaderSchemaFactory.java +++ b/test/src/java/org/jdom2/test/cases/input/sax/TestXMLReaderSchemaFactory.java @@ -18,6 +18,7 @@ import org.jdom2.Namespace; import org.jdom2.input.SAXBuilder; import org.jdom2.input.sax.XMLReaderSchemaFactory; +import org.jdom2.test.util.UnitTestUtil; @SuppressWarnings("javadoc") public class TestXMLReaderSchemaFactory { @@ -32,6 +33,16 @@ public void testSchemaXMLReaderFactory() throws SAXException, JDOMException { assertNotNull(readerfac.createXMLReader()); } + @Test + public void testSchemaXMLReaderFactoryNull() { + try { + new XMLReaderSchemaFactory(null); + UnitTestUtil.failNoException(NullPointerException.class); + } catch (Exception e) { + UnitTestUtil.checkException(NullPointerException.class, e); + } + } + @Test public void testParseValidateWorks() throws JDOMException, IOException, SAXException { SchemaFactory schemafac = diff --git a/test/src/java/org/jdom2/test/cases/util/TestReflectionConstructor.java b/test/src/java/org/jdom2/test/cases/util/TestReflectionConstructor.java new file mode 100644 index 000000000..101997f69 --- /dev/null +++ b/test/src/java/org/jdom2/test/cases/util/TestReflectionConstructor.java @@ -0,0 +1,52 @@ +package org.jdom2.test.cases.util; + +import static org.junit.Assert.*; +import static org.jdom2.test.util.UnitTestUtil.*; + +import java.util.List; + +import org.junit.Test; + +import org.jdom2.JDOMRuntimeException; +import org.jdom2.Namespace; +import org.jdom2.util.ReflectionConstructor; + +@SuppressWarnings("javadoc") +public class TestReflectionConstructor { + + @Test + public void testConstruct() { + List al = ReflectionConstructor.construct("java.util.ArrayList", List.class); + assertTrue(al.isEmpty()); + } + + @Test + public void testConstructNoSuchClass() { + try { + ReflectionConstructor.construct("java.util.Junk", List.class); + failNoException(JDOMRuntimeException.class); + } catch (Exception e) { + checkException(JDOMRuntimeException.class, e); + } + } + + @Test + public void testConstructDefaultConstructor() { + try { + ReflectionConstructor.construct("java.util.Integer", Integer.class); + failNoException(JDOMRuntimeException.class); + } catch (Exception e) { + checkException(JDOMRuntimeException.class, e); + } + } + + @Test + public void testConstructNoaccessConstructor() { + try { + ReflectionConstructor.construct("org.jdom2.Namespace", Namespace.class); + failNoException(JDOMRuntimeException.class); + } catch (Exception e) { + checkException(JDOMRuntimeException.class, e); + } + } +}