| /*
|
| * Copyright 1999-2011 Alibaba Group.
|
| *
|
| * Licensed under the Apache License, Version 2.0 (the "License");
|
| * you may not use this file except in compliance with the License.
|
| * You may obtain a copy of the License at
|
| *
|
| * http://www.apache.org/licenses/LICENSE-2.0
|
| *
|
| * Unless required by applicable law or agreed to in writing, software
|
| * distributed under the License is distributed on an "AS IS" BASIS,
|
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| * See the License for the specific language governing permissions and
|
| * limitations under the License.
|
| */
|
| package com.alibaba.dubbo.common.serialize.serialization; |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.sql.Time; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Random; |
| import java.util.Set; |
| |
| import org.junit.Test; |
| |
| import com.alibaba.dubbo.common.URL; |
| import com.alibaba.dubbo.common.model.AnimalEnum; |
| import com.alibaba.dubbo.common.model.BizException; |
| import com.alibaba.dubbo.common.model.BizExceptionNoDefaultConstructor; |
| import com.alibaba.dubbo.common.model.SerializablePerson; |
| import com.alibaba.dubbo.common.model.media.Image; |
| import com.alibaba.dubbo.common.model.media.Image.Size; |
| import com.alibaba.dubbo.common.model.media.Media; |
| import com.alibaba.dubbo.common.model.media.Media.Player; |
| import com.alibaba.dubbo.common.model.media.MediaContent; |
| import com.alibaba.dubbo.common.model.person.BigPerson; |
| import com.alibaba.dubbo.common.model.person.FullAddress; |
| import com.alibaba.dubbo.common.model.person.PersonInfo; |
| import com.alibaba.dubbo.common.model.person.PersonStatus; |
| import com.alibaba.dubbo.common.model.person.Phone; |
| import com.alibaba.dubbo.common.serialize.ObjectInput; |
| import com.alibaba.dubbo.common.serialize.ObjectOutput; |
| import com.alibaba.dubbo.common.serialize.Serialization; |
| |
| /** |
| * @author ding.lid |
| */ |
| public abstract class AbstractSerializationTest { |
| Serialization serialization; |
| |
| URL url = new URL("protocl", "1.1.1.1", 1234); |
| ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); |
| |
| static Random random = new Random(); |
| |
| // ================ Primitive Type ================ |
| |
| @Test |
| public void test_Bool() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeBool(false); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertFalse(deserialize.readBool()); |
| |
| try { |
| deserialize.readBool(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Bool_Multi() throws Exception { |
| boolean[] array = new boolean[100]; |
| for (int i = 0; i < array.length; i++) { |
| array[i] = random.nextBoolean(); |
| } |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| for (boolean b : array) { |
| objectOutput.writeBool(b); |
| } |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| for (boolean b : array) { |
| assertEquals(b, deserialize.readBool()); |
| } |
| |
| try { |
| deserialize.readBool(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Byte() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeByte((byte) 123); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals((byte) 123, deserialize.readByte()); |
| |
| try { |
| deserialize.readByte(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Byte_Multi() throws Exception { |
| byte[] array = new byte[100]; |
| random.nextBytes(array); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| for (byte b : array) { |
| objectOutput.writeByte(b); |
| } |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| for (byte b : array) { |
| assertEquals(b, deserialize.readByte()); |
| } |
| |
| try { |
| deserialize.readByte(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Short() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeShort((short) 123); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals((short) 123, deserialize.readShort()); |
| |
| try { |
| deserialize.readShort(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Integer() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeInt(1); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| int i = deserialize.readInt(); |
| assertEquals(1, i); |
| |
| try { |
| deserialize.readInt(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Long() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeLong(123L); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals(123L, deserialize.readLong()); |
| |
| try { |
| deserialize.readLong(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Float() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeFloat(1.28F); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertTrue(1.28F == deserialize.readFloat()); |
| |
| try { |
| deserialize.readFloat(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Double() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeDouble(1.28); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertTrue(1.28 == deserialize.readDouble()); |
| |
| try { |
| deserialize.readDouble(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_UtfString() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeUTF("123中华人民共和国"); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals("123中华人民共和国", deserialize.readUTF()); |
| |
| try { |
| deserialize.readUTF(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_Bytes() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeBytes("123中华人民共和国".getBytes()); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals("123中华人民共和国".getBytes(), deserialize.readBytes()); |
| |
| try { |
| deserialize.readBytes(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_BytesRange() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeBytes("123中华人民共和国-新疆维吾尔自治区".getBytes(), 1, 9); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| byte[] expectedArray = new byte[9]; |
| System.arraycopy("123中华人民共和国-新疆维吾尔自治区".getBytes(), 1, expectedArray, 0, expectedArray.length); |
| assertArrayEquals(expectedArray, deserialize.readBytes()); |
| |
| try { |
| deserialize.readBytes(); |
| fail(); |
| } catch (IOException expected) {} |
| } |
| |
| // ================== Util methods ================== |
| |
| <T> void assertObjectArray(T[] data, Class<T[]> clazz) throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, clazz.cast(deserialize.readObject())); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| <T> void assertObjectArrayWithType(T[] data, Class<T[]> clazz) throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, clazz.cast(deserialize.readObject(clazz))); |
| |
| try { |
| deserialize.readObject(clazz); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| <T> void assertObject(T data) throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals(data, (T) deserialize.readObject()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| <T> void assertObjectWithType(T data, Class<T> clazz) throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals(data, (T) deserialize.readObject(clazz)); |
| |
| try { |
| deserialize.readObject(clazz); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| // ================ Array Type ================ |
| |
| @Test |
| public void test_boolArray() throws Exception { |
| boolean[] data = new boolean[] { true, false, true}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertTrue(Arrays.equals(data, (boolean[]) deserialize.readObject())); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_boolArray_withType() throws Exception { |
| boolean[] data = new boolean[] { true, false, true}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertTrue(Arrays.equals(data, (boolean[]) deserialize.readObject(boolean[].class))); |
| |
| try { |
| deserialize.readObject(boolean[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_charArray() throws Exception { |
| char[] data = new char[] { 'a', '中', '无' }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (char[]) deserialize.readObject()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_charArray_withType() throws Exception { |
| char[] data = new char[] { 'a', '中', '无' }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (char[]) deserialize.readObject(char[].class)); |
| |
| try { |
| deserialize.readObject(char[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_shortArray() throws Exception { |
| short[] data = new short[] { 37, 39, 12 }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (short[]) deserialize.readObject()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_shortArray_withType() throws Exception { |
| short[] data = new short[] { 37, 39, 12 }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (short[]) deserialize.readObject(short[].class)); |
| |
| try { |
| deserialize.readObject(short[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_intArray() throws Exception { |
| int[] data = new int[] { 234, 0, -1}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (int[]) deserialize.readObject()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_intArray_withType() throws Exception { |
| int[] data = new int[] { 234, 0, -1}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (int[]) deserialize.readObject(int[].class)); |
| |
| try { |
| deserialize.readObject(int[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_longArray() throws Exception { |
| long[] data = new long[] { 234, 0, -1}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (long[]) deserialize.readObject()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_longArray_withType() throws Exception { |
| long[] data = new long[] { 234, 0, -1}; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (long[]) deserialize.readObject(long[].class)); |
| |
| try { |
| deserialize.readObject(long[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_floatArray() throws Exception { |
| float[] data = new float[] { 37F, -3.14F, 123456.7F }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (float[]) deserialize.readObject(), 0.0001F); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_floatArray_withType() throws Exception { |
| float[] data = new float[] { 37F, -3.14F, 123456.7F }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (float[]) deserialize.readObject(float[].class), 0.0001F); |
| |
| try { |
| deserialize.readObject(float[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_doubleArray() throws Exception { |
| double[] data = new double[] { 37D, -3.14D, 123456.7D }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (double[]) deserialize.readObject(), 0.0001); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_doubleArray_withType() throws Exception { |
| double[] data = new double[] { 37D, -3.14D, 123456.7D }; |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertArrayEquals(data, (double[]) deserialize.readObject(double[].class), 0.0001); |
| |
| try { |
| deserialize.readObject(double[].class); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_StringArray() throws Exception { |
| assertObjectArray(new String[] { "1", "b" }, String[].class); |
| } |
| |
| @Test |
| public void test_StringArray_withType() throws Exception { |
| assertObjectArrayWithType(new String[] { "1", "b" }, String[].class); |
| } |
| |
| @Test |
| public void test_IntegerArray() throws Exception { |
| assertObjectArray(new Integer[] { 234, 0, -1}, Integer[].class); |
| } |
| |
| @Test |
| public void test_IntegerArray_withType() throws Exception { |
| assertObjectArrayWithType(new Integer[] { 234, 0, -1}, Integer[].class); |
| } |
| |
| @Test |
| public void test_EnumArray() throws Exception { |
| assertObjectArray(new AnimalEnum[] { AnimalEnum.bull, AnimalEnum.cat, AnimalEnum.dog, AnimalEnum.horse}, AnimalEnum[].class); |
| } |
| |
| @Test |
| public void test_EnumArray_withType() throws Exception { |
| assertObjectArrayWithType(new AnimalEnum[] { AnimalEnum.bull, AnimalEnum.cat, AnimalEnum.dog, AnimalEnum.horse}, AnimalEnum[].class); |
| } |
| |
| // ================ Simple Type ================ |
| |
| @Test |
| public void test_SPerson() throws Exception { |
| assertObject(new SerializablePerson()); |
| } |
| |
| @Test |
| public void test_SPerson_withType() throws Exception { |
| assertObjectWithType(new SerializablePerson(), SerializablePerson.class); |
| } |
| |
| @Test |
| public void test_BizException() throws Exception { |
| BizException e = new BizException("Hello"); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(e); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| Object read = deserialize.readObject(); |
| assertEquals("Hello", ((BizException) read).getMessage()); |
| } |
| |
| @Test |
| public void test_BizException_WithType() throws Exception { |
| BizException e = new BizException("Hello"); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(e); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| Object read = deserialize.readObject(BizException.class); |
| assertEquals("Hello", ((BizException) read).getMessage()); |
| } |
| |
| @Test |
| public void test_BizExceptionNoDefaultConstructor() throws Exception { |
| BizExceptionNoDefaultConstructor e = new BizExceptionNoDefaultConstructor("Hello"); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(e); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| Object read = deserialize.readObject(); |
| assertEquals("Hello", ((BizExceptionNoDefaultConstructor) read).getMessage()); |
| } |
| |
| @Test |
| public void test_BizExceptionNoDefaultConstructor_WithType() throws Exception { |
| BizExceptionNoDefaultConstructor e = new BizExceptionNoDefaultConstructor("Hello"); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(e); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| Object read = deserialize.readObject(BizExceptionNoDefaultConstructor.class); |
| assertEquals("Hello", ((BizExceptionNoDefaultConstructor) read).getMessage()); |
| } |
| |
| @Test |
| public void test_enum() throws Exception { |
| assertObject(AnimalEnum.dog); |
| } |
| |
| @Test |
| public void test_enum_withType() throws Exception { |
| assertObjectWithType(AnimalEnum.dog, AnimalEnum.class); |
| } |
| |
| @Test |
| public void test_Date() throws Exception { |
| assertObject(new Date()); |
| } |
| |
| @Test |
| public void test_Date_withType() throws Exception { |
| assertObjectWithType(new Date(), Date.class); |
| } |
| |
| @Test |
| public void test_Time() throws Exception { |
| assertObject(new Time(System.currentTimeMillis())); |
| } |
| |
| @Test |
| public void test_Time_withType() throws Exception { |
| assertObjectWithType(new Time(System.currentTimeMillis()), Time.class); |
| } |
| |
| @Test |
| public void test_ByteWrap() throws Exception { |
| assertObject(new Byte((byte) 12)); |
| } |
| |
| @Test |
| public void test_ByteWrap_withType() throws Exception { |
| assertObjectWithType(new Byte((byte) 12), Byte.class); |
| } |
| |
| @Test |
| public void test_LongWrap() throws Exception { |
| assertObject(new Long(12)); |
| } |
| |
| @Test |
| public void test_LongWrap_withType() throws Exception { |
| assertObjectWithType(new Long(12), Long.class); |
| } |
| |
| @Test |
| public void test_BigInteger() throws Exception { |
| assertObject(new BigInteger("23423434234234234")); |
| } |
| |
| @Test |
| public void test_BigInteger_withType() throws Exception { |
| assertObjectWithType(new BigInteger("23423434234234234"), BigInteger.class); |
| } |
| |
| @Test |
| public void test_BigDecimal() throws Exception { |
| assertObject(new BigDecimal("23423434234234234.341274832341234235")); |
| } |
| |
| @Test |
| public void test_BigDecimal_withType() throws Exception { |
| assertObjectWithType(new BigDecimal("23423434234234234.341274832341234235"), BigDecimal.class); |
| } |
| |
| @Test |
| public void test_StringList_asListReturn() throws Exception { |
| List<String> args = Arrays.asList(new String[] { "1", "b" }); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_StringArrayList() throws Exception { |
| List<String> args = new ArrayList<String>(Arrays.asList(new String[] { "1", "b" })); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_StringSet() throws Exception { |
| Set<String> args = new HashSet<String>(); |
| args.add("1"); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_LinkedHashMap() throws Exception { |
| LinkedHashMap<String, String> data = new LinkedHashMap<String, String>(); |
| data.put("1", "a"); |
| data.put("2", "b"); |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(data); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| Object read = deserialize.readObject(); |
| assertTrue(read instanceof LinkedHashMap); |
| @SuppressWarnings("unchecked") |
| String key1 = ((LinkedHashMap<String, String>)read).entrySet().iterator().next().getKey(); |
| assertEquals("1", key1); |
| |
| assertEquals(data, read); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_SPersonList() throws Exception { |
| List<SerializablePerson> args = new ArrayList<SerializablePerson>(); |
| args.add(new SerializablePerson()); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_SPersonSet() throws Exception { |
| Set<SerializablePerson> args = new HashSet<SerializablePerson>(); |
| args.add(new SerializablePerson()); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_IntSPersonMap() throws Exception { |
| Map<Integer, SerializablePerson> args = new HashMap<Integer, SerializablePerson>(); |
| args.put(1, new SerializablePerson()); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_StringSPersonMap() throws Exception { |
| Map<String, SerializablePerson> args = new HashMap<String, SerializablePerson>(); |
| args.put("1", new SerializablePerson()); |
| |
| assertObject(args); |
| } |
| |
| // ================ Complex Collection Type ================ |
| |
| @Test |
| public void test_StringSPersonListMap() throws Exception { |
| Map<String, List<SerializablePerson>> args = new HashMap<String, List<SerializablePerson>>(); |
| |
| List<SerializablePerson> sublist = new ArrayList<SerializablePerson>(); |
| sublist.add(new SerializablePerson()); |
| args.put("1", sublist); |
| |
| assertObject(args); |
| } |
| |
| @Test |
| public void test_SPersonListList() throws Exception { |
| List<List<SerializablePerson>> args = new ArrayList<List<SerializablePerson>>(); |
| List<SerializablePerson> sublist = new ArrayList<SerializablePerson>(); |
| sublist.add(new SerializablePerson()); |
| args.add(sublist); |
| |
| assertObject(args); |
| } |
| |
| // ================ complex POJO ============= |
| |
| BigPerson bigPerson; |
| { |
| bigPerson = new BigPerson(); |
| bigPerson.setPersonId("superman111"); |
| bigPerson.setLoginName("superman"); |
| bigPerson.setStatus(PersonStatus.ENABLED); |
| bigPerson.setEmail("sm@1.com"); |
| bigPerson.setPenName("pname"); |
| |
| ArrayList<Phone> phones = new ArrayList<Phone>(); |
| Phone phone1 = new Phone("86", "0571", "87654321", "001"); |
| Phone phone2 = new Phone("86", "0571", "87654322", "002"); |
| phones.add(phone1); |
| phones.add(phone2); |
| |
| PersonInfo pi = new PersonInfo(); |
| pi.setPhones(phones); |
| Phone fax = new Phone("86", "0571", "87654321", null); |
| pi.setFax(fax); |
| FullAddress addr = new FullAddress("CN", "zj", "3480", "wensanlu", "315000"); |
| pi.setFullAddress(addr); |
| pi.setMobileNo("13584652131"); |
| pi.setMale(true); |
| pi.setDepartment("b2b"); |
| pi.setHomepageUrl("www.capcom.com"); |
| pi.setJobTitle("qa"); |
| pi.setName("superman"); |
| |
| bigPerson.setInfoProfile(pi); |
| } |
| |
| @Test |
| public void test_BigPerson() throws Exception { |
| assertObject(bigPerson); |
| } |
| |
| @Test |
| public void test_BigPerson_WithType() throws Exception { |
| assertObjectWithType(bigPerson, BigPerson.class); |
| } |
| |
| MediaContent mediaContent; |
| { |
| Media media = new Media(); |
| media.setUri("uri://中华人民共和国"); |
| media.setTitle("title"); |
| media.setWidth(1239); |
| media.setHeight(1938); |
| media.setFormat("format-xxxx"); |
| media.setDuration(93419235); |
| media.setSize(3477897); |
| media.setBitrate(94523); |
| List<String> persons = new ArrayList<String>(); |
| persons.add("jerry"); |
| persons.add("tom"); |
| persons.add("lucy"); |
| media.setPersons(persons); |
| media.setCopyright("1999-2011"); |
| media.setPlayer(Player.FLASH); |
| |
| List<Image> images = new ArrayList<Image>(); |
| for(int i = 0; i < 10; ++i) { |
| Image image = new Image(); |
| image.setUri("url" + i); |
| if(i % 2 == 0) image.setTitle("title" + i); |
| image.setWidth(34 + i); |
| image.setHeight(2323 + i); |
| image.setSize((i % 2 == 0) ? Size.SMALL : Size.LARGE); |
| |
| images.add(image); |
| } |
| |
| mediaContent = new MediaContent(media, images); |
| } |
| |
| @Test |
| public void test_MediaContent() throws Exception { |
| assertObject(mediaContent); |
| } |
| |
| @Test |
| public void test_MediaContent_WithType() throws Exception { |
| assertObjectWithType(mediaContent, MediaContent.class); |
| } |
| |
| @Test |
| public void test_MultiObject() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeBool(false); |
| objectOutput.writeObject(bigPerson); |
| objectOutput.writeByte((byte) 23); |
| objectOutput.writeObject(mediaContent); |
| objectOutput.writeInt(-23); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals(false, deserialize.readBool()); |
| assertEquals(bigPerson, deserialize.readObject()); |
| assertEquals((byte) 23, deserialize.readByte()); |
| assertEquals(mediaContent, deserialize.readObject()); |
| assertEquals(-23, deserialize.readInt()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| @Test |
| public void test_MultiObject_WithType() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeBool(false); |
| objectOutput.writeObject(bigPerson); |
| objectOutput.writeByte((byte) 23); |
| objectOutput.writeObject(mediaContent); |
| objectOutput.writeInt(-23); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| |
| assertEquals(false, deserialize.readBool()); |
| assertEquals(bigPerson, deserialize.readObject(BigPerson.class)); |
| assertEquals((byte) 23, deserialize.readByte()); |
| assertEquals(mediaContent, deserialize.readObject(MediaContent.class)); |
| assertEquals(-23, deserialize.readInt()); |
| |
| try { |
| deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| } |
| } |
| |
| |
| // abnormal case |
| |
| @Test |
| public void test_MediaContent_badStream() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(mediaContent); |
| objectOutput.flushBuffer(); |
| |
| byte[] byteArray = byteArrayOutputStream.toByteArray(); |
| for (int i = 0; i < byteArray.length; i++) { |
| if(i%3 == 0) { |
| byteArray[i] = (byte)~byteArray[i]; |
| } |
| } |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray); |
| |
| try { |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| @SuppressWarnings("unused") // local variable, convenient for debug |
| Object read = deserialize.readObject(); |
| fail(); |
| } catch (IOException expected) { |
| System.out.println(expected); |
| } |
| } |
| |
| @Test |
| public void test_MediaContent_WithType_badStream() throws Exception { |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(mediaContent); |
| objectOutput.flushBuffer(); |
| |
| byte[] byteArray = byteArrayOutputStream.toByteArray(); |
| for (int i = 0; i < byteArray.length; i++) { |
| if(i%3 == 0) { |
| byteArray[i] = (byte)~byteArray[i]; |
| } |
| } |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray); |
| |
| try { |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| @SuppressWarnings("unused") // local variable, convenient for debug |
| Object read = deserialize.readObject(MediaContent.class); |
| fail(); |
| } catch (IOException expected) { |
| System.out.println(expected); |
| } |
| } |
| |
| |
| @Test(timeout=3000) |
| public void test_LoopReference() throws Exception { |
| Map<String, Object> map= new HashMap<String, Object>(); |
| map.put("k1", "v1"); |
| map.put("self", map); |
| |
| |
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); |
| objectOutput.writeObject(map); |
| objectOutput.flushBuffer(); |
| |
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream( |
| byteArrayOutputStream.toByteArray()); |
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream); |
| @SuppressWarnings("unchecked") |
| Map<String, Object> output = (Map<String, Object>) deserialize.readObject(); |
| |
| assertEquals("v1", output.get("k1")); |
| assertSame(output, output.get("self")); |
| }
|
|
|
| // ================ final field test ================
|
|
|
| @Test
|
| public void test_URL_mutable_withType() throws Exception {
|
| URL data = URL.valueOf("dubbo://admin:hello1234@10.20.130.230:20880/context/path?version=1.0.0&application=morgan&noValue");
|
|
|
| ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream);
|
| objectOutput.writeObject(data);
|
| objectOutput.flushBuffer();
|
|
|
| ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
|
| byteArrayOutputStream.toByteArray());
|
| ObjectInput deserialize = serialization.deserialize(url, byteArrayInputStream);
|
|
|
| URL actual = (URL) deserialize.readObject(URL.class);
|
| assertEquals(data, actual);
|
| assertEquals(data.getParameters(), actual.getParameters());
|
|
|
| try {
|
| deserialize.readObject();
|
| fail();
|
| } catch (IOException expected) {
|
| }
|
| }
|
| } |
