complexserializertest.java

利用SyncML开发客户端程序的中间件

        expectedDout.write(htStream);
        
        //Assert true if baos is equal to expectedBaos
        htvhtStream = compareStream(baos, expectedBaos);
        Log.info("6.Hashtable with Vector and Hashtable Test Successfull");
    
    }
    
    /**
     * Test of method serializeObject for Vector of Vector: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testSerializeVectorOfVector() throws Exception {
        Log.info("7.Serializing Vector with Vector and Hashtable");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(baos);
        ComplexSerializer.serializeVector(dout,vht);
        
        //Building Expected result
        ByteArrayOutputStream expectedBaos = new ByteArrayOutputStream();
        DataOutputStream expectedDout = new DataOutputStream(expectedBaos);
        
        //Building Expected result
        //expectedDout.writeByte(VECTOR);
        int n = vht.size();
        expectedDout.writeInt(n);
        
        //Writes all the elements of the Vector to expectedDout
        expectedDout.writeByte(VECTOR);
        expectedDout.write(vStream);
        expectedDout.writeByte(HASHTABLE);
        expectedDout.write(htvhtStream);
        expectedDout.writeByte(HASHTABLE);
        expectedDout.write(htStream);
        expectedDout.write(iStream);
        expectedDout.write(strStream);
        expectedDout.write(baStream);
        
        //Assert true if baos is equal to expectedBaos
        vhtStream = compareStream(baos, expectedBaos);
        Log.info("7.Vector with Vector and Hashtable Test Succesfull");
    }

    /**
     * Test of method deserializeObject for Integer: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeInteger() throws Exception {
        Log.info("8.Deserializing Integer");
        ByteArrayInputStream bais = new ByteArrayInputStream(iStream);
        DataInputStream din = new DataInputStream(bais);
        assertEquals(ComplexSerializer.deserializeObject(din), i); 
        Log.info("8.Deserializing Integer Test Successfull");
    
    }

    /**
     * Test of method deserializeObject for String: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeString() throws Exception {
        Log.info("9.Deserializing String");
        ByteArrayInputStream bais = new ByteArrayInputStream(strStream);
        DataInputStream din = new DataInputStream(bais);
        assertEquals(ComplexSerializer.deserializeObject(din), str); 
        Log.info("9.Deserializing String Test Successfull");
    }

    /**
     * Test of method deserializeObject for byte[]: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeByteArray() throws Exception {
        Log.info("10.Deserializing ByteArray");
        ByteArrayInputStream bais = new ByteArrayInputStream(baStream);
        DataInputStream din = new DataInputStream(bais);
        byte[] actual = (byte[]) ComplexSerializer.deserializeObject(din);
        for (int i=0; i<actual.length; i++) {
            assertTrue(actual[i]==ba[i]); 
        }
        Log.info("10.Deserializing ByteArray Test Successfull");
    }

    /**
     * Test of method deserializeObject for HashTable: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeHashTable() throws Exception {
        Log.info("11.Deserializing HashTable");
        ByteArrayInputStream bais = new ByteArrayInputStream(htStream);
        DataInputStream din = new DataInputStream(bais);
        assertEquals(ComplexSerializer.deserializeHashTable(din).toString(), 
                     ht.toString()); 
        Log.info("11.Deserializing HashTable Test Successfull");
    
    }

    /**
     * Test of method deserializeObject for Vector: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeVector() throws Exception {
        Log.info("12.Deserializing Vector");
        ByteArrayInputStream bais = new ByteArrayInputStream(vStream);
        DataInputStream din = new DataInputStream(bais);
        Vector actual = new Vector();
        actual = (Vector) ComplexSerializer.deserializeVector(din);
        assertEquals(actual.elementAt(0), v.elementAt(0)); 
        assertEquals(actual.elementAt(1), v.elementAt(1)); 
        byte[] actualVectorElement = (byte[]) v.elementAt(2);
        for (int i=0; i<actualVectorElement.length; i++) {
            assertTrue(actualVectorElement[i]==ba[i]); 
        }
        assertEquals(actual.elementAt(3).toString(), v.elementAt(3).toString()); 
        Log.info("12.Deserializing Vector Test Successfull");
    }
    
    /**
     * Test of method deserializeObject for HashtableOfVector: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testDeserializeHashtableOfVector() throws Exception {
        Log.info("13.Deserializing HashtableOfVector");
        ByteArrayInputStream bais = new ByteArrayInputStream(htvhtStream);
        DataInputStream din = new DataInputStream(bais);
        //v, ht
        Hashtable actual = new Hashtable();
        actual = (Hashtable) ComplexSerializer.deserializeHashTable(din); 
        Enumeration actualEnum = actual.keys();
        Enumeration expectedEnum = htVectorHashtable.keys(); 
        while (actualEnum.hasMoreElements()) {
            assertEquals(actualEnum.nextElement().getClass().getName(), 
                         expectedEnum.nextElement().getClass().getName());
        }
        
        while (actualEnum.hasMoreElements()) {
            assertEquals(actualEnum.nextElement().toString(), 
                         expectedEnum.nextElement().toString());
        }
        
        actualEnum = actual.elements();
        expectedEnum = htVectorHashtable.elements();
        
        while (actualEnum.hasMoreElements()) {
            assertEquals(actualEnum.nextElement().getClass().getName(), 
                         expectedEnum.nextElement().getClass().getName());
        }
        
        while (actualEnum.hasMoreElements()) {
            assertEquals(actualEnum.nextElement().toString(), 
                         expectedEnum.nextElement().toString());
        }
        
        assertTrue(actual.size()==1);
        
        
        //htVectorHashtable; 
        Log.info("13.Deserializing HashtableOfVector Test Successfull");
    }

    private void testDeserializeVectorOfVector() throws Exception {
        Log.info("14.Deserializing VectorOfVector");
        ByteArrayInputStream bais = new ByteArrayInputStream(vhtStream);
        DataInputStream din = new DataInputStream(bais);
        
        Vector actual = new Vector(); 
        actual = (Vector) ComplexSerializer.deserializeVector(din);
        assertTrue(actual.size()==6);
        assertTrue(actual.elementAt(0) instanceof Vector); 
        assertTrue(actual.elementAt(1) instanceof Hashtable); 
        assertTrue(actual.elementAt(2) instanceof Hashtable); 
        assertTrue(actual.elementAt(3) instanceof Integer); 
        assertTrue(actual.elementAt(4) instanceof String); 
        assertTrue(actual.elementAt(5) instanceof byte[]); 
        
        assertEquals(actual.elementAt(2).toString(), ht.toString());
        assertEquals(actual.elementAt(3), i);
        assertEquals(actual.elementAt(4), str);
        
        byte[] actualBa = (byte[]) actual.elementAt(5);
        for (int i=0; i<actualBa.length; i++) {
            assertTrue(actualBa[i]==ba[i]);
        }
        
        Log.info("14.Deserializing VectorOfVector Test Successfull");
    }
    
    /**
     * Build various private object in order to fully accamplish TestCase 
     * com.funambol.storage.ComplexSerializer.java
     */
    private void createObjects() {
        i = new Integer(100);
        
        str = new String("String to be retrieved");
        
        ba = new byte[3];
        ba[0] = 1;
        ba[1] = 2;
        ba[2] = 3;
        
        ht = new Hashtable();
        ht.put(new String("key 0"), new Integer(0));
        ht.put(new String("key 1"), new Integer(1));
        ht.put(new String("key 2"), new Integer(2));
        ht.put(new String("key 3"), new Integer(3));
        
        v = new Vector();
        v.addElement(i);
        v.addElement(str);
        v.addElement(ba);
        v.addElement(ht);
        
        htVectorHashtable = new Hashtable();
        htVectorHashtable.put(v, ht);
        
        vht = new Vector();
        vht.addElement(v);
        vht.addElement(htVectorHashtable);
        vht.addElement(ht);
        vht.addElement(i);
        vht.addElement(str);
        vht.addElement(ba);
        
        SerializeMe sm = new SerializeMe();
        serializableHt = new Hashtable();
        serializableHt.put(sm, sm);
        
    }

    /**
     * Compare actual and expected Byte array byte by byte.
     * @param baos is the ByteArrayOutputStream obtained from serialization
     * @param expectedBaos is the expected ByteArrayOutputStream
     * @return byte[] result for next test.
     */
    private byte[] compareStream(ByteArrayOutputStream baos, 
                               ByteArrayOutputStream expectedBaos) 
                               throws AssertionFailedException {
        byte[] actual = expectedBaos.toByteArray();
        byte[] expected = baos.toByteArray();
        for (int j=0; j<actual.length; j++) {
            assertTrue(actual[j]==expected[j]);
        }
        //Return the byteArray to use for deserialization test 
        return actual;
    }
    
    /**
     * Test of method serializeObject for Vector of Vector: 
     * com.funambol.storage.ComplexSerializer.
     */
    private void testSerializeSerializableHashtable() throws Exception {
        Log.info("15.Serializing Hashtable with Serialized Elements");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(baos);
        ComplexSerializer.serializeHashTable(dout,serializableHt);
        
        //Building Expected result
        ByteArrayOutputStream expectedBaos = new ByteArrayOutputStream();
        DataOutputStream expectedDout = new DataOutputStream(expectedBaos);
        
        //Building Expected result
        //expectedDout.writeByte(VECTOR);
        expectedDout.writeInt(serializableHt.size());
        
        //Writes all the elements of the Vector to expectedDout
        expectedDout.writeByte(SERIALIZED);
        expectedDout.writeUTF((new SerializeMe()).getClass().getName());
        expectedDout.writeUTF("Serializing me");
        expectedDout.writeByte(SERIALIZED);
        expectedDout.writeUTF((new SerializeMe()).getClass().getName());
        expectedDout.writeUTF("Serializing me");
        
        //Assert true if baos is equal to expectedBaos
        serializableHtStream = compareStream(baos, expectedBaos);
        Log.info("15.Serializing Hashtable with Serialized Elements");
    }
    
    private void deserializeSerializableHashtable() throws Exception{
        Log.info("16.Deserializing Hashtable with Serialized Elements");
        ByteArrayInputStream bais = new ByteArrayInputStream(serializableHtStream);
        DataInputStream din = new DataInputStream(bais);
        
        Hashtable actual = new Hashtable();
        actual = (Hashtable) ComplexSerializer.deserializeHashTable(din);
        assertTrue(actual.size()==1);
        
        Log.info(actual.toString());
        Log.info("16.Deserializing Hashtable with Serialized Elements " +
                                                                  "succesfull");
    }

}