/* $Id: RuleTestCase.java 1212599 2011-12-09 19:46:42Z simonetripodi $
*
* 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.junit.Assert.assertEquals;
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.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import org.apache.commons.digester3.Digester;
import org.apache.commons.digester3.ExtendedBaseRules;
import org.apache.commons.digester3.RuleSet;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.xml.sax.SAXException;
/**
* <p>
* Test Case for the Digester class. These tests perform parsing of XML documents to exercise the built-in rules.
* </p>
*
* @author Craig R. McClanahan
* @author Janek Bogucki
*/
public class RuleTestCase
{
// ----------------------------------------------------- Instance Variables
/**
* The digester instance we will be processing.
*/
protected Digester digester = null;
// --------------------------------------------------- Overall Test Methods
/**
* Set up instance variables required by this test case.
*/
@Before
public void setUp()
{
digester = new Digester();
}
/**
* Tear down instance variables required by this test case.
*/
@After
public void tearDown()
{
digester = null;
}
// ------------------------------------------------ Individual Test Methods
/**
* Test object creation (and associated property setting) with nothing on the stack, which should cause an
* appropriate Employee object to be returned.
*/
@Test
public void testObjectCreate1()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", "org.apache.commons.digester3.Employee" );
digester.addSetProperties( "employee" );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test1.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
}
/**
* Test object creation (and associated property setting) with nothing on the stack, which should cause an
* appropriate Employee object to be returned. The processing rules will process the nested Address elements as
* well, but will not attempt to add them to the Employee.
*/
@Test
public void testObjectCreate2()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", Employee.class );
digester.addSetProperties( "employee" );
digester.addObjectCreate( "employee/address", "org.apache.commons.digester3.Address" );
digester.addSetProperties( "employee/address" );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test1.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
}
/**
* Test object creation (and associated property setting) with nothing on the stack, which should cause an
* appropriate Employee object to be returned. The processing rules will process the nested Address elements as
* well, and will add them to the owning Employee.
*/
@Test
public void testObjectCreate3()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", Employee.class );
digester.addSetProperties( "employee" );
digester.addObjectCreate( "employee/address", "org.apache.commons.digester3.Address" );
digester.addSetProperties( "employee/address" );
digester.addSetNext( "employee/address", "addAddress" );
// Parse our test input once
Object root = null;
root = digester.parse( getInputStream( "Test1.xml" ) );
validateObjectCreate3( root );
// Parse the same input again
try
{
root = digester.parse( getInputStream( "Test1.xml" ) );
}
catch ( Throwable t )
{
fail( "Digester threw IOException: " + t );
}
validateObjectCreate3( root );
}
/**
* Same as testObjectCreate1(), except use individual call method rules to set the properties of the Employee.
*/
@Test
public void testObjectCreate4()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", Employee.class );
digester.addCallMethod( "employee", "setFirstName", 1 );
digester.addCallParam( "employee", 0, "firstName" );
digester.addCallMethod( "employee", "setLastName", 1 );
digester.addCallParam( "employee", 0, "lastName" );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test1.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
}
/**
* Same as testObjectCreate1(), except use individual call method rules to set the properties of the Employee. Bean
* data are defined using elements instead of attributes. The purpose is to test CallMethod with a paramCount=0 (ie
* the body of the element is the argument of the method).
*/
@Test
public void testObjectCreate5()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", Employee.class );
digester.addCallMethod( "employee/firstName", "setFirstName", 0 );
digester.addCallMethod( "employee/lastName", "setLastName", 0 );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test5.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
}
/**
* It should be possible to parse the same input twice, and get trees of objects that are isomorphic but not be
* identical object instances.
*/
@Test
public void testRepeatedParse()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", Employee.class );
digester.addSetProperties( "employee" );
digester.addObjectCreate( "employee/address", "org.apache.commons.digester3.Address" );
digester.addSetProperties( "employee/address" );
digester.addSetNext( "employee/address", "addAddress" );
// Parse our test input the first time
Object root1 = null;
root1 = digester.parse( getInputStream( "Test1.xml" ) );
validateObjectCreate3( root1 );
// Parse our test input the second time
Object root2 = null;
root2 = digester.parse( getInputStream( "Test1.xml" ) );
validateObjectCreate3( root2 );
// Make sure that it was a different root
assertTrue( "Different tree instances were returned", root1 != root2 );
}
/**
* Test object creation (and associated property setting) with nothing on the stack, which should cause an
* appropriate Employee object to be returned. The processing rules will process the nested Address elements as
* well, but will not attempt to add them to the Employee.
*/
@Test
public void testRuleSet1()
throws SAXException, IOException
{
// Configure the digester as required
RuleSet rs = new TestRuleSet();
digester.addRuleSet( rs );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test1.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
assertNotNull( "Can retrieve home address", employee.getAddress( "home" ) );
assertNotNull( "Can retrieve office address", employee.getAddress( "office" ) );
}
/**
* Same as <code>testRuleSet1</code> except using a single namespace.
*/
@Test
public void testRuleSet2()
throws SAXException, IOException
{
// Configure the digester as required
digester.setNamespaceAware( true );
RuleSet rs = new TestRuleSet( null, "http://commons.apache.org/digester/Foo" );
digester.addRuleSet( rs );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test2.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
assertNotNull( "Can retrieve home address", employee.getAddress( "home" ) );
assertNotNull( "Can retrieve office address", employee.getAddress( "office" ) );
}
/**
* Same as <code>testRuleSet2</code> except using a namespace for employee that we should recognize, and a namespace
* for address that we should skip.
*/
@Test
public void testRuleSet3()
throws SAXException, IOException
{
// Configure the digester as required
digester.setNamespaceAware( true );
RuleSet rs = new TestRuleSet( null, "http://commons.apache.org/digester/Foo" );
digester.addRuleSet( rs );
// Parse our test input.
Employee employee = digester.parse( getInputStream( "Test3.xml" ) );
assertNotNull( "Digester returned an object", employee );
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
assertNull( "Can not retrieve home address", employee.getAddress( "home" ) );
assertNull( "Can not retrieve office address", employee.getAddress( "office" ) );
}
/**
* Test the two argument version of the SetTopRule rule. This test is based on testObjectCreate3 and should result
* in the same tree of objects. Instead of using the SetNextRule rule which results in a method invocation on the
* (top-1) (parent) object with the top object (child) as an argument, this test uses the SetTopRule rule which
* results in a method invocation on the top object (child) with the top-1 (parent) object as an argument. The three
* argument form is tested in <code>testSetTopRule2</code>.
*/
@Test
public void testSetTopRule1()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", "org.apache.commons.digester3.Employee" );
digester.addSetProperties( "employee" );
digester.addObjectCreate( "employee/address", "org.apache.commons.digester3.Address" );
digester.addSetProperties( "employee/address" );
digester.addSetTop( "employee/address", "setEmployee" );
// Parse our test input.
Object root = null;
root = digester.parse( getInputStream( "Test1.xml" ) );
validateObjectCreate3( root );
}
/**
* Same as <code>testSetTopRule1</code> except using the three argument form of the SetTopRule rule.
*/
@Test
public void testSetTopRule2()
throws SAXException, IOException
{
// Configure the digester as required
digester.addObjectCreate( "employee", "org.apache.commons.digester3.Employee" );
digester.addSetProperties( "employee" );
digester.addObjectCreate( "employee/address", "org.apache.commons.digester3.Address" );
digester.addSetProperties( "employee/address" );
digester.addSetTop( "employee/address", "setEmployee", "org.apache.commons.digester3.Employee" );
// Parse our test input.
Object root = null;
root = digester.parse( getInputStream( "Test1.xml" ) );
validateObjectCreate3( root );
}
/**
* Test rule addition - this boils down to making sure that digester is set properly on rule addition.
*/
@Test
public void testAddRule()
{
Digester digester = new Digester();
TestRule rule = new TestRule( "Test" );
digester.addRule( "/root", rule );
assertEquals( "Digester is not properly on rule addition.", digester, rule.getDigester() );
}
@Test
public void testSetNext()
throws SAXException, IOException
{
Digester digester = new Digester();
digester.setRules( new ExtendedBaseRules() );
digester.setValidating( false );
digester.addObjectCreate( "!*/b", BetaBean.class );
digester.addObjectCreate( "!*/a", AlphaBean.class );
digester.addObjectCreate( "root", ArrayList.class );
digester.addSetProperties( "!*" );
digester.addSetNext( "!*/b/?", "setChild" );
digester.addSetNext( "!*/a/?", "setChild" );
digester.addSetNext( "!root/?", "add" );
ArrayList<?> root = digester.parse( getInputStream( "Test4.xml" ) );
assertEquals( "Wrong array size", 2, root.size() );
AlphaBean one = (AlphaBean) root.get( 0 );
assertTrue( one.getChild() instanceof BetaBean );
BetaBean two = (BetaBean) one.getChild();
assertEquals( "Wrong name (1)", two.getName(), "TWO" );
assertTrue( two.getChild() instanceof AlphaBean );
AlphaBean three = (AlphaBean) two.getChild();
assertEquals( "Wrong name (2)", three.getName(), "THREE" );
BetaBean four = (BetaBean) root.get( 1 );
assertEquals( "Wrong name (3)", four.getName(), "FOUR" );
assertTrue( four.getChild() instanceof BetaBean );
BetaBean five = (BetaBean) four.getChild();
assertEquals( "Wrong name (4)", five.getName(), "FIVE" );
}
@Test
public void testSetTop()
throws SAXException, IOException
{
Digester digester = new Digester();
digester.setRules( new ExtendedBaseRules() );
digester.setValidating( false );
digester.addObjectCreate( "!*/b", BetaBean.class );
digester.addObjectCreate( "!*/a", AlphaBean.class );
digester.addObjectCreate( "root", ArrayList.class );
digester.addSetProperties( "!*" );
digester.addSetTop( "!*/b/?", "setParent" );
digester.addSetTop( "!*/a/?", "setParent" );
digester.addSetRoot( "!*/a", "add" );
digester.addSetRoot( "!*/b", "add" );
ArrayList<?> root = digester.parse( getInputStream( "Test4.xml" ) );
assertEquals( "Wrong array size", 5, root.size() );
// note that the array is in popped order (rather than pushed)
Object obj = root.get( 1 );
assertTrue( "TWO should be a BetaBean", obj instanceof BetaBean );
BetaBean two = (BetaBean) obj;
assertNotNull( "Two's parent should not be null", two.getParent() );
assertEquals( "Wrong name (1)", "TWO", two.getName() );
assertEquals( "Wrong name (2)", "ONE", two.getParent().getName() );
obj = root.get( 0 );
assertTrue( "THREE should be an AlphaBean", obj instanceof AlphaBean );
AlphaBean three = (AlphaBean) obj;
assertNotNull( "Three's parent should not be null", three.getParent() );
assertEquals( "Wrong name (3)", "THREE", three.getName() );
assertEquals( "Wrong name (4)", "TWO", three.getParent().getName() );
obj = root.get( 3 );
assertTrue( "FIVE should be a BetaBean", obj instanceof BetaBean );
BetaBean five = (BetaBean) obj;
assertNotNull( "Five's parent should not be null", five.getParent() );
assertEquals( "Wrong name (5)", "FIVE", five.getName() );
assertEquals( "Wrong name (6)", "FOUR", five.getParent().getName() );
}
/**
*/
@Test
public void testSetCustomProperties()
throws SAXException, IOException
{
Digester digester = new Digester();
digester.setValidating( false );
digester.addObjectCreate( "toplevel", ArrayList.class );
digester.addObjectCreate( "toplevel/one", Address.class );
digester.addSetNext( "toplevel/one", "add" );
digester.addObjectCreate( "toplevel/two", Address.class );
digester.addSetNext( "toplevel/two", "add" );
digester.addObjectCreate( "toplevel/three", Address.class );
digester.addSetNext( "toplevel/three", "add" );
digester.addObjectCreate( "toplevel/four", Address.class );
digester.addSetNext( "toplevel/four", "add" );
digester.addSetProperties( "toplevel/one" );
digester.addSetProperties( "toplevel/two", new String[] { "alt-street", "alt-city", "alt-state" },
new String[] { "street", "city", "state" } );
digester.addSetProperties( "toplevel/three", new String[] { "aCity", "state" }, new String[] { "city" } );
digester.addSetProperties( "toplevel/four", "alt-city", "city" );
ArrayList<?> root = digester.parse( getInputStream( "Test7.xml" ) );
assertEquals( "Wrong array size", 4, root.size() );
// note that the array is in popped order (rather than pushed)
Object obj = root.get( 0 );
assertTrue( "(1) Should be an Address ", obj instanceof Address );
Address addressOne = (Address) obj;
assertEquals( "(1) Street attribute", "New Street", addressOne.getStreet() );
assertEquals( "(1) City attribute", "Las Vegas", addressOne.getCity() );
assertEquals( "(1) State attribute", "Nevada", addressOne.getState() );
obj = root.get( 1 );
assertTrue( "(2) Should be an Address ", obj instanceof Address );
Address addressTwo = (Address) obj;
assertEquals( "(2) Street attribute", "Old Street", addressTwo.getStreet() );
assertEquals( "(2) City attribute", "Portland", addressTwo.getCity() );
assertEquals( "(2) State attribute", "Oregon", addressTwo.getState() );
obj = root.get( 2 );
assertTrue( "(3) Should be an Address ", obj instanceof Address );
Address addressThree = (Address) obj;
assertEquals( "(3) Street attribute", "4th Street", addressThree.getStreet() );
assertEquals( "(3) City attribute", "Dayton", addressThree.getCity() );
assertEquals( "(3) State attribute", "US", addressThree.getState() );
obj = root.get( 3 );
assertTrue( "(4) Should be an Address ", obj instanceof Address );
Address addressFour = (Address) obj;
assertEquals( "(4) Street attribute", "6th Street", addressFour.getStreet() );
assertEquals( "(4) City attribute", "Cleveland", addressFour.getCity() );
assertEquals( "(4) State attribute", "Ohio", addressFour.getState() );
}
// ------------------------------------------------ Utility Support Methods
/**
* Return an appropriate InputStream for the specified test file (which must be inside our current package.
*
* @param name Name of the test file we want
* @exception IOException if an input/output error occurs
*/
protected InputStream getInputStream( String name )
throws IOException
{
return ( this.getClass().getResourceAsStream( "/org/apache/commons/digester3/" + name ) );
}
/**
* Validate the assertions for ObjectCreateRule3.
*
* @param root Root object returned by <code>digester.parse()</code>
*/
protected void validateObjectCreate3( Object root )
{
// Validate the retrieved Employee
assertNotNull( "Digester returned an object", root );
assertTrue( "Digester returned an Employee", root instanceof Employee );
Employee employee = (Employee) root;
assertEquals( "First name is correct", "First Name", employee.getFirstName() );
assertEquals( "Last name is correct", "Last Name", employee.getLastName() );
// Validate the corresponding "home" Address
Address home = employee.getAddress( "home" );
assertNotNull( "Retrieved home address", home );
assertEquals( "Home street", "Home Street", home.getStreet() );
assertEquals( "Home city", "Home City", home.getCity() );
assertEquals( "Home state", "HS", home.getState() );
assertEquals( "Home zip", "HmZip", home.getZipCode() );
// Validate the corresponding "office" Address
Address office = employee.getAddress( "office" );
assertNotNull( "Retrieved office address", office );
assertEquals( "Office street", "Office Street", office.getStreet() );
assertEquals( "Office city", "Office City", office.getCity() );
assertEquals( "Office state", "OS", office.getState() );
assertEquals( "Office zip", "OfZip", office.getZipCode() );
}
}