commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From simonetrip...@apache.org
Subject svn commit: r1067611 - /commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
Date Sun, 06 Feb 2011 07:47:21 GMT
Author: simonetripodi
Date: Sun Feb  6 07:47:21 2011
New Revision: 1067611

URL: http://svn.apache.org/viewvc?rev=1067611&view=rev
Log:
first checkin of DigesterTestCase, an adapted version of the proper on /trunk
old testcases continue pass!

Added:
    commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
  (with props)

Added: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
URL: http://svn.apache.org/viewvc/commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java?rev=1067611&view=auto
==============================================================================
--- commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
(added)
+++ commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
Sun Feb  6 07:47:21 2011
@@ -0,0 +1,408 @@
+/* $Id$
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.digester3;
+
+import static org.apache.commons.digester3.DigesterLoader.newLoader;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.Reader;
+import java.io.StringReader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.util.EmptyStackException;
+import java.util.Map;
+
+import org.apache.commons.digester3.spi.Substitutor;
+import org.junit.Test;
+import org.xml.sax.Attributes;
+import org.xml.sax.InputSource;
+import org.xml.sax.helpers.AttributesImpl;
+
+/**
+ * <p>Test Case for the Digester class.  These tests exercise the individual
+ * methods of a Digester, but do not attempt to process complete documents.
+ * </p>
+ *
+ * @author Craig R. McClanahan
+ * @version $Revision$ $Date$
+ */
+public class DigesterTestCase extends AbstractTestCase {
+
+    /**
+     * The set of public identifiers, and corresponding resource names,
+     * for the versions of the DTDs that we know about.  There
+     * <strong>MUST</strong> be an even number of Strings in this array.
+     */
+    protected static final String registrations[] = {
+        "-//Netscape Communications//DTD RSS 0.9//EN",
+        "/org/apache/commons/digester/rss/rss-0.9.dtd",
+        "-//Netscape Communications//DTD RSS 0.91//EN",
+        "/org/apache/commons/digester/rss/rss-0.91.dtd",
+    };
+
+    private DigesterLoader newEmptyLoader() {
+        return newLoader(new AbstractRulesModule() {
+
+            @Override
+            protected void configure() {
+                // do nothing
+            }
+
+        });
+    }
+
+    private Digester newEmptyDigester() {
+        return newEmptyLoader().newDigester();
+    }
+
+    /**
+     * Test <code>null</code> parsing.
+     * (should lead to <code>IllegalArgumentException</code>s)
+     */
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullFileParse() throws Exception {
+        newEmptyDigester().parse((File) null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullInputSourceParse() throws Exception {
+        newEmptyDigester().parse((InputSource) null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullInputStreamParse() throws Exception {
+        newEmptyDigester().parse((InputStream) null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullReaderParse() throws Exception {
+        newEmptyDigester().parse((Reader) null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullStringParse() throws Exception {
+        newEmptyDigester().parse((String) null);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testNullURLParse() throws Exception {
+        newEmptyDigester().parse((URL) null);
+    }
+
+    /**
+     * Test the basic property getters and setters.
+     */
+    @Test
+    public void testProperties() {
+        DigesterLoader loader = newEmptyLoader();
+
+        assertTrue("Initial namespace aware is false", !loader.isNamespaceAware());
+        loader.setNamespaceAware(true);
+        assertTrue("Set namespace aware is true", loader.isNamespaceAware());
+        loader.setNamespaceAware(false);
+        assertTrue("Reset namespace aware is false", !loader.isNamespaceAware());
+
+        assertTrue("Initial validating is false", !loader.isValidating());
+        loader.setValidating(true);
+        assertTrue("Set validating is true", loader.isValidating());
+        loader.setValidating(false);
+        assertTrue("Reset validating is false", !loader.isValidating());
+
+        Digester digester = loader.newDigester();
+
+        assertNotNull("Initial error handler is null", digester.getErrorHandler());
+        assertTrue("Set error handler is digester", digester.getErrorHandler() == digester);
+        digester.setErrorHandler(null);
+        assertNull("Reset error handler is null", digester.getErrorHandler());
+    }
+
+    /**
+     * Test registration of URLs for specified public identifiers.
+     */
+    @Test
+    public void testRegistrations() {
+        DigesterLoader loader = newEmptyLoader();
+
+        Map<String, URL> map = loader.getRegistrations();
+        assertEquals("Initially zero registrations", 0, map.size());
+        int n = 0;
+        for (int i = 0; i < registrations.length; i += 2) {
+            URL url = this.getClass().getResource(registrations[i + 1]);
+            if (url != null) {
+                loader.register(registrations[i], url);
+                n++;
+            }
+        }
+        map = loader.getRegistrations();
+        assertEquals("Registered two URLs", n, map.size());
+
+        int count[] = new int[n];
+        for (int i = 0; i < n; i++)
+            count[i] = 0;
+        for (String key : map.keySet()) {
+            for (int i = 0; i < n; i++) {
+                if (key.equals(registrations[i * 2])) {
+                    count[i]++;
+                    break;
+                }
+            }
+        }
+        for (int i = 0; i < n; i++)
+            assertEquals("Count for key " + registrations[i * 2], 1, count[i]);
+    }
+
+    /**
+     * Test the basic stack mechanisms.
+     */
+    @Test
+    public void testStackMethods() {
+        Digester digester = newEmptyDigester();
+
+        Object value = null;
+
+        // New stack must be empty
+        assertEquals("New stack is empty", 0, digester.getCount());
+        value = digester.peek();
+        assertNull("New stack peek() returns null", value);
+        value = digester.pop();
+        assertNull("New stack pop() returns null", value);
+
+        // Test pushing and popping activities
+        digester.push("First Item");
+        assertEquals("Pushed one item size", 1, digester.getCount());
+        value = digester.peek();
+        assertNotNull("Peeked first item is not null", value);
+        assertEquals("Peeked first item value", "First Item", (String) value);
+
+        digester.push("Second Item");
+        assertEquals("Pushed two items size", 2, digester.getCount());
+        value = digester.peek();
+        assertNotNull("Peeked second item is not null", value);
+        assertEquals("Peeked second item value", "Second Item", (String) value);
+
+        value = digester.pop();
+        assertEquals("Popped stack size", 1, digester.getCount());
+        assertNotNull("Popped second item is not null", value);
+        assertEquals("Popped second item value", "Second Item", (String) value);
+        value = digester.peek();
+        assertNotNull("Remaining item is not null", value);
+        assertEquals("Remaining item value", "First Item", (String) value);
+        assertEquals("Remaining stack size", 1, digester.getCount());
+
+        // Cleared stack is empty
+        digester.push("Dummy Item");
+        digester.clear();
+        assertEquals("Cleared stack is empty", 0, digester.getCount());
+        value = digester.peek();
+        assertNull("Cleared stack peek() returns null", value);
+        value = digester.pop();
+        assertNull("Cleared stack pop() returns null", value);
+    }
+
+    @Test
+    public void testBasicSubstitution() throws Exception {
+        class TestSubRule extends Rule {
+
+            public String body;
+
+            public Attributes attributes;
+
+            @Override
+            public void begin(String namespace, String name, Attributes attributes) {
+                this.attributes = new AttributesImpl(attributes);
+            }
+
+            @Override
+            public void body(String namespace, String name, String text) {
+                this.body = text;
+            }
+        }
+
+        final TestSubRule tsr = new TestSubRule();
+        DigesterLoader loader = newLoader(new AbstractRulesModule() {
+
+            @Override
+            protected void configure() {
+                forPattern("alpha/beta").addRule(tsr);
+            }
+
+        });
+
+        Digester digester = loader.newDigester();
+
+        // it's not easy to transform dirty harry into the mighty circus - but let's give
it a try
+        String xml = "<?xml version='1.0'?><alpha><beta forname='Dirty' surname='Harry'>Do
you feel luck punk?</beta></alpha>";
+        InputSource in = new InputSource(new StringReader(xml));
+
+        digester.parse(in);
+
+        assertEquals("Unsubstituted body text", "Do you feel luck punk?", tsr.body);
+        assertEquals("Unsubstituted number of attributes", 2, tsr.attributes.getLength());
+        assertEquals("Unsubstituted forname attribute value", "Dirty", tsr.attributes.getValue("forname"));
+        assertEquals("Unsubstituted surname attribute value", "Harry", tsr.attributes.getValue("surname"));
+
+        digester = loader.setSubstitutor(new Substitutor() {
+
+            public Attributes substitute(Attributes attributes) {
+                AttributesImpl results = new AttributesImpl();
+                results.addAttribute("", "python", "python", "CDATA", "Cleese");
+                return results;
+            }
+
+            public String substitute(String bodyText) {
+                return "And now for something completely different...";
+            }
+
+        }).newDigester();
+
+        // now transform into the full monty
+        in = new InputSource(new StringReader(xml));
+        digester.parse(in);
+
+        assertEquals("Substituted body text", "And now for something completely different...",
tsr.body);
+        assertEquals("Substituted number of attributes", 1, tsr.attributes.getLength());
+        assertEquals("Substituted python attribute value", "Cleese", tsr.attributes.getValue("",
"python"));
+    }
+
+    /** Tests the push-peek-pop cycle for a named stack */
+    @Test
+    public void testNamedStackPushPeekPop() throws Exception {
+        BigDecimal archimedesAveragePi = new BigDecimal("3.1418");
+        String testStackName = "org.apache.commons.digester.tests.testNamedStackPushPeekPop";
+        Digester digester = newEmptyDigester();
+        assertTrue("Stack starts empty:", digester.isEmpty(testStackName));
+        digester.push(testStackName, archimedesAveragePi);
+        assertEquals("Peeked value:", archimedesAveragePi, digester.peek(testStackName));
+        assertEquals("Popped value:", archimedesAveragePi, digester.pop(testStackName));
+        assertTrue("Stack ends empty:", digester.isEmpty(testStackName));
+
+        digester.push(testStackName, "1");
+        digester.push(testStackName, "2");
+        digester.push(testStackName, "3");
+
+        assertEquals("Peek#1", "1", digester.peek(testStackName, 2));
+        assertEquals("Peek#2", "2", digester.peek(testStackName, 1));
+        assertEquals("Peek#3", "3", digester.peek(testStackName, 0));
+        assertEquals("Peek#3a", "3", digester.peek(testStackName));
+
+        try {
+            // peek beyond stack
+            digester.peek(testStackName, 3);
+            fail("Peek#4 failed to throw an exception.");
+        } catch(EmptyStackException ex) {
+            // ok, expected
+        }
+
+        try {
+            // peek a nonexistent named stack
+            digester.peek("no.such.stack", 0);
+            fail("Peeking a non-existent stack failed to throw an exception.");
+        } catch(EmptyStackException ex) {
+            // ok, expected
+        }
+    }
+
+    /** Tests that values are stored independently */
+    @Test
+    public void testNamedIndependence() {
+        String testStackOneName = "org.apache.commons.digester.tests.testNamedIndependenceOne";
+        String testStackTwoName = "org.apache.commons.digester.tests.testNamedIndependenceTwo";
+        Digester digester = newEmptyDigester();
+        digester.push(testStackOneName, "Tweedledum");
+        digester.push(testStackTwoName, "Tweedledee");
+        assertEquals("Popped value one:", "Tweedledum", digester.pop(testStackOneName));
+        assertEquals("Popped value two:", "Tweedledee", digester.pop(testStackTwoName));
+    }
+
+    /** Tests popping named stack not yet pushed */
+    @Test
+    public void testPopNamedStackNotPushed() {
+        String testStackName = "org.apache.commons.digester.tests.testPopNamedStackNotPushed";
+        Digester digester = newEmptyDigester();
+        try {
+            digester.pop(testStackName);
+            fail("Expected an EmptyStackException");
+        } catch (EmptyStackException e) {
+            // expected
+        }
+
+        try {
+            digester.peek(testStackName);
+            fail("Expected an EmptyStackException");
+        } catch (EmptyStackException e) {
+            // expected
+        }
+    }
+
+    /** Tests for isEmpty */
+    @Test
+    public void testNamedStackIsEmpty() {
+        String testStackName = "org.apache.commons.digester.tests.testNamedStackIsEmpty";
+        Digester digester = newEmptyDigester();
+        assertTrue(
+            "A named stack that has no object pushed onto it yet should be empty", 
+            digester.isEmpty(testStackName));
+
+        digester.push(testStackName, "Some test value");
+        assertFalse(
+            "A named stack that has an object pushed onto it should be not empty",
+            digester.isEmpty(testStackName));
+
+        digester.peek(testStackName);
+        assertFalse(
+            "Peek should not effect whether the stack is empty",
+            digester.isEmpty(testStackName));
+
+        digester.pop(testStackName);
+        assertTrue(
+            "A named stack that has it's last object popped is empty", 
+            digester.isEmpty(testStackName));
+    }
+
+    /**
+     * Test the Digester.getRoot method.
+     */
+    @Test
+    public void testGetRoot() throws Exception {
+        Digester digester = newBasicDigester(new AbstractRulesModule() {
+
+            @Override
+            protected void configure() {
+                forPattern("root").createObject().ofType(SimpleTestBean.class);
+            }
+
+        });
+
+        String xml = "<root/>";
+        InputSource in = new InputSource(new StringReader(xml));
+
+        digester.parse(in);
+
+        Object root = digester.getRoot();
+        assertNotNull("root object not retrieved", root);
+        assertTrue("root object not a TestRule instance", (root instanceof SimpleTestBean));
+    }
+
+}

Propchange: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL

Propchange: commons/sandbox/digester3/trunk/src/test/java/org/apache/commons/digester3/DigesterTestCase.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message