java: write test programs for org.msgpack.util.codegen.*.java

java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java

@@ -33,6 +33,9 @@ import org.slf4j.LoggerFactory;
 
 public class DynamicCodeGenBase implements Constants {
 
+	private static Logger LOG = LoggerFactory
+			.getLogger(DynamicCodeGenBase.class);
+
 	public static interface NullChecker {
 		void setNullCheck(boolean nullCheck);
 	}
@@ -58,9 +61,6 @@ public class DynamicCodeGenBase implements Constants {
 		}
 	}
 
-	private static Logger LOG = LoggerFactory
-			.getLogger(DynamicCodeGenBase.class);
-
 	private static AtomicInteger COUNTER = new AtomicInteger(0);
 
 	protected static int inc() {
@@ -74,80 +74,58 @@ public class DynamicCodeGenBase implements Constants {
 	}
 
 	protected void checkTypeValidation(Class<?> type) {
-		DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
-				+ type.getName());
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"Fatal error: %s", new Object[] { type.getName() }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
-	protected void throwTypeValidationException(Class<?> origClass,
-			String message) throws DynamicCodeGenException {
-		DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
-				+ origClass.getName());
+	protected void throwTypeValidationException(Class<?> type, String message)
+			throws DynamicCodeGenException {
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"%s: %s", new Object[] { message, type.getName() }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
 	protected void checkDefaultConstructorValidation(Class<?> type) {
-		DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
-				+ type.getName());
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"Fatal error: %s", new Object[] { type.getName() }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
 	protected void throwConstructorValidationException(Class<?> origClass) {
-		DynamicCodeGenException e = new DynamicCodeGenException(
-				"it must have a public zero-argument constructor: "
-						+ origClass.getName());
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"it must have a public zero-argument constructor: %s",
+				new Object[] { origClass.getName() }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
-	protected void throwFieldValidationException(Field f) {
-		DynamicCodeGenException e = new DynamicCodeGenException(
-				"it must be a public field: " + f.getName());
+	protected void throwFieldValidationException(Field field) {
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"it must be a public field: %s",
+				new Object[] { field.getName() }));
 		LOG.debug(e.getMessage(), e);
 		throw e;
 	}
 
 	protected static void throwMethodValidationException(Method method,
 			String message) throws DynamicCodeGenException {
-		DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
-				+ method.getName());
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"%s: %s", new Object[] { message, method.getName() }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
 	protected CtClass makeClass(String name) throws NotFoundException {
-		DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
-				+ name);
+		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
+				"Fatal error: %s", new Object[] { name }));
 		LOG.error(e.getMessage(), e);
 		throw e;
 	}
 
-	enum Color {
-		// TODO
-		RED, BLUE
-	}
-
-	public static void main(String[] args) throws Exception {
-		// TODO
-		class Foo {
-		}
-		class Bar extends Foo {
-		}
-		Color c = Color.RED;
-		Color c1 = null;
-
-		ClassPool pool = ClassPool.getDefault();
-		CtClass barCtClass = pool.get(Bar.class.getName());
-		CtClass sbarCtClass = barCtClass.getSuperclass();
-		System.out.println("bar: " + sbarCtClass.getName());
-		CtClass fooCtClass = pool.get(Foo.class.getName());
-		CtClass sfooCtClass = fooCtClass.getSuperclass();
-		System.out.println("foo: " + sfooCtClass.getName());
-	}
-
 	protected void setSuperclass(CtClass newCtClass, Class<?> superClass)
 			throws NotFoundException, CannotCompileException {
 		// check the specified super class

java/src/main/java/org/msgpack/util/codegen/FieldOption.java

@@ -0,0 +1,10 @@
+package org.msgpack.util.codegen;
+
+import org.msgpack.Template;
+
+public class FieldOption {
+
+    public String name;
+    
+    public Template tmpl;
+}

java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java

@@ -2,6 +2,7 @@ package org.msgpack.util.codegen;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -15,8 +16,11 @@ import org.junit.Test;
 import org.msgpack.CustomConverter;
 import org.msgpack.CustomPacker;
 import org.msgpack.CustomUnpacker;
+import org.msgpack.MessageConvertable;
 import org.msgpack.MessagePackObject;
+import org.msgpack.MessagePackable;
 import org.msgpack.MessagePacker;
+import org.msgpack.MessageTypeException;
 import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Unpacker;
@@ -1007,4 +1011,121 @@ public class TestPackConvert extends TestCase {
 		public SampleSuperClass() {
 		}
 	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass00() throws Exception {
+		BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass();
+		MessagePackableConvertableClass src1 = new MessagePackableConvertableClass();
+		List<MessagePackableConvertableClass> src2 = new ArrayList<MessagePackableConvertableClass>();
+		src1.f0 = 0;
+		src1.f1 = 1;
+		src.f0 = src1;
+		src.f1 = 1;
+		src2.add(src1);
+		src.f2 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableConvertableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableConvertableClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl
+				.convert(mpo);
+		assertEquals(src.f0.f0, dst.f0.f0);
+		assertEquals(src.f0.f1, dst.f0.f1);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2.size(), dst.f2.size());
+		assertEquals(src.f2.get(0).f0, dst.f2.get(0).f0);
+		assertEquals(src.f2.get(0).f1, dst.f2.get(0).f1);
+		assertFalse(it.hasNext());
+	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass01() throws Exception {
+		BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass();
+		src.f0 = null;
+		src.f1 = 1;
+		src.f2 = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableConvertableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableConvertableClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl
+				.convert(mpo);
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertFalse(it.hasNext());
+	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass02() throws Exception {
+		BaseMessagePackableConvertableClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableConvertableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableConvertableClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl
+				.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class BaseMessagePackableConvertableClass {
+		public MessagePackableConvertableClass f0;
+
+		public int f1;
+
+		public List<MessagePackableConvertableClass> f2;
+
+		public BaseMessagePackableConvertableClass() {
+		}
+	}
+
+	public static class MessagePackableConvertableClass implements
+			MessagePackable, MessageConvertable {
+
+		public int f0;
+
+		public int f1;
+
+		public MessagePackableConvertableClass() {
+		}
+
+		@Override
+		public void messagePack(Packer packer) throws IOException {
+			packer.pack(f0);
+			packer.pack(f1);
+		}
+
+		@Override
+		public void messageConvert(MessagePackObject obj)
+				throws MessageTypeException {
+			if (obj.isNil()) {
+				return;
+			}
+			MessagePackObject[] objs = obj.asArray();
+			f0 = objs[0].asInt();
+			f1 = objs[1].asInt();
+		}
+	}
 }

java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java

@@ -2,6 +2,7 @@ package org.msgpack.util.codegen;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -13,7 +14,10 @@ import org.junit.Test;
 import org.msgpack.CustomConverter;
 import org.msgpack.CustomPacker;
 import org.msgpack.CustomUnpacker;
+import org.msgpack.MessagePackable;
 import org.msgpack.MessagePacker;
+import org.msgpack.MessageTypeException;
+import org.msgpack.MessageUnpackable;
 import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Unpacker;
@@ -885,4 +889,104 @@ public class TestPackUnpack extends TestCase {
 		public SampleSuperClass() {
 		}
 	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass00() throws Exception {
+		BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass();
+		MessagePackableUnpackableClass src1 = new MessagePackableUnpackableClass();
+		List<MessagePackableUnpackableClass> src2 = new ArrayList<MessagePackableUnpackableClass>();
+		src1.f0 = 0;
+		src1.f1 = 1;
+		src.f0 = src1;
+		src.f1 = 1;
+		src2.add(src1);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableUnpackableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableUnpackableClass.class);
+		BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0.f0, dst.f0.f0);
+		assertEquals(src.f0.f1, dst.f0.f1);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2.size(), dst.f2.size());
+		assertEquals(src.f2.get(0).f0, dst.f2.get(0).f0);
+		assertEquals(src.f2.get(0).f1, dst.f2.get(0).f1);
+	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass01() throws Exception {
+		BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass();
+		src.f0 = null;
+		src.f1 = 1;
+		src.f2 = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableUnpackableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableUnpackableClass.class);
+		BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+	}
+
+	//@Test
+	public void XtestMessagePackableUnpackableClass02() throws Exception {
+		BaseMessagePackableUnpackableClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(BaseMessagePackableUnpackableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(BaseMessagePackableUnpackableClass.class);
+		BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class BaseMessagePackableUnpackableClass {
+		public MessagePackableUnpackableClass f0;
+
+		public int f1;
+
+		public List<MessagePackableUnpackableClass> f2;
+
+		public BaseMessagePackableUnpackableClass() {
+		}
+	}
+
+	public static class MessagePackableUnpackableClass implements
+			MessagePackable, MessageUnpackable {
+
+		public int f0;
+
+		public int f1;
+
+		public MessagePackableUnpackableClass() {
+		}
+
+		@Override
+		public void messagePack(Packer packer) throws IOException {
+			packer.pack(f0);
+			packer.pack(f1);
+		}
+
+		@Override
+		public void messageUnpack(Unpacker unpacker) throws IOException,
+				MessageTypeException {
+			if (unpacker.tryUnpackNull()) {
+				return;
+			}
+			f0 = unpacker.unpackInt();
+			f1 = unpacker.unpackInt();
+		}
+	}
 }