documenttest.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

/*
 * $Id: DocumentTest.java,v 1.21 2005/09/02 00:41:45 bondolo Exp $
 ********************
 *
 * Copyright (c) 2001 Sun Microsystems, Inc.  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 following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *       Sun Microsystems, Inc. for Project JXTA."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact Project JXTA at http://www.jxta.org.
 *
 * 5. Products derived from this software may not be called "JXTA",
 *    nor may "JXTA" appear in their name, without prior written
 *    permission of Sun.
 *
 * 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 SUN MICROSYSTEMS OR
 * ITS 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 Project JXTA.  For more
 * information on Project JXTA, please see
 * <http://www.jxta.org/>.
 *
 * This license is based on the BSD license adopted by the Apache Foundation.
 ********************
 */

package net.jxta.document;

import java.io.*;
import java.util.Enumeration;
import java.util.Collections;
import java.util.List;
import java.security.ProviderException;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import net.jxta.impl.document.LiteXMLDocument;
import net.jxta.impl.document.LiteXMLElement;
import net.jxta.impl.document.PlainTextDocument;
import net.jxta.impl.document.PlainTextElement;

public final class DocumentTest extends TestCase {
       
    final static String badlittleimpl = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
    "<!DOCTYPE jxta:MIA>\n" +
    "<jxta:MIA xmlns:jxta=\"http://jxta.org\">\n" +
    "  	<MSID/>\n" +
    " 	<Parm>\n" +
    " 		<Svc>\n" +
    " 			<jxta:MIA xmlns:jxta=\"http://jxta.org\">\n" +
    " 				<MSID/>\n" +
    " 			</jxta:MIA>\n" +
    " 		</Svc>\n" +
    " 		<Proto>\n" +
    " 			<jxta:MIA xmlns:jxta=\"http://jxta.org\">\n" +
    " 				<MSID/>\n" +
    " 			</jxta:MIA>\n" +
    " 		</Proto>\n" +
    " 	</Parm>\n" +
    " </jxta:MIA>\n";
    
     public static class LiteXMLBug {
        public LiteXMLBug( String xml ) {
            MimeMediaType mimeMediaType = MimeMediaType.XMLUTF8;
            StringReader reader = new StringReader( xml );
            try {
                LiteXMLDocument document = (LiteXMLDocument)
                LiteXMLDocument.INSTANTIATOR.newInstance( mimeMediaType, reader );
                spew( document );
            } catch( IOException caught ) {
                fail( "should not have thrown an exception" );
            } finally {
                reader.close();
            }
        }
        
        public void spew( LiteXMLElement element ) {
            System.out.println( element.getValue() );
            
            Enumeration children = element.getChildren();
            while ( children.hasMoreElements() ) {
                LiteXMLElement child = (LiteXMLElement) children.nextElement();
                spew( child );
            }
        }
        
    }
    
    /** Creates new DocTest */
    public DocumentTest(String name) {
        super(name);
    }
    
    public static Test suite() {
        TestSuite suite = new TestSuite(DocumentTest.class);
        return suite;
    }
    
    private void _test( StructuredDocumentFactory.Instantiator instantiator, MimeMediaType type ) {
        try {
            final String useDocType = "Test";
            StructuredTextDocument doc = null;
            try {
                doc = (StructuredTextDocument) instantiator.newInstance( type, useDocType );
            } catch( Throwable thrown ) {
                fail("exception thrown during construction!" + thrown.toString() );
            }
            
            assertTrue("could not construct object for type : " + type, doc != null);
            
            String itsType = doc.getName();
            
            assertTrue( "returned doctype does not equal type document was created with!",
            useDocType.equals( itsType ) );
            
            assertTrue(
            "returned doc name does not equal name of document element",
            doc.getName().equals( itsType ) );
            
            TextElement testElement = doc.createElement( "element" );
            
            doc.appendChild( testElement );
            
            try {
                Element firstchild = (Element) doc.getChildren().nextElement();
                assertTrue(
                "added a single element, but something else was returned",
                testElement.equals( firstchild ) );
            } catch( Exception e ) {
                e.printStackTrace();
                fail( "added a single element, but it was not returned" );
            }
            
            final String useName = "element2";
            final String useValue = "value&<!";
            
            TextElement testElement2 = doc.createElement( useName, useValue );
            
            testElement.appendChild( testElement2 );
            
            String itsName = testElement2.getName();
            assertTrue("name of element was not correct after creation",
            useName.equals(itsName) );
            
            String itsValue = testElement2.getTextValue();
            assertTrue(
            "value of element was not correct after creation. was '" + itsValue + "' should be '" + useValue + "'",
            useValue.equals(itsValue) );
            
            testElement2 = doc.createElement( "element3", useValue );
            
            testElement.appendChild( testElement2 );
            
            testElement2 = doc.createElement( "element4", "1" );
            
            testElement.appendChild( testElement2 );
            
            itsValue = testElement2.getTextValue();
            assertTrue("value of element was not correct after creation (length 1)",
            "1".equals(itsValue) );
            
            if( type.getSubtype().equalsIgnoreCase( "XML" ) ) {
                try {
                    
                    TextElement testElement5 = doc.createElement( "really wrong and long", "1" );
                    
                    fail( "Tag names with spaces should be disallowed" );
                } catch ( Exception failed ) {
                    // that's ok
                }
            }
            
            int count = 0;
            for( Enumeration eachChild = doc.getChildren(); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue("Doc didnt have one child", 1 == count );
            
            count = 0;
            for( Enumeration eachChild = doc.getChildren( "element" ); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue("Doc didnt have one child named 'element'", 1 == count );
            
            count = 0;
            for( Enumeration eachChild = doc.getChildren( "bogus" ); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue(" Doc shouldnt have had a child named 'bogus'", 0 == count );
            
            count = 0;
            for( Enumeration eachChild = testElement.getChildren( ); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue("element didnt have expected number of children" , 3 == count );
            
            count = 0;
            for( Enumeration eachChild = testElement.getChildren( useName ); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue(
            "element didnt have expected number of children named '" +useName + "'",
            1 == count );
            
            // This check also is important for checking that the behaviour of the
            // tree is correct when there are nodes with the same name as the parent in subtrees.
            
            Element testElement3 = doc.createElement( useName, useValue );
            testElement2.appendChild( testElement3 );
            
            testElement3 = doc.createElement( useName );
            testElement2.appendChild( testElement3 );
            
            count = 0;
            for( Enumeration eachChild = testElement2.getChildren( useName ); eachChild.hasMoreElements(); count++, eachChild.nextElement() )
                ;
            
            assertTrue(
            "element didnt have expected number of children named '" +useName + "'",
            2 == count );
            
            StructuredDocument likeMe = null;
            
            try {
                likeMe = (StructuredTextDocument) instantiator.newInstance( doc.getMimeType(), doc.getStream() );
            } catch( java.security.ProviderException thrown ) {
                ;
            } catch( Throwable thrown ) {
                thrown.printStackTrace();
                fail( "Exception thrown during reconstruction! " + thrown.toString() );
            }
            
            if( testElement instanceof Attributable ) {
                _testAttributes( (Attributable) testElement );
                _testAttributes( (Attributable) testElement3 );
            }
            
            
            try {
                likeMe = instantiator.newInstance( doc.getMimeType(), doc.getStream() );
            } catch( java.security.ProviderException thrown ) {
                ;
            } catch( Throwable thrown ) {
                thrown.printStackTrace();
                fail( "Exception thrown during reconstruction! " + thrown.toString() );
            }
            
            Writer somewhere = new StringWriter();
            
            ((StructuredTextDocument)doc).sendToWriter( somewhere );
            
            String docAsString = somewhere.toString().trim();
            
            testElement3 = doc.createElement( useName, docAsString );
            testElement2.appendChild( testElement3 );
            
            String docFromElement = (String) testElement3.getValue();
            
            assertTrue(
            "Could not faithfully store stream representation of doc in doc. (lengths dont match)",
            docAsString.length() == docFromElement.length() );
            
            for( int eachChar = 0; eachChar < docAsString.length(); eachChar++ ) {
                assertTrue(
                "Could not faithfully store stream representation of doc in doc. (failed at index: " + eachChar + ")",
                docAsString.charAt( eachChar ) == docFromElement.charAt(eachChar) );
            }
            
            Element testElement4 = doc.createElement( "shortname", "shortvalue" );
            Element testElement5 = doc.createElement( "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongname", "shortvalue" );
            Element testElement6 = doc.createElement(
            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongname",
            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongvalue" );
            Element testElement7 = doc.createElement(
            "shortname",
            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongvalue" );
            
            doc.appendChild( testElement4 );
            doc.appendChild( testElement5 );
            doc.appendChild( testElement6 );
            doc.appendChild( testElement7 );
            
            System.out.println( testElement4.toString() );
            //            System.out.println( testElement5.toString() );
            //            System.out.println( testElement6.toString() );
            //           System.out.println( testElement7.toString() );
        } catch( Throwable everything ) {
            everything.printStackTrace();
            fail("caught an unexpected exception - " + everything.toString() );
        }
    }
    
    public void _testAttributes( Attributable element ) {
        try {
            final String someName = "attrName";
            final String someValue = "attrValue";
            
            Enumeration attribs = element.getAttributes();
            
            assertTrue( "Element already had attributes!", !attribs.hasMoreElements() );
            
            assertTrue( "New attribute returned previous value!",
            null == element.addAttribute( someName, someValue ) );
            
            String oldValue = element.addAttribute( new Attribute( someName, someValue) );
            
            assertTrue( "New attribute didnt return previous value!",
            (null != oldValue) && (oldValue.equals(someValue)) );
            
            Attribute anAttrib = element.getAttribute( someName );
            
            assertTrue( "Could not get attribute back!", null != anAttrib );
            
            assertTrue( "value of attribute was not correct",