From e3bf8a404b993da62676d1d435e49a37c404fe3b Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 19:32:45 +0900 Subject: [PATCH 1/7] java: adds MessagePack class --- .../main/java/org/msgpack/MessagePack.java | 123 ++++++++++++++++++ java/src/main/java/org/msgpack/Unpacker.java | 5 +- .../msgpack/TestMessagePackStaticMethods.java | 121 +++++++++++++++++ 3 files changed, 247 insertions(+), 2 deletions(-) create mode 100644 java/src/main/java/org/msgpack/MessagePack.java create mode 100644 java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java diff --git a/java/src/main/java/org/msgpack/MessagePack.java b/java/src/main/java/org/msgpack/MessagePack.java new file mode 100644 index 00000000..f9dcce86 --- /dev/null +++ b/java/src/main/java/org/msgpack/MessagePack.java @@ -0,0 +1,123 @@ +// +// MessagePack for Java +// +// Copyright (C) 2009-2010 FURUHASHI Sadayuki +// +// 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 org.msgpack; + +import java.io.OutputStream; +import java.io.InputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; + +public class MessagePack { + public static byte[] pack(Object obj) { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try { + new Packer(out).pack(obj); + } catch (IOException e) { + throw new RuntimeException(e); + } + return out.toByteArray(); + } + + public static void pack(OutputStream out, Object obj) throws IOException { + new Packer(out).pack(obj); + } + + public static byte[] pack(Object obj, Template tmpl) throws MessageTypeException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try { + new Packer(out).pack(obj, tmpl); + } catch (IOException e) { + throw new RuntimeException(e); + } + return out.toByteArray(); + } + + public static void pack(OutputStream out, Object obj, Template tmpl) throws IOException { + new Packer(out).pack(obj, tmpl); + } + + + public static MessagePackObject unpack(byte[] buffer) throws IOException { + Unpacker pac = new Unpacker(); + pac.wrap(buffer); + try { + return pac.unpackObject(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static Object unpack(byte[] buffer, Template tmpl) throws MessageTypeException { + Unpacker pac = new Unpacker(); + pac.wrap(buffer); + try { + return pac.unpack(tmpl); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static T unpack(byte[] buffer, Class klass) throws MessageTypeException { + Unpacker pac = new Unpacker(); + pac.wrap(buffer); + try { + return pac.unpack(klass); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static MessagePackObject unpack(InputStream in) { + Unpacker pac = new Unpacker(in); + try { + return pac.unpackObject(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static Object unpack(InputStream in, Template tmpl) throws IOException, MessageTypeException { + Unpacker pac = new Unpacker(in); + try { + return pac.unpack(tmpl); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static T unpack(InputStream in, Class klass) throws IOException, MessageTypeException { + Unpacker pac = new Unpacker(in); + try { + return pac.unpack(klass); + } catch (IOException e) { + throw new RuntimeException(e); + } + + } + + //public static void register(Class target); // TODO: auto-detect + + //public static void register(Class target, Template tmpl); // TODO + + //public static void registerPacker(Class target, MessagePacker packer); // TODO + + //public static void registerConverter(Class target, MessageConverter converter); // TODO + + //public static void registerUnpacker(Class target, MessageUnpacker unpacker); // TODO +} + diff --git a/java/src/main/java/org/msgpack/Unpacker.java b/java/src/main/java/org/msgpack/Unpacker.java index e458b62b..d07de1ec 100644 --- a/java/src/main/java/org/msgpack/Unpacker.java +++ b/java/src/main/java/org/msgpack/Unpacker.java @@ -580,8 +580,9 @@ public class Unpacker implements Iterable { return tmpl.unpack(this); } - final public Object unpack(Class klass) throws IOException, MessageTypeException, InstantiationException, IllegalAccessException { - return unpack(Templates.tClass(klass)); + final public T unpack(Class klass) throws IOException, MessageTypeException { + // FIXME optional? + return (T)unpack(Templates.tOptional(Templates.tClass(klass))); } } diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java new file mode 100644 index 00000000..dea2a371 --- /dev/null +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -0,0 +1,121 @@ +package org.msgpack; + +import org.msgpack.*; +import org.msgpack.object.*; +import static org.msgpack.Templates.*; + +import java.io.*; +import java.util.*; +import java.math.BigInteger; + +import org.junit.Test; +import junit.framework.TestCase; + +public class TestMessagePackStaticMethods extends TestCase { + @Test + public void testPackToByteArray() throws Exception { + byte[] a = MessagePack.pack("msgpack"); + byte[] b = MessagePack.pack((Object)1); + byte[] c = MessagePack.pack((Object)null); + + { + MessagePackObject aobj = MessagePack.unpack(a); + MessagePackObject bobj = MessagePack.unpack(b); + MessagePackObject cobj = MessagePack.unpack(c); + + assertEquals(aobj, RawType.create("msgpack")); + assertEquals(bobj, IntegerType.create(1)); + assertEquals(cobj, NilType.create()); + } + } + + @Test + public void testPackToStream() throws Exception { + ByteArrayOutputStream aout = new ByteArrayOutputStream(); + MessagePack.pack(aout, "msgpack"); + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + MessagePack.pack(bout, (Object)1); + ByteArrayOutputStream cout = new ByteArrayOutputStream(); + MessagePack.pack(cout, (Object)null); + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + MessagePackObject aobj = MessagePack.unpack(ain); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + MessagePackObject bobj = MessagePack.unpack(bin); + InputStream cin = new ByteArrayInputStream(cout.toByteArray()); + MessagePackObject cobj = MessagePack.unpack(cin); + + assertEquals(aobj, RawType.create("msgpack")); + assertEquals(bobj, IntegerType.create(1)); + assertEquals(cobj, NilType.create()); + } + } + + @Test + public void testCheckedPackToByteArray() throws Exception { + byte[] a = MessagePack.pack("msgpack", TString); + byte[] b = MessagePack.pack((Object)1, TInteger); + byte[] c = MessagePack.pack((Object)null, TAny); + + { + Object aobj = MessagePack.unpack(a, TString); + Object bobj = MessagePack.unpack(b, TInteger); + Object cobj_any = MessagePack.unpack(c, TAny); + Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); + assertEquals(aobj, "msgpack"); + assertEquals(bobj, 1); + assertEquals(cobj_any, NilType.create()); + assertEquals(cobj_obj, null); + } + + { + String aobj = MessagePack.unpack(a, String.class); + Integer bobj = MessagePack.unpack(b, Integer.class); + Object cobj = MessagePack.unpack(c, Object.class); + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + } + } + + @Test + public void testCheckedPackToStream() throws Exception { + ByteArrayOutputStream aout = new ByteArrayOutputStream(); + MessagePack.pack(aout, "msgpack"); + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + MessagePack.pack(bout, (Object)1); + ByteArrayOutputStream cout = new ByteArrayOutputStream(); + MessagePack.pack(cout, (Object)null); + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + Object aobj = MessagePack.unpack(ain, TString); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + Object bobj = MessagePack.unpack(bin, TInteger); + InputStream cin_any = new ByteArrayInputStream(cout.toByteArray()); + Object cobj_any = MessagePack.unpack(cin_any, TAny); + InputStream cin_obj = new ByteArrayInputStream(cout.toByteArray()); + Object cobj_obj = MessagePack.unpack(cin_obj, tOptional(TAny)); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, 1); + assertEquals(cobj_any, NilType.create()); + assertEquals(cobj_obj, null); + } + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + String aobj = MessagePack.unpack(ain, String.class); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + Integer bobj = MessagePack.unpack(bin, Integer.class); + InputStream cin = new ByteArrayInputStream(cout.toByteArray()); + Object cobj = MessagePack.unpack(cin, Object.class); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + } + } +} + From 19ff0dd17fee50f2ea18b6f941c9f7068260bcb7 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 20:11:39 +0900 Subject: [PATCH 2/7] java: fixes ListTemplate and MapTemplate --- .../org/msgpack/template/ListTemplate.java | 3 +- .../org/msgpack/template/MapTemplate.java | 3 +- .../msgpack/TestMessagePackStaticMethods.java | 32 +++++++++++++++++++ 3 files changed, 36 insertions(+), 2 deletions(-) diff --git a/java/src/main/java/org/msgpack/template/ListTemplate.java b/java/src/main/java/org/msgpack/template/ListTemplate.java index 6703df40..f15ae523 100644 --- a/java/src/main/java/org/msgpack/template/ListTemplate.java +++ b/java/src/main/java/org/msgpack/template/ListTemplate.java @@ -34,10 +34,11 @@ public class ListTemplate implements Template { } public void pack(Packer pk, Object target) throws IOException { - if(target instanceof List) { + if(!(target instanceof List)) { throw new MessageTypeException(); } List list = (List)target; + pk.packArray(list.size()); for(Object element : list) { elementTemplate.pack(pk, element); } diff --git a/java/src/main/java/org/msgpack/template/MapTemplate.java b/java/src/main/java/org/msgpack/template/MapTemplate.java index 6925982d..9b7b250f 100644 --- a/java/src/main/java/org/msgpack/template/MapTemplate.java +++ b/java/src/main/java/org/msgpack/template/MapTemplate.java @@ -40,10 +40,11 @@ public class MapTemplate implements Template { } public void pack(Packer pk, Object target) throws IOException { - if(target instanceof Map) { + if(!(target instanceof Map)) { throw new MessageTypeException(); } Map map = (Map)target; + pk.packMap(map.size()); for(Map.Entry pair : map.entrySet()) { keyTemplate.pack(pk, pair.getKey()); valueTemplate.pack(pk, pair.getValue()); diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java index dea2a371..b91615b3 100644 --- a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -17,15 +17,18 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] a = MessagePack.pack("msgpack"); byte[] b = MessagePack.pack((Object)1); byte[] c = MessagePack.pack((Object)null); + byte[] d = MessagePack.pack(createStringList()); { MessagePackObject aobj = MessagePack.unpack(a); MessagePackObject bobj = MessagePack.unpack(b); MessagePackObject cobj = MessagePack.unpack(c); + MessagePackObject dobj = MessagePack.unpack(d); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); + assertEquals(dobj, createStringList_dynamic()); } } @@ -37,6 +40,8 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePack.pack(bout, (Object)1); ByteArrayOutputStream cout = new ByteArrayOutputStream(); MessagePack.pack(cout, (Object)null); + ByteArrayOutputStream dout = new ByteArrayOutputStream(); + MessagePack.pack(dout, createStringList()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -45,10 +50,13 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePackObject bobj = MessagePack.unpack(bin); InputStream cin = new ByteArrayInputStream(cout.toByteArray()); MessagePackObject cobj = MessagePack.unpack(cin); + InputStream din = new ByteArrayInputStream(dout.toByteArray()); + MessagePackObject dobj = MessagePack.unpack(din); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); + assertEquals(dobj, createStringList_dynamic()); } } @@ -57,16 +65,19 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] a = MessagePack.pack("msgpack", TString); byte[] b = MessagePack.pack((Object)1, TInteger); byte[] c = MessagePack.pack((Object)null, TAny); + byte[] d = MessagePack.pack(createStringList(), tList(TString)); { Object aobj = MessagePack.unpack(a, TString); Object bobj = MessagePack.unpack(b, TInteger); Object cobj_any = MessagePack.unpack(c, TAny); Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); + Object dobj = MessagePack.unpack(d, tList(TString)); assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); + assertEquals(dobj, createStringList()); } { @@ -87,6 +98,8 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePack.pack(bout, (Object)1); ByteArrayOutputStream cout = new ByteArrayOutputStream(); MessagePack.pack(cout, (Object)null); + ByteArrayOutputStream dout = new ByteArrayOutputStream(); + MessagePack.pack(dout, createStringList()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -97,11 +110,14 @@ public class TestMessagePackStaticMethods extends TestCase { Object cobj_any = MessagePack.unpack(cin_any, TAny); InputStream cin_obj = new ByteArrayInputStream(cout.toByteArray()); Object cobj_obj = MessagePack.unpack(cin_obj, tOptional(TAny)); + InputStream din = new ByteArrayInputStream(dout.toByteArray()); + Object dobj = MessagePack.unpack(din, tList(TString)); assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); + assertEquals(dobj, createStringList()); } { @@ -117,5 +133,21 @@ public class TestMessagePackStaticMethods extends TestCase { assertEquals(cobj, null); } } + + private List createStringList() { + List list = new ArrayList(); + list.add("frsyuki"); + list.add("kumofs"); + list.add("gem-compile"); + return list; + } + + private MessagePackObject createStringList_dynamic() { + MessagePackObject[] array = new MessagePackObject[3]; + array[0] = RawType.create("frsyuki"); + array[1] = RawType.create("kumofs"); + array[2] = RawType.create("gem-compile"); + return ArrayType.create(array); + } } From 0a345cb12bb77c7afc5b29cc4568f717e7862ff6 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 20:16:37 +0900 Subject: [PATCH 3/7] java: fixes CollectionTemplate --- .../src/main/java/org/msgpack/template/CollectionTemplate.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/java/src/main/java/org/msgpack/template/CollectionTemplate.java b/java/src/main/java/org/msgpack/template/CollectionTemplate.java index 0269d67d..50e6b13a 100644 --- a/java/src/main/java/org/msgpack/template/CollectionTemplate.java +++ b/java/src/main/java/org/msgpack/template/CollectionTemplate.java @@ -31,10 +31,11 @@ public class CollectionTemplate implements Template { } public void pack(Packer pk, Object target) throws IOException { - if(target instanceof Collection) { + if(!(target instanceof Collection)) { throw new MessageTypeException(); } Collection collection = (Collection)target; + pk.packArray(collection.size()); for(Object element : collection) { elementTemplate.pack(pk, element); } From 7ac4ad3e38d5537e83a36f2d9fb9a5ce872c0c57 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 20:46:22 +0900 Subject: [PATCH 4/7] java: adds MessagePack.register methods --- .../main/java/org/msgpack/MessagePack.java | 43 +++++++++-- .../msgpack/TestMessagePackStaticMethods.java | 73 +++++++++++++++++++ 2 files changed, 111 insertions(+), 5 deletions(-) diff --git a/java/src/main/java/org/msgpack/MessagePack.java b/java/src/main/java/org/msgpack/MessagePack.java index f9dcce86..449f8a09 100644 --- a/java/src/main/java/org/msgpack/MessagePack.java +++ b/java/src/main/java/org/msgpack/MessagePack.java @@ -21,6 +21,10 @@ import java.io.OutputStream; import java.io.InputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; +//import org.msgpack.util.codegen.DynamicTemplate; // FIXME +import org.msgpack.util.codegen.DynamicPacker; +import org.msgpack.util.codegen.DynamicConverter; +import org.msgpack.util.codegen.DynamicUnpacker; public class MessagePack { public static byte[] pack(Object obj) { @@ -110,14 +114,43 @@ public class MessagePack { } - //public static void register(Class target); // TODO: auto-detect + public static void register(Class target) { // auto-detect + // FIXME + //Template tmpl; + //if(List.isAssignableFrom(target)) { + //} else if(Set.isAssignableFrom(target)) { + //} else if(Map.isAssignableFrom(target)) { + //} else if(Collection.isAssignableFrom(target)) { + //} else if(BigInteger.isAssignableFrom(target)) { + //} else { + //} - //public static void register(Class target, Template tmpl); // TODO + // FIXME + //Template tmpl = DynamicTemplate.create(target); + //register(target, tmpl); - //public static void registerPacker(Class target, MessagePacker packer); // TODO + // FIXME + CustomPacker.register(target, DynamicPacker.create(target)); + CustomConverter.register(target, DynamicConverter.create(target)); + CustomUnpacker.register(target, DynamicUnpacker.create(target)); + } - //public static void registerConverter(Class target, MessageConverter converter); // TODO + public static void register(Class target, Template tmpl) { + CustomPacker.register(target, tmpl); + CustomConverter.register(target, tmpl); + CustomUnpacker.register(target, tmpl); + } - //public static void registerUnpacker(Class target, MessageUnpacker unpacker); // TODO + public static void registerPacker(Class target, MessagePacker packer) { + CustomPacker.register(target, packer); + } + + public static void registerConverter(Class target, MessageConverter converter) { + CustomConverter.register(target, converter); + } + + public static void registerUnpacker(Class target, MessageUnpacker unpacker) { + CustomUnpacker.register(target, unpacker); + } } diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java index b91615b3..f2aad15e 100644 --- a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -12,23 +12,51 @@ import org.junit.Test; import junit.framework.TestCase; public class TestMessagePackStaticMethods extends TestCase { + public static class CustomClass { + public boolean bool; + public String str; + public List list; + + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof CustomClass)) { + return false; + } + CustomClass o = (CustomClass)obj; + return bool == o.bool && str.equals(o.str) && list.equals(o.list); + } + + public String toString() { + return "CustomClass"; + } + } + + static { + MessagePack.register(CustomClass.class); + } + @Test public void testPackToByteArray() throws Exception { byte[] a = MessagePack.pack("msgpack"); byte[] b = MessagePack.pack((Object)1); byte[] c = MessagePack.pack((Object)null); byte[] d = MessagePack.pack(createStringList()); + byte[] e = MessagePack.pack(createCustomClass()); { MessagePackObject aobj = MessagePack.unpack(a); MessagePackObject bobj = MessagePack.unpack(b); MessagePackObject cobj = MessagePack.unpack(c); MessagePackObject dobj = MessagePack.unpack(d); + MessagePackObject eobj = MessagePack.unpack(e); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); assertEquals(dobj, createStringList_dynamic()); + assertEquals(eobj, createCustomClass_dynamic()); } } @@ -42,6 +70,8 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePack.pack(cout, (Object)null); ByteArrayOutputStream dout = new ByteArrayOutputStream(); MessagePack.pack(dout, createStringList()); + ByteArrayOutputStream eout = new ByteArrayOutputStream(); + MessagePack.pack(eout, createCustomClass()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -52,11 +82,14 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePackObject cobj = MessagePack.unpack(cin); InputStream din = new ByteArrayInputStream(dout.toByteArray()); MessagePackObject dobj = MessagePack.unpack(din); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + MessagePackObject eobj = MessagePack.unpack(ein); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); assertEquals(dobj, createStringList_dynamic()); + assertEquals(eobj, createCustomClass_dynamic()); } } @@ -66,6 +99,7 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] b = MessagePack.pack((Object)1, TInteger); byte[] c = MessagePack.pack((Object)null, TAny); byte[] d = MessagePack.pack(createStringList(), tList(TString)); + byte[] e = MessagePack.pack(createCustomClass(), tClass(CustomClass.class)); { Object aobj = MessagePack.unpack(a, TString); @@ -73,20 +107,26 @@ public class TestMessagePackStaticMethods extends TestCase { Object cobj_any = MessagePack.unpack(c, TAny); Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); Object dobj = MessagePack.unpack(d, tList(TString)); + Object eobj = MessagePack.unpack(e, tClass(CustomClass.class)); + assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); assertEquals(dobj, createStringList()); + assertEquals(eobj, createCustomClass()); } { String aobj = MessagePack.unpack(a, String.class); Integer bobj = MessagePack.unpack(b, Integer.class); Object cobj = MessagePack.unpack(c, Object.class); + CustomClass eobj = MessagePack.unpack(e, CustomClass.class); + assertEquals(aobj, "msgpack"); assertEquals(bobj, (Integer)1); assertEquals(cobj, null); + assertEquals(eobj, createCustomClass()); } } @@ -100,6 +140,8 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePack.pack(cout, (Object)null); ByteArrayOutputStream dout = new ByteArrayOutputStream(); MessagePack.pack(dout, createStringList()); + ByteArrayOutputStream eout = new ByteArrayOutputStream(); + MessagePack.pack(eout, createCustomClass()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -112,12 +154,15 @@ public class TestMessagePackStaticMethods extends TestCase { Object cobj_obj = MessagePack.unpack(cin_obj, tOptional(TAny)); InputStream din = new ByteArrayInputStream(dout.toByteArray()); Object dobj = MessagePack.unpack(din, tList(TString)); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + Object eobj = MessagePack.unpack(ein, tClass(CustomClass.class)); assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); assertEquals(dobj, createStringList()); + assertEquals(eobj, createCustomClass()); } { @@ -127,13 +172,17 @@ public class TestMessagePackStaticMethods extends TestCase { Integer bobj = MessagePack.unpack(bin, Integer.class); InputStream cin = new ByteArrayInputStream(cout.toByteArray()); Object cobj = MessagePack.unpack(cin, Object.class); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + Object eobj = MessagePack.unpack(ein, CustomClass.class); assertEquals(aobj, "msgpack"); assertEquals(bobj, (Integer)1); assertEquals(cobj, null); + assertEquals(eobj, createCustomClass()); } } + private List createStringList() { List list = new ArrayList(); list.add("frsyuki"); @@ -149,5 +198,29 @@ public class TestMessagePackStaticMethods extends TestCase { array[2] = RawType.create("gem-compile"); return ArrayType.create(array); } + + + private CustomClass createCustomClass() { + CustomClass obj = new CustomClass(); + obj.bool = true; + obj.str = "viver"; + obj.list = new ArrayList(); + obj.list.add(1); + obj.list.add(2); + obj.list.add(3); + return obj; + } + + private MessagePackObject createCustomClass_dynamic() { + MessagePackObject[] obj = new MessagePackObject[3]; + obj[0] = BooleanType.create(true); + obj[1] = RawType.create("viver"); + MessagePackObject[] list = new MessagePackObject[3]; + list[0] = IntegerType.create(1); + list[1] = IntegerType.create(2); + list[2] = IntegerType.create(3); + obj[2] = ArrayType.create(list); + return ArrayType.create(obj); + } } From 1b3231e6174e3ea908a5fd3ae1437e43b1a2c320 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 20:59:19 +0900 Subject: [PATCH 5/7] java: improves test case of the MessagePack class --- .../msgpack/TestMessagePackStaticMethods.java | 114 ++++++++++++++---- 1 file changed, 92 insertions(+), 22 deletions(-) diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java index f2aad15e..5d979539 100644 --- a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -2,6 +2,7 @@ package org.msgpack; import org.msgpack.*; import org.msgpack.object.*; +import org.msgpack.annotation.*; import static org.msgpack.Templates.*; import java.io.*; @@ -12,7 +13,7 @@ import org.junit.Test; import junit.framework.TestCase; public class TestMessagePackStaticMethods extends TestCase { - public static class CustomClass { + public static class ProvidedClass { public boolean bool; public String str; public List list; @@ -21,20 +22,44 @@ public class TestMessagePackStaticMethods extends TestCase { if (obj == this) { return true; } - if (!(obj instanceof CustomClass)) { + if (!(obj instanceof ProvidedClass)) { return false; } - CustomClass o = (CustomClass)obj; + ProvidedClass o = (ProvidedClass)obj; return bool == o.bool && str.equals(o.str) && list.equals(o.list); } public String toString() { - return "CustomClass"; + return "ProvidedClass"; + } + } + + @MessagePackMessage + public static class UserDefinedClass { + public boolean bool; + public String str; + public List list; + + public boolean equals(Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof UserDefinedClass)) { + return false; + } + UserDefinedClass o = (UserDefinedClass)obj; + return bool == o.bool && str.equals(o.str) && list.equals(o.list); + } + + public String toString() { + return "UserDefinedClass"; } } static { - MessagePack.register(CustomClass.class); + // provided classes needs registration + MessagePack.register(ProvidedClass.class); + // annotated classes doesn't need registration } @Test @@ -43,7 +68,8 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] b = MessagePack.pack((Object)1); byte[] c = MessagePack.pack((Object)null); byte[] d = MessagePack.pack(createStringList()); - byte[] e = MessagePack.pack(createCustomClass()); + byte[] e = MessagePack.pack(createProvidedClass()); + byte[] f = MessagePack.pack(createUserDefinedClass_dynamic()); { MessagePackObject aobj = MessagePack.unpack(a); @@ -51,12 +77,14 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePackObject cobj = MessagePack.unpack(c); MessagePackObject dobj = MessagePack.unpack(d); MessagePackObject eobj = MessagePack.unpack(e); + MessagePackObject fobj = MessagePack.unpack(f); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); assertEquals(dobj, createStringList_dynamic()); - assertEquals(eobj, createCustomClass_dynamic()); + assertEquals(eobj, createProvidedClass_dynamic()); + assertEquals(fobj, createUserDefinedClass_dynamic()); } } @@ -71,7 +99,9 @@ public class TestMessagePackStaticMethods extends TestCase { ByteArrayOutputStream dout = new ByteArrayOutputStream(); MessagePack.pack(dout, createStringList()); ByteArrayOutputStream eout = new ByteArrayOutputStream(); - MessagePack.pack(eout, createCustomClass()); + MessagePack.pack(eout, createProvidedClass()); + ByteArrayOutputStream fout = new ByteArrayOutputStream(); + MessagePack.pack(fout, createUserDefinedClass()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -84,12 +114,15 @@ public class TestMessagePackStaticMethods extends TestCase { MessagePackObject dobj = MessagePack.unpack(din); InputStream ein = new ByteArrayInputStream(eout.toByteArray()); MessagePackObject eobj = MessagePack.unpack(ein); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + MessagePackObject fobj = MessagePack.unpack(fin); assertEquals(aobj, RawType.create("msgpack")); assertEquals(bobj, IntegerType.create(1)); assertEquals(cobj, NilType.create()); assertEquals(dobj, createStringList_dynamic()); - assertEquals(eobj, createCustomClass_dynamic()); + assertEquals(eobj, createProvidedClass_dynamic()); + assertEquals(fobj, createUserDefinedClass_dynamic()); } } @@ -99,7 +132,8 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] b = MessagePack.pack((Object)1, TInteger); byte[] c = MessagePack.pack((Object)null, TAny); byte[] d = MessagePack.pack(createStringList(), tList(TString)); - byte[] e = MessagePack.pack(createCustomClass(), tClass(CustomClass.class)); + byte[] e = MessagePack.pack(createProvidedClass(), tClass(ProvidedClass.class)); + byte[] f = MessagePack.pack(createUserDefinedClass(), tClass(UserDefinedClass.class)); { Object aobj = MessagePack.unpack(a, TString); @@ -107,26 +141,30 @@ public class TestMessagePackStaticMethods extends TestCase { Object cobj_any = MessagePack.unpack(c, TAny); Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); Object dobj = MessagePack.unpack(d, tList(TString)); - Object eobj = MessagePack.unpack(e, tClass(CustomClass.class)); + Object eobj = MessagePack.unpack(e, tClass(ProvidedClass.class)); + Object fobj = MessagePack.unpack(f, tClass(UserDefinedClass.class)); assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); assertEquals(dobj, createStringList()); - assertEquals(eobj, createCustomClass()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); } { String aobj = MessagePack.unpack(a, String.class); Integer bobj = MessagePack.unpack(b, Integer.class); Object cobj = MessagePack.unpack(c, Object.class); - CustomClass eobj = MessagePack.unpack(e, CustomClass.class); + ProvidedClass eobj = MessagePack.unpack(e, ProvidedClass.class); + UserDefinedClass fobj = MessagePack.unpack(f, UserDefinedClass.class); assertEquals(aobj, "msgpack"); assertEquals(bobj, (Integer)1); assertEquals(cobj, null); - assertEquals(eobj, createCustomClass()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); } } @@ -141,7 +179,9 @@ public class TestMessagePackStaticMethods extends TestCase { ByteArrayOutputStream dout = new ByteArrayOutputStream(); MessagePack.pack(dout, createStringList()); ByteArrayOutputStream eout = new ByteArrayOutputStream(); - MessagePack.pack(eout, createCustomClass()); + MessagePack.pack(eout, createProvidedClass()); + ByteArrayOutputStream fout = new ByteArrayOutputStream(); + MessagePack.pack(fout, createUserDefinedClass()); { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); @@ -155,14 +195,17 @@ public class TestMessagePackStaticMethods extends TestCase { InputStream din = new ByteArrayInputStream(dout.toByteArray()); Object dobj = MessagePack.unpack(din, tList(TString)); InputStream ein = new ByteArrayInputStream(eout.toByteArray()); - Object eobj = MessagePack.unpack(ein, tClass(CustomClass.class)); + Object eobj = MessagePack.unpack(ein, tClass(ProvidedClass.class)); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + Object fobj = MessagePack.unpack(fin, tClass(UserDefinedClass.class)); assertEquals(aobj, "msgpack"); assertEquals(bobj, 1); assertEquals(cobj_any, NilType.create()); assertEquals(cobj_obj, null); assertEquals(dobj, createStringList()); - assertEquals(eobj, createCustomClass()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); } { @@ -173,12 +216,15 @@ public class TestMessagePackStaticMethods extends TestCase { InputStream cin = new ByteArrayInputStream(cout.toByteArray()); Object cobj = MessagePack.unpack(cin, Object.class); InputStream ein = new ByteArrayInputStream(eout.toByteArray()); - Object eobj = MessagePack.unpack(ein, CustomClass.class); + ProvidedClass eobj = MessagePack.unpack(ein, ProvidedClass.class); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + UserDefinedClass fobj = MessagePack.unpack(fin, UserDefinedClass.class); assertEquals(aobj, "msgpack"); assertEquals(bobj, (Integer)1); assertEquals(cobj, null); - assertEquals(eobj, createCustomClass()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); } } @@ -200,8 +246,8 @@ public class TestMessagePackStaticMethods extends TestCase { } - private CustomClass createCustomClass() { - CustomClass obj = new CustomClass(); + private ProvidedClass createProvidedClass() { + ProvidedClass obj = new ProvidedClass(); obj.bool = true; obj.str = "viver"; obj.list = new ArrayList(); @@ -211,7 +257,7 @@ public class TestMessagePackStaticMethods extends TestCase { return obj; } - private MessagePackObject createCustomClass_dynamic() { + private MessagePackObject createProvidedClass_dynamic() { MessagePackObject[] obj = new MessagePackObject[3]; obj[0] = BooleanType.create(true); obj[1] = RawType.create("viver"); @@ -222,5 +268,29 @@ public class TestMessagePackStaticMethods extends TestCase { obj[2] = ArrayType.create(list); return ArrayType.create(obj); } + + + private UserDefinedClass createUserDefinedClass() { + UserDefinedClass obj = new UserDefinedClass(); + obj.bool = false; + obj.str = "muga"; + obj.list = new ArrayList(); + obj.list.add(9); + obj.list.add(10); + obj.list.add(11); + return obj; + } + + private MessagePackObject createUserDefinedClass_dynamic() { + MessagePackObject[] obj = new MessagePackObject[3]; + obj[0] = BooleanType.create(false); + obj[1] = RawType.create("muga"); + MessagePackObject[] list = new MessagePackObject[3]; + list[0] = IntegerType.create(9); + list[1] = IntegerType.create(10); + list[2] = IntegerType.create(11); + obj[2] = ArrayType.create(list); + return ArrayType.create(obj); + } } From 147056073d71a845fdbcd7562db344e9eb0c69c9 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 21:04:31 +0900 Subject: [PATCH 6/7] java: improves test case of the MessagePack class --- .../msgpack/TestMessagePackStaticMethods.java | 209 +++++++++--------- 1 file changed, 105 insertions(+), 104 deletions(-) diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java index 5d979539..e7b8d843 100644 --- a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -57,9 +57,112 @@ public class TestMessagePackStaticMethods extends TestCase { } static { - // provided classes needs registration + // provided classes need registration MessagePack.register(ProvidedClass.class); - // annotated classes doesn't need registration + // annotated classes don't need registration + } + + + @Test + public void testCheckedPackToByteArray() throws Exception { + byte[] a = MessagePack.pack("msgpack", TString); + byte[] b = MessagePack.pack((Object)1, TInteger); + byte[] c = MessagePack.pack((Object)null, TAny); + byte[] d = MessagePack.pack(createStringList(), tList(TString)); + byte[] e = MessagePack.pack(createProvidedClass(), tClass(ProvidedClass.class)); + byte[] f = MessagePack.pack(createUserDefinedClass(), tClass(UserDefinedClass.class)); + + { + String aobj = MessagePack.unpack(a, String.class); + Integer bobj = MessagePack.unpack(b, Integer.class); + Object cobj = MessagePack.unpack(c, Object.class); + ProvidedClass eobj = MessagePack.unpack(e, ProvidedClass.class); + UserDefinedClass fobj = MessagePack.unpack(f, UserDefinedClass.class); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } + + { + Object aobj = MessagePack.unpack(a, TString); + Object bobj = MessagePack.unpack(b, TInteger); + Object cobj_any = MessagePack.unpack(c, TAny); + Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); + Object dobj = MessagePack.unpack(d, tList(TString)); + Object eobj = MessagePack.unpack(e, tClass(ProvidedClass.class)); + Object fobj = MessagePack.unpack(f, tClass(UserDefinedClass.class)); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, 1); + assertEquals(cobj_any, NilType.create()); + assertEquals(cobj_obj, null); + assertEquals(dobj, createStringList()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } + } + + @Test + public void testCheckedPackToStream() throws Exception { + ByteArrayOutputStream aout = new ByteArrayOutputStream(); + MessagePack.pack(aout, "msgpack"); + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + MessagePack.pack(bout, (Object)1); + ByteArrayOutputStream cout = new ByteArrayOutputStream(); + MessagePack.pack(cout, (Object)null); + ByteArrayOutputStream dout = new ByteArrayOutputStream(); + MessagePack.pack(dout, createStringList()); + ByteArrayOutputStream eout = new ByteArrayOutputStream(); + MessagePack.pack(eout, createProvidedClass()); + ByteArrayOutputStream fout = new ByteArrayOutputStream(); + MessagePack.pack(fout, createUserDefinedClass()); + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + String aobj = MessagePack.unpack(ain, String.class); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + Integer bobj = MessagePack.unpack(bin, Integer.class); + InputStream cin = new ByteArrayInputStream(cout.toByteArray()); + Object cobj = MessagePack.unpack(cin, Object.class); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + ProvidedClass eobj = MessagePack.unpack(ein, ProvidedClass.class); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + UserDefinedClass fobj = MessagePack.unpack(fin, UserDefinedClass.class); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + Object aobj = MessagePack.unpack(ain, TString); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + Object bobj = MessagePack.unpack(bin, TInteger); + InputStream cin_any = new ByteArrayInputStream(cout.toByteArray()); + Object cobj_any = MessagePack.unpack(cin_any, TAny); + InputStream cin_obj = new ByteArrayInputStream(cout.toByteArray()); + Object cobj_obj = MessagePack.unpack(cin_obj, tOptional(TAny)); + InputStream din = new ByteArrayInputStream(dout.toByteArray()); + Object dobj = MessagePack.unpack(din, tList(TString)); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + Object eobj = MessagePack.unpack(ein, tClass(ProvidedClass.class)); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + Object fobj = MessagePack.unpack(fin, tClass(UserDefinedClass.class)); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, 1); + assertEquals(cobj_any, NilType.create()); + assertEquals(cobj_obj, null); + assertEquals(dobj, createStringList()); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } } @Test @@ -126,108 +229,6 @@ public class TestMessagePackStaticMethods extends TestCase { } } - @Test - public void testCheckedPackToByteArray() throws Exception { - byte[] a = MessagePack.pack("msgpack", TString); - byte[] b = MessagePack.pack((Object)1, TInteger); - byte[] c = MessagePack.pack((Object)null, TAny); - byte[] d = MessagePack.pack(createStringList(), tList(TString)); - byte[] e = MessagePack.pack(createProvidedClass(), tClass(ProvidedClass.class)); - byte[] f = MessagePack.pack(createUserDefinedClass(), tClass(UserDefinedClass.class)); - - { - Object aobj = MessagePack.unpack(a, TString); - Object bobj = MessagePack.unpack(b, TInteger); - Object cobj_any = MessagePack.unpack(c, TAny); - Object cobj_obj = MessagePack.unpack(c, tOptional(TAny)); - Object dobj = MessagePack.unpack(d, tList(TString)); - Object eobj = MessagePack.unpack(e, tClass(ProvidedClass.class)); - Object fobj = MessagePack.unpack(f, tClass(UserDefinedClass.class)); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, 1); - assertEquals(cobj_any, NilType.create()); - assertEquals(cobj_obj, null); - assertEquals(dobj, createStringList()); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - - { - String aobj = MessagePack.unpack(a, String.class); - Integer bobj = MessagePack.unpack(b, Integer.class); - Object cobj = MessagePack.unpack(c, Object.class); - ProvidedClass eobj = MessagePack.unpack(e, ProvidedClass.class); - UserDefinedClass fobj = MessagePack.unpack(f, UserDefinedClass.class); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, (Integer)1); - assertEquals(cobj, null); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - } - - @Test - public void testCheckedPackToStream() throws Exception { - ByteArrayOutputStream aout = new ByteArrayOutputStream(); - MessagePack.pack(aout, "msgpack"); - ByteArrayOutputStream bout = new ByteArrayOutputStream(); - MessagePack.pack(bout, (Object)1); - ByteArrayOutputStream cout = new ByteArrayOutputStream(); - MessagePack.pack(cout, (Object)null); - ByteArrayOutputStream dout = new ByteArrayOutputStream(); - MessagePack.pack(dout, createStringList()); - ByteArrayOutputStream eout = new ByteArrayOutputStream(); - MessagePack.pack(eout, createProvidedClass()); - ByteArrayOutputStream fout = new ByteArrayOutputStream(); - MessagePack.pack(fout, createUserDefinedClass()); - - { - InputStream ain = new ByteArrayInputStream(aout.toByteArray()); - Object aobj = MessagePack.unpack(ain, TString); - InputStream bin = new ByteArrayInputStream(bout.toByteArray()); - Object bobj = MessagePack.unpack(bin, TInteger); - InputStream cin_any = new ByteArrayInputStream(cout.toByteArray()); - Object cobj_any = MessagePack.unpack(cin_any, TAny); - InputStream cin_obj = new ByteArrayInputStream(cout.toByteArray()); - Object cobj_obj = MessagePack.unpack(cin_obj, tOptional(TAny)); - InputStream din = new ByteArrayInputStream(dout.toByteArray()); - Object dobj = MessagePack.unpack(din, tList(TString)); - InputStream ein = new ByteArrayInputStream(eout.toByteArray()); - Object eobj = MessagePack.unpack(ein, tClass(ProvidedClass.class)); - InputStream fin = new ByteArrayInputStream(fout.toByteArray()); - Object fobj = MessagePack.unpack(fin, tClass(UserDefinedClass.class)); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, 1); - assertEquals(cobj_any, NilType.create()); - assertEquals(cobj_obj, null); - assertEquals(dobj, createStringList()); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - - { - InputStream ain = new ByteArrayInputStream(aout.toByteArray()); - String aobj = MessagePack.unpack(ain, String.class); - InputStream bin = new ByteArrayInputStream(bout.toByteArray()); - Integer bobj = MessagePack.unpack(bin, Integer.class); - InputStream cin = new ByteArrayInputStream(cout.toByteArray()); - Object cobj = MessagePack.unpack(cin, Object.class); - InputStream ein = new ByteArrayInputStream(eout.toByteArray()); - ProvidedClass eobj = MessagePack.unpack(ein, ProvidedClass.class); - InputStream fin = new ByteArrayInputStream(fout.toByteArray()); - UserDefinedClass fobj = MessagePack.unpack(fin, UserDefinedClass.class); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, (Integer)1); - assertEquals(cobj, null); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - } - private List createStringList() { List list = new ArrayList(); From 1bd347d9970ba8d00b757ece940b8a32564821e4 Mon Sep 17 00:00:00 2001 From: frsyuki Date: Sun, 24 Oct 2010 21:17:19 +0900 Subject: [PATCH 7/7] java: fixes CustomMessage class --- .../main/java/org/msgpack/CustomMessage.java | 13 +++- .../org/msgpack/template/AnyTemplate.java | 2 +- .../msgpack/template/BigIntegerTemplate.java | 2 +- .../org/msgpack/template/BooleanTemplate.java | 2 +- .../msgpack/template/ByteArrayTemplate.java | 2 +- .../org/msgpack/template/ByteTemplate.java | 2 +- .../org/msgpack/template/DoubleTemplate.java | 2 +- .../org/msgpack/template/FloatTemplate.java | 2 +- .../org/msgpack/template/IntegerTemplate.java | 2 +- .../org/msgpack/template/LongTemplate.java | 2 +- .../org/msgpack/template/ShortTemplate.java | 2 +- .../org/msgpack/template/StringTemplate.java | 2 +- .../util/codegen/DynamicCodeGenBase.java | 6 +- .../msgpack/TestMessagePackStaticMethods.java | 66 +++++++++---------- 14 files changed, 58 insertions(+), 49 deletions(-) diff --git a/java/src/main/java/org/msgpack/CustomMessage.java b/java/src/main/java/org/msgpack/CustomMessage.java index 959c9cd5..832aa599 100644 --- a/java/src/main/java/org/msgpack/CustomMessage.java +++ b/java/src/main/java/org/msgpack/CustomMessage.java @@ -24,9 +24,18 @@ public class CustomMessage { CustomPacker.register(target, packer); } - public static void registerTemplate(Class target, Template tmpl) { - CustomUnpacker.register(target, tmpl); + public static void registerConverter(Class target, MessageConverter converter) { + CustomConverter.register(target, converter); + } + + public static void registerUnpacker(Class target, MessageUnpacker unpacker) { + CustomUnpacker.register(target, unpacker); + } + + public static void register(Class target, Template tmpl) { + CustomPacker.register(target, tmpl); CustomConverter.register(target, tmpl); + CustomUnpacker.register(target, tmpl); } public static boolean isAnnotated(Class target, Class with) { diff --git a/java/src/main/java/org/msgpack/template/AnyTemplate.java b/java/src/main/java/org/msgpack/template/AnyTemplate.java index fb2e1eee..91eab900 100644 --- a/java/src/main/java/org/msgpack/template/AnyTemplate.java +++ b/java/src/main/java/org/msgpack/template/AnyTemplate.java @@ -46,7 +46,7 @@ public class AnyTemplate implements Template { static final AnyTemplate instance = new AnyTemplate(); static { - CustomMessage.registerTemplate(MessagePackObject.class, instance); + CustomMessage.register(MessagePackObject.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java b/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java index 66e142b0..79b5c7dc 100644 --- a/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java +++ b/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java @@ -43,7 +43,7 @@ public class BigIntegerTemplate implements Template { static final BigIntegerTemplate instance = new BigIntegerTemplate(); static { - CustomMessage.registerTemplate(BigInteger.class, instance); + CustomMessage.register(BigInteger.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/BooleanTemplate.java b/java/src/main/java/org/msgpack/template/BooleanTemplate.java index e9fd33cc..dd3367ff 100644 --- a/java/src/main/java/org/msgpack/template/BooleanTemplate.java +++ b/java/src/main/java/org/msgpack/template/BooleanTemplate.java @@ -42,7 +42,7 @@ public class BooleanTemplate implements Template { static final BooleanTemplate instance = new BooleanTemplate(); static { - CustomMessage.registerTemplate(Boolean.class, instance); + CustomMessage.register(Boolean.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java b/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java index 45a006fb..2008b7ca 100644 --- a/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java +++ b/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java @@ -42,7 +42,7 @@ public class ByteArrayTemplate implements Template { static final ByteArrayTemplate instance = new ByteArrayTemplate(); static { - CustomMessage.registerTemplate(byte[].class, instance); + CustomMessage.register(byte[].class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/ByteTemplate.java b/java/src/main/java/org/msgpack/template/ByteTemplate.java index d58e8b0b..0c8a31bb 100644 --- a/java/src/main/java/org/msgpack/template/ByteTemplate.java +++ b/java/src/main/java/org/msgpack/template/ByteTemplate.java @@ -42,7 +42,7 @@ public class ByteTemplate implements Template { static final ByteTemplate instance = new ByteTemplate(); static { - CustomMessage.registerTemplate(Byte.class, instance); + CustomMessage.register(Byte.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/DoubleTemplate.java b/java/src/main/java/org/msgpack/template/DoubleTemplate.java index c899e733..94550ebf 100644 --- a/java/src/main/java/org/msgpack/template/DoubleTemplate.java +++ b/java/src/main/java/org/msgpack/template/DoubleTemplate.java @@ -42,7 +42,7 @@ public class DoubleTemplate implements Template { static final DoubleTemplate instance = new DoubleTemplate(); static { - CustomMessage.registerTemplate(Double.class, instance); + CustomMessage.register(Double.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/FloatTemplate.java b/java/src/main/java/org/msgpack/template/FloatTemplate.java index 354e3f8c..c247e296 100644 --- a/java/src/main/java/org/msgpack/template/FloatTemplate.java +++ b/java/src/main/java/org/msgpack/template/FloatTemplate.java @@ -42,7 +42,7 @@ public class FloatTemplate implements Template { static final FloatTemplate instance = new FloatTemplate(); static { - CustomMessage.registerTemplate(Float.class, instance); + CustomMessage.register(Float.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/IntegerTemplate.java b/java/src/main/java/org/msgpack/template/IntegerTemplate.java index 21ff0af9..2dee8e08 100644 --- a/java/src/main/java/org/msgpack/template/IntegerTemplate.java +++ b/java/src/main/java/org/msgpack/template/IntegerTemplate.java @@ -42,7 +42,7 @@ public class IntegerTemplate implements Template { static final IntegerTemplate instance = new IntegerTemplate(); static { - CustomMessage.registerTemplate(Integer.class, instance); + CustomMessage.register(Integer.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/LongTemplate.java b/java/src/main/java/org/msgpack/template/LongTemplate.java index d8990afd..930b7d0d 100644 --- a/java/src/main/java/org/msgpack/template/LongTemplate.java +++ b/java/src/main/java/org/msgpack/template/LongTemplate.java @@ -42,7 +42,7 @@ public class LongTemplate implements Template { static final LongTemplate instance = new LongTemplate(); static { - CustomMessage.registerTemplate(Long.class, instance); + CustomMessage.register(Long.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/ShortTemplate.java b/java/src/main/java/org/msgpack/template/ShortTemplate.java index 0268797a..10ac43b3 100644 --- a/java/src/main/java/org/msgpack/template/ShortTemplate.java +++ b/java/src/main/java/org/msgpack/template/ShortTemplate.java @@ -42,7 +42,7 @@ public class ShortTemplate implements Template { static final ShortTemplate instance = new ShortTemplate(); static { - CustomMessage.registerTemplate(Short.class, instance); + CustomMessage.register(Short.class, instance); } } diff --git a/java/src/main/java/org/msgpack/template/StringTemplate.java b/java/src/main/java/org/msgpack/template/StringTemplate.java index 4a4be3ee..dd31d9e0 100644 --- a/java/src/main/java/org/msgpack/template/StringTemplate.java +++ b/java/src/main/java/org/msgpack/template/StringTemplate.java @@ -42,7 +42,7 @@ public class StringTemplate implements Template { static final StringTemplate instance = new StringTemplate(); static { - CustomMessage.registerTemplate(String.class, instance); + CustomMessage.register(String.class, instance); } } diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java index c80d3549..c8ab3c7f 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java @@ -581,7 +581,7 @@ public class DynamicCodeGenBase implements Constants { } else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) { // @MessagePackMessage Template tmpl = DynamicTemplate.create(c); - CustomMessage.registerTemplate(c, tmpl); + CustomMessage.register(c, tmpl); return tmpl; } else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) { // FIXME DelegatePacker @@ -593,12 +593,12 @@ public class DynamicCodeGenBase implements Constants { MessagePackOrdinalEnum.class)) { // @MessagePackOrdinalEnum Template tmpl = DynamicOrdinalEnumTemplate.create(c); - CustomMessage.registerTemplate(c, tmpl); + CustomMessage.register(c, tmpl); return tmpl; } else if (MessageConvertable.class.isAssignableFrom(c) || MessageUnpackable.class.isAssignableFrom(c)) { Template tmpl = new MessageUnpackableConvertableTemplate(c); - CustomMessage.registerTemplate(c, tmpl); + CustomMessage.register(c, tmpl); return tmpl; } else { throw new MessageTypeException("Type error: " diff --git a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java index e7b8d843..f08176ed 100644 --- a/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java +++ b/java/src/test/java/org/msgpack/TestMessagePackStaticMethods.java @@ -72,20 +72,6 @@ public class TestMessagePackStaticMethods extends TestCase { byte[] e = MessagePack.pack(createProvidedClass(), tClass(ProvidedClass.class)); byte[] f = MessagePack.pack(createUserDefinedClass(), tClass(UserDefinedClass.class)); - { - String aobj = MessagePack.unpack(a, String.class); - Integer bobj = MessagePack.unpack(b, Integer.class); - Object cobj = MessagePack.unpack(c, Object.class); - ProvidedClass eobj = MessagePack.unpack(e, ProvidedClass.class); - UserDefinedClass fobj = MessagePack.unpack(f, UserDefinedClass.class); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, (Integer)1); - assertEquals(cobj, null); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - { Object aobj = MessagePack.unpack(a, TString); Object bobj = MessagePack.unpack(b, TInteger); @@ -103,6 +89,20 @@ public class TestMessagePackStaticMethods extends TestCase { assertEquals(eobj, createProvidedClass()); assertEquals(fobj, createUserDefinedClass()); } + + { + String aobj = MessagePack.unpack(a, String.class); + Integer bobj = MessagePack.unpack(b, Integer.class); + Object cobj = MessagePack.unpack(c, Object.class); + ProvidedClass eobj = MessagePack.unpack(e, ProvidedClass.class); + UserDefinedClass fobj = MessagePack.unpack(f, UserDefinedClass.class); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } } @Test @@ -120,25 +120,6 @@ public class TestMessagePackStaticMethods extends TestCase { ByteArrayOutputStream fout = new ByteArrayOutputStream(); MessagePack.pack(fout, createUserDefinedClass()); - { - InputStream ain = new ByteArrayInputStream(aout.toByteArray()); - String aobj = MessagePack.unpack(ain, String.class); - InputStream bin = new ByteArrayInputStream(bout.toByteArray()); - Integer bobj = MessagePack.unpack(bin, Integer.class); - InputStream cin = new ByteArrayInputStream(cout.toByteArray()); - Object cobj = MessagePack.unpack(cin, Object.class); - InputStream ein = new ByteArrayInputStream(eout.toByteArray()); - ProvidedClass eobj = MessagePack.unpack(ein, ProvidedClass.class); - InputStream fin = new ByteArrayInputStream(fout.toByteArray()); - UserDefinedClass fobj = MessagePack.unpack(fin, UserDefinedClass.class); - - assertEquals(aobj, "msgpack"); - assertEquals(bobj, (Integer)1); - assertEquals(cobj, null); - assertEquals(eobj, createProvidedClass()); - assertEquals(fobj, createUserDefinedClass()); - } - { InputStream ain = new ByteArrayInputStream(aout.toByteArray()); Object aobj = MessagePack.unpack(ain, TString); @@ -163,6 +144,25 @@ public class TestMessagePackStaticMethods extends TestCase { assertEquals(eobj, createProvidedClass()); assertEquals(fobj, createUserDefinedClass()); } + + { + InputStream ain = new ByteArrayInputStream(aout.toByteArray()); + String aobj = MessagePack.unpack(ain, String.class); + InputStream bin = new ByteArrayInputStream(bout.toByteArray()); + Integer bobj = MessagePack.unpack(bin, Integer.class); + InputStream cin = new ByteArrayInputStream(cout.toByteArray()); + Object cobj = MessagePack.unpack(cin, Object.class); + InputStream ein = new ByteArrayInputStream(eout.toByteArray()); + ProvidedClass eobj = MessagePack.unpack(ein, ProvidedClass.class); + InputStream fin = new ByteArrayInputStream(fout.toByteArray()); + UserDefinedClass fobj = MessagePack.unpack(fin, UserDefinedClass.class); + + assertEquals(aobj, "msgpack"); + assertEquals(bobj, (Integer)1); + assertEquals(cobj, null); + assertEquals(eobj, createProvidedClass()); + assertEquals(fobj, createUserDefinedClass()); + } } @Test