messagetest.java

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

        Message.ElementIterator eachElement = msg1.getMessageElements( "not-default", foo );
        Iterator eachListElement = list.iterator();
        
        while( eachElement.hasNext() ) {
            MessageElement aElement = (MessageElement) eachElement.next();
            
            assertTrue( "Should still be contents in the test vector.", eachListElement.hasNext() );
            MessageElement aListElement = (MessageElement) eachListElement.next();
            
            assertTrue( "Should be the correct mime type", aElement.getMimeType().equals(foo) );
            assertTrue( "Should be the same element", aElement == aListElement );
            assertTrue( "Elements should be equal", aElement.equals( aListElement ) );
        }
        
        assertTrue( "iterators should have ended at the same time", !eachListElement.hasNext() );
    }
    
    public void testMessageGetElement() {
        Message msg1 = new Message( "default" );
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", (MessageElement) null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", (MessageElement) null );
        
        msg1.addMessageElement( elm1 );
        msg1.addMessageElement( "not-default", elm1 );
        
        msg1.addMessageElement( "not-default", elm2 );
        
        // try to get back an element by name
        MessageElement elm3 = msg1.getMessageElement( "element1" );
        
        assertSame( "Did not get back the right element", elm3, elm1 );
        
        // try to get back on in a non default name space
        elm3 = msg1.getMessageElement( "element2" );
        
        assertSame( "Did not get back the right element", elm3, elm2 );
        
        // get an element from a named namespace
        elm3 = msg1.getMessageElement( "default", "element1" );
        
        assertSame( "Did not get back the right element", elm3, elm1 );
        
        // get an element from a non-default named name space.
        elm3 = msg1.getMessageElement( "not-default", "element1" );
        
        assertSame( "Did not get back the right element", elm3, elm1 );
        
        // make sure we can't get an element from a namespace its not in.
        elm3 = msg1.getMessageElement( "default", "element2" );
        
        assertNull( "Should not have gotten an element", elm3 );
    }
    
    public void testMessageGetNamespaces() {
        Message msg1 = new Message( "default" );
        Set namespaces = new HashSet();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", (MessageElement) null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", (MessageElement) null );
        
        msg1.addMessageElement( elm1 );
        namespaces.add( "default" );
        
        msg1.addMessageElement( "not-default", elm2 );
        namespaces.add( "not-default" );
        
        Iterator eachNamespace = msg1.getMessageNamespaces();
        
        while( eachNamespace.hasNext() ) {
            String aNamespace = (String) eachNamespace.next();
            
            assertTrue( namespaces.remove( aNamespace ) );
        }
        
        assertTrue( namespaces.isEmpty() );
    }
    
    /**
     *    tests the replace method
     **/
    public void testMessageReplacement() {
        Message msg1 = new Message();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element1", "test1", null );
        
        int initialModCount = msg1.getMessageModCount();
        
        msg1.addMessageElement( elm1 );
        
        int afterAddModCount = msg1.getMessageModCount();
        
        assertTrue( "element was added, modcounts should differ", initialModCount != afterAddModCount );
        
        Iterator elements = msg1.getMessageElements();
        
        assertTrue( "message should have had an element", elements.hasNext() );
        
        assertTrue( "should have replaced elem1", elm1 == msg1.replaceMessageElement(elm2) );
        
        int afterReplaceModCount = msg1.getMessageModCount();
        
        assertTrue( "replaced, modcounts should differ", afterAddModCount != afterReplaceModCount );
        
        elements = msg1.getMessageElements();
        
        assertTrue( "message should have had an element", elements.hasNext() );
        
        assertTrue( "should have returned elm2", elm2 == elements.next() );
    }
    
    /**
     *    tests the replace method
     **/
    public void testIteratorSet() {
        Message msg1 = new Message();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element1", "test1", null );
        
        int initialModCount = msg1.getMessageModCount();
        
        msg1.addMessageElement( elm1 );
        
        int afterAddModCount = msg1.getMessageModCount();
        
        assertTrue( "element was added, modcounts should differ", initialModCount != afterAddModCount );
        
        Message.ElementIterator elements = msg1.getMessageElements();
        
        assertTrue( "message should have had an element", elements.hasNext() );
        
        assertTrue( "should have returned elm1", elm1 == elements.next() );
        
        elements.set( elm2);
        
        int afterReplaceModCount = msg1.getMessageModCount();
        
        assertTrue( "replaced, modcounts should differ", afterAddModCount != afterReplaceModCount );
        
        elements = msg1.getMessageElements();
        
        assertTrue( "message should have had an element", elements.hasNext() );
        
        assertTrue( "should have returned elm2", elm2 == elements.next() );
    }
    
    /**
     *   Tests Message Element
     **/
    public void testMessageLength() {
        Message msg1 = new Message();
        List    list = new ArrayList();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element1", "test23", null );
        
        assertTrue( "Message should have had length 0", 0 == msg1.getByteLength() );
        
        int initialModCount = msg1.getMessageModCount();
        
        msg1.addMessageElement( elm1 );
        int firstElementModCount = msg1.getMessageModCount();
        
        long msgLen1 = msg1.getByteLength();
        assertTrue( "Message should have had length > 0", msgLen1 > 0 );
        assertTrue( "element was added, modcounts should differ", initialModCount != firstElementModCount );
        
        msg1.addMessageElement( "not-default", elm2 );
        int secondElementModCount = msg1.getMessageModCount();
        assertTrue( "element was added, modcounts should differ", firstElementModCount != secondElementModCount );
        long msgLen2 = msg1.getByteLength();
        assertTrue( "Message length should have increased", msgLen2 > msgLen1 );
        
        msg1.clear();
        
        int afterClearModCount = msg1.getMessageModCount();
        
        assertTrue( "cleared, modcounts should differ", secondElementModCount != afterClearModCount );
        
        assertTrue( "Message should have had length 0", 0 == msg1.getByteLength() );
    }
    
    /**
     *   Tests Message Element
     **/
    public void testMessageToString() {
        Message msg1 = new Message();
        
        String toString = msg1.toString();
        
        assertTrue( "Message should have had a toString", 0 != toString.length() );
    }
    
    /**
     *    Test Message Element Remove
     **/
    public void testMessageRemoveElement() {
        Message msg1 = new Message();
        List    list = new ArrayList();
        List    namespaces = new ArrayList();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", null );
        
        msg1.addMessageElement( elm1 );
        msg1.addMessageElement( "not-default", elm1 );
        list.add( elm1 );
        namespaces.add( "not-default" );
        msg1.addMessageElement( "not-default", elm2 );
        list.add( elm2 );
        namespaces.add( "not-default" );
        msg1.addMessageElement( "not-default", elm2 );
        list.add( elm2 );
        namespaces.add( "not-default" );
        
        assertTrue( "should have removed an element", msg1.removeMessageElement( elm1 ) );
        
        // check if all of the elements are returned
        Message.ElementIterator eachElement = msg1.getMessageElements();
        Iterator eachListElement = list.iterator();
        Iterator eachNamesElement = namespaces.iterator();
        
        while( eachElement.hasNext() ) {
            MessageElement aElement = (MessageElement) eachElement.next();
            MessageElement aListElement = (MessageElement) eachListElement.next();
            
            assertTrue( "namespaces should have matched", eachElement.getNamespace().equals( eachNamesElement.next() ) );
            assertTrue( "should be the same element", aElement == aListElement );
            assertTrue( "elements should be equal", aElement.equals( aListElement ) );
        }
        
        assertTrue( "iterators should have ended at the same time", !eachListElement.hasNext() );
        
        assertTrue( "should not have removed an element", !msg1.removeMessageElement( "bogus", elm2 ) );
    }
    
    public void testIssue991() {
        Message msg1 = new Message();
        List    list = new ArrayList();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", null );
        MessageElement elm3 = new StringMessageElement( "element3", "test3", null );
        
        msg1.addMessageElement( elm1 );
        list.add( elm1 );
        
        msg1.addMessageElement( "not-default", elm1 );
        list.add( elm1 );
        
        msg1.addMessageElement( elm2 );
        list.add( elm2 );
        
        msg1.addMessageElement( "not-default", elm2 );
        list.add( elm2 );
        
        msg1.addMessageElement( elm3 );
        list.add( elm3 );
        
        msg1.addMessageElement( "not-default", elm3 );
        list.add( elm3 );
        
        msg1.addMessageElement( "not-default", elm3 );
        list.add( elm3 );
        
        // Remove an element.
        Message.ElementIterator eachElement = msg1.getMessageElements( );
        Iterator eachListElement = list.iterator();
        
        eachElement.next(); eachListElement.next(); // "", elm1
        eachElement.next(); eachListElement.next(); // "not-default", elm1
        eachElement.next(); eachListElement.next(); // "", elm2
        eachElement.next(); eachListElement.next(); // "not-default", elm2
        eachElement.next(); eachListElement.next(); // "", elm3
        eachElement.next(); eachListElement.next(); // "not-default", elm3
        eachElement.next(); eachListElement.next(); // "not-default", elm3
        eachElement.remove();  eachListElement.remove(); // should be removing elm3
        
        eachElement = msg1.getMessageElements( );
        eachListElement = list.iterator();
        
        while( eachElement.hasNext() ) {
            MessageElement aElement = (MessageElement) eachElement.next();
            MessageElement aListElement = (MessageElement) eachListElement.next();
            
            assertTrue( "should be the same element", aElement == aListElement );
            assertTrue( "elements should be equal", aElement.equals( aListElement ) );
        }
        
        assertTrue( "iterators should have ended at the same time", !eachListElement.hasNext() );
    }
    
    public void testConcurrentMod() {
        Message msg1 = new Message();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", null );
        
        msg1.addMessageElement( elm1 );
        msg1.addMessageElement( "not-default", elm1 );
        
        msg1.addMessageElement( "not-default", elm2 );
        
        msg1.addMessageElement( "not-default", elm2 );
        
        Iterator allElems = msg1.getMessageElements();
        
        MessageElement elm3 = (MessageElement) allElems.next();
        
        // this should cause a concurrent mod except if allElms.next() is called
        msg1.addMessageElement( elm1 );
        
        try {
            elm3 = (MessageElement) allElems.next();
        } catch( ConcurrentModificationException failed ) {
        }
    }
    
    public void testMessageSerialization() {
        Message msg1 = new Message();
        
        MessageElement elm1 = new StringMessageElement( "element1", "test1", null );
        MessageElement elm2 = new StringMessageElement( "element2", "test2", null );
        
        msg1.addMessageElement( elm1 );
        msg1.addMessageElement( "not-default", elm1 );
        
        msg1.addMessageElement( "not-default", elm2 );
        
        msg1.addMessageElement( "not-default", elm2 );
        
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            
            oos.writeObject( msg1 );
            
            oos.close();
            bos.close();
            
            ByteArrayInputStream bis = new ByteArrayInputStream( bos.toByteArray() );
            ObjectInputStream ois = new ObjectInputStream( bis );
            
            Message msg2 = (Message) ois.readObject();
            
            assertTrue( "Messages should have been equal()", msg1.equals(msg2) );
        } catch ( Throwable failure ) {
            fail( "Exception during test! "+ failure.getMessage() );
        }
        
    }
}