testattribute.java

一个java操作xml的完整示例

package org.jdom.test.cases;

/*--

 Copyright (C) 2000 Brett McLaughlin & Jason Hunter.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:

 1. Redistributions of source code must retain the above copyright
	notice, this list of conditions, and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions, and the disclaimer that follows
	these conditions in the documentation and/or other materials
	provided with the distribution.

 3. The name "JDOM" must not be used to endorse or promote products
	derived from this software without prior written permission.  For
	written permission, please contact [e-mail].

 4. Products derived from this software may not be called "JDOM", nor
	may "JDOM" appear in their name, without prior written permission
	from the JDOM Project Management ([e-mail]).

 In addition, we request (but do not require) that you include in the
 end-user documentation provided with the redistribution and/or in the
 software itself an acknowledgement equivalent to the following:
	 "This product includes software developed by the
	  JDOM Project (http://www.jdom.org/)."
 Alternatively, the acknowledgment may be graphical using the logos
 available at http://www.jdom.org/images/logos.

 THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.

 This software consists of voluntary contributions made by many
 individuals on behalf of the JDOM Project and was originally
 created by Brett McLaughlin <[e-mail]> and
 Jason Hunter <[e-mail]>.  For more information on the
 JDOM Project, please see <http://www.jdom.org/>.

 */


import java.io.*;
import junit.framework.*;

import org.jdom.*;

/**
 * Test the expected behavior of the Attribute class.
 *
 * @author unascribed
 * @version 0.1
 */
public final class TestAttribute
    extends junit.framework.TestCase
{

    /**
     *  Construct a new instance.
     */
    public TestAttribute(final String name) {
        super(name);
    }

    /**
     * The main method runs all the tests in the text ui
     */
    public static void main (final String args[]) {
        junit.textui.TestRunner.run(suite());
    }

    /**
     * This method is called before a test is executed.
     */
    public void setUp() {
        // your code goes here.
    }

    /**
     * The suite method runs all the tests
     */
    public static Test suite () {
        final TestSuite suite = new TestSuite(TestAttribute.class);
        return suite;
    }

    /**
     * This method is called after a test is executed.
     */
    public void tearDown() {
        // your code goes here.
    }

    /**
     * Test the simple case of constructing an attribute without name, value,
     * namespace or prefix
     */
    public void test_TCC() {
        final Attribute attribute = new Attribute(){
            // anonymous class
        };
    }

    /**
	 * Test the simple case of constructing an attribute without
	 * namespace or prefix
	 */
	public void test_TCC___String_String() {
		final Attribute attribute = new Attribute("test", "value");
		assertTrue("incorrect attribute name", attribute.getName().equals("test"));
        assertTrue("incoorect attribute value", attribute.getValue().equals("value"));
        assertEquals("incorrect attribute type", attribute.getAttributeType(), Attribute.UNDECLARED_TYPE);

        //should have been put in the NO_NAMESPACE namespace
		assertTrue("incorrect namespace", attribute.getNamespace().equals(Namespace.NO_NAMESPACE));


		try {
			final Attribute nullNameAttribute = new Attribute(null, "value");
			fail("didn't catch null attribute name");
		} catch (final IllegalArgumentException e) {
		} catch (final NullPointerException e) {
			fail("NullPointerException with null attribute name");
		}

		try {
            final Attribute nullValueAttribute  = new Attribute("test", null);
			fail("didn't catch null attribute value");
		} catch (final IllegalArgumentException e) {
		} catch (final NullPointerException e) {
			fail("NullPointerException with null attribute value");
		}

		try {
            final Attribute invalidNameAttribute = new Attribute("test" + (char)0x01, "value");
			fail("didn't catch invalid attribute name");
		} catch (final IllegalArgumentException e) {
		}

		try {
            final Attribute invalidValueAttribute = new Attribute("test", "test" + (char)0x01);
			fail("didn't catch invalid attribute value");
		} catch (final IllegalArgumentException e) {
		}

	}

    /**
	 * Test the constructor with name, value and namespace
	 */
	public void test_TCC___String_String_OrgJdomNamespace() {
        {
    		final Namespace namespace = Namespace.getNamespace("prefx", "http://some.other.place");

    		final Attribute attribute = new Attribute("test", "value", namespace);
    		assertTrue("incorrect attribute name", attribute.getName().equals("test"));
    		assertTrue("incoorect attribute value", attribute.getValue().equals("value"));
    		assertTrue("incorrect Namespace", attribute.getNamespace().equals(namespace));

            assertEquals("incoorect attribute type", attribute.getAttributeType(), Attribute.UNDECLARED_TYPE);
        }

		//now test that the attribute cannot be created with a namespace
		//without a prefix
        final Namespace defaultNamespace = Namespace.getNamespace("http://some.other.place");
		try {
            final Attribute attribute = new Attribute("test", "value", defaultNamespace);
			fail("allowed creation of attribute with a default namespace");
		} catch (final IllegalNameException e) {
		}


		try {
            final Attribute attribute = new Attribute("test", "value", null);
		} catch (final Exception e) {
        		fail("didn't handle null attribute namespace");
		}
	}


    /**
     * Test possible attribute values
     */
    public void test_TCM__Attribute_setAttributeType_int() {
        final Attribute attribute = new Attribute("test", "value");

        for(int attributeType = -10; attributeType < 15; attributeType++) {
            if (
                    Attribute.UNDECLARED_TYPE <= attributeType &&
                    attributeType <= Attribute.ENUMERATED_TYPE
            ) {
                continue;
            }
            try {
                attribute.setAttributeType(attributeType);
                fail("set unvalid attribute type: "+ attributeType);
            }
            catch(final IllegalDataException ignore) {
                // is expected
            }
            catch(final Exception exception) {
                fail("unknown exception throws: "+ exception);
            }
        }
    }

    /**
	 * Test a simple object comparison
	 */
	public void test_TCM__boolean_equals_Object() {
		final Attribute attribute = new Attribute("test", "value");

        assertFalse("attribute equal to null", attribute.equals(null));

        final Object object = (Object) attribute;
        assertTrue("object not equal to attribute", attribute.equals(object));
        assertTrue("attribute not equal to object", object.equals(attribute));

        // current implementation checks only for identity
//        final Attribute clonedAttribute = (Attribute) attribute.clone();
//        assertTrue("attribute not equal to its clone", attribute.equals(clonedAttribute));
//        assertTrue("clone not equal to attribute", clonedAttribute.equals(attribute));
	}

    /**
	 * test the convienience method getBooleanValue();
	 */
	public void test_TCM__boolean_getBooleanValue() {
		final Attribute attribute = new Attribute("test", "true");
		try {
			assertTrue("incorrect boolean true value", attribute.getBooleanValue());

            attribute.setValue("false");
			assertTrue("incorrect boolean false value", !attribute.getBooleanValue());

            attribute.setValue("TRUE");
			assertTrue("incorrect boolean TRUE value", attribute.getBooleanValue());

            attribute.setValue("FALSE");
			assertTrue("incorrect boolean FALSE value", !attribute.getBooleanValue());

		} catch (DataConversionException e) {
			fail("couldn't convert boolean value");
		}

		try {
            attribute.setValue("foo");
			assertTrue("incorrectly returned boolean from non boolean value", attribute.getBooleanValue());

		} catch (DataConversionException e) {
		}


	}
	/**
	 * Test convience method for getting doubles from an Attribute
	 */
	public void test_TCM__double_getDoubleValue() {
		Attribute attr = new Attribute("test", "11111111111111");
		try {
			assertTrue("incorrect double value", attr.getDoubleValue() == 11111111111111d );

			attr.setValue("0");
			assertTrue("incorrect double value", attr.getDoubleValue() == 0 );