doctest.java

jxme的一些相关程序,主要是手机上程序开发以及手机和计算机通信的一些程序资料,程序编译需要Ant支持

/*
 * $Id: DocTest.java,v 1.1 2002/02/18 16:06:30 echtcherbina 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.
 ********************
 */

import junit.framework.*;

import java.io.Writer;
import java.io.ByteArrayOutputStream;
import java.io.StringWriter;
import java.util.Enumeration;
import java.io.StringReader;

import net.jxta.document.*;
import net.jxta.impl.document.*;

/**
 *
 * @author  mike
 * @version
 */
public final class DocTest extends TestCase {
    
    public static class LiteXMLBug {
        public LiteXMLBug( String xml ) {
            MimeMediaType mimeMediaType = new MimeMediaType( "text/plain" );
            StringReader reader = new StringReader( xml );
            try {
                LiteXMLDocument document =
                new LiteXMLDocument( mimeMediaType, reader );
                spew( document );
            }
            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 DocTest(String name) {
        super(name);
    }
    
    private void _test( MimeMediaType type ) {
        try {
            final String useDocType = "Test";
            StructuredTextDocument doc = null;
            try {
                doc = (StructuredTextDocument) StructuredDocumentFactory.newStructuredDocument( 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) );
            
            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 );
            
            if( testElement instanceof Attributable ) {
                _testAttributes( (Attributable) testElement );
                _testAttributes( (Attributable) testElement3 );
            }
            
            StructuredDocument likeMe = null;
            
            try {
                likeMe = StructuredDocumentFactory.newStructuredDocument( doc.getMimeType(), doc.getStream() );
            }
            catch( java.security.ProviderException thrown ) {
                ;
            } catch( Throwable thrown ) {
                fail("Exception thrown during construction!" + 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) );
            }
            
        }
        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",
            anAttrib.getValue().equals( someValue ) );
            
            anAttrib = element.getAttribute( "bogusName" );
            
            assertTrue( "Should not have been able to get an unknown attribute name", null == anAttrib );
            
        }
        catch( Throwable everything ) {
            everything.printStackTrace();
            fail( "Caught an unexpected exception - " + everything.toString() );
        }
    }
    
    public void _testAttributesSolo( MimeMediaType type ) {
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            LiteXMLDocument doc = new LiteXMLDocument( type, "Message");
            doc.addAttribute("version", "123");
            doc.sendToStream(os);
            
            String old = doc.addAttribute("version", "1xx23");
            assertTrue( "updating attribute gave wrong result", "123".equals( old ) );
            doc.sendToStream(os);
        }
        catch( Throwable everything ) {
            everything.printStackTrace();
            fail( "Caught an unexpected exception - " + everything.toString() );
        }
    }
    
    public static void copyElements( StructuredDocument intoDoc, Element intoElement, Element from ) {
        Object fromKey = from.getKey();
        Object fromValue = from.getValue();
        
        Element newElement = intoDoc.createElement( fromKey, fromValue );
        
        intoElement.appendChild( newElement );
        
        // recurse to add the children.
        for( Enumeration eachChild = from.getChildren(); eachChild.hasMoreElements(); ) {
            Element aChild = (Element) eachChild.nextElement();
            
            copyElements( intoDoc, newElement, aChild );
        }
    }
    
    public void testXMLStructuredDoc() {
        _test( new MimeMediaType("Text/Xml") );
        _testAttributesSolo( new MimeMediaType("Text/Xml") );
    }
    
    public void testPlainTextDoc() {
        _test(new MimeMediaType("Text/Plain"));
        _testAttributesSolo( new MimeMediaType("Text/Plain") );
    }
    
    public void testExtensionMapping() {
        MimeMediaType refMime = new MimeMediaType("Text/Xml");
        String refExt = "xml";
        
        String ext = StructuredDocumentFactory.getFileExtensionForMimeType(
        refMime );
        
        MimeMediaType mime = StructuredDocumentFactory.getMimeTypeForFileExtension(
        ext );
        
        assertTrue( "mime type was not the same after reflex mapping",
        refMime.equals( mime ) );
        
        assertTrue( "extension was not the same after reflex mapping",
        refExt.equals( ext ) );
    }
    
    public void testIssue102() {
        String WORKS =
        "<xml><stooges>Moe, Larry, &#x41;&#65;&#0666;& Curly</stooges></xml>";
        
        String DOES_NOT_WORK =
        "<xml><stooges>Moe, Larry, & Joe</stooges></xml>";
        
        LiteXMLBug works = new LiteXMLBug( WORKS );
        LiteXMLBug doesNotWork = new LiteXMLBug( DOES_NOT_WORK );
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        new junit.textui.TestRunner().main(new String[] {"DocTest"});
    }
    
}