messagetest.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

            MessageElement aElement = 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 = 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 = 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());
        }
        
    }
}