--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/org/msgpack/util/TestTemplatePreCompilerBufferPackBufferUnpack.java	Sat Oct 18 15:06:15 2014 +0900
@@ -0,0 +1,625 @@
+package org.msgpack.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.msgpack.MessagePack;
+import org.msgpack.packer.BufferPacker;
+import org.msgpack.template.TemplateRegistry;
+import org.msgpack.template.Template;
+import org.msgpack.template.builder.TestSet;
+import org.msgpack.testclasses.FinalClass;
+import org.msgpack.testclasses.InheritanceClass;
+import org.msgpack.testclasses.InheritanceClassNotNullable;
+import org.msgpack.testclasses.ListTypeFieldsClass;
+import org.msgpack.testclasses.ListTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.MapTypeFieldsClass;
+import org.msgpack.testclasses.MapTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.MessagePackableTypeFieldsClass;
+import org.msgpack.testclasses.MessagePackableTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.ModifiersFieldsClass;
+import org.msgpack.testclasses.ModifiersFieldsClassNotNullable;
+import org.msgpack.testclasses.PrimitiveTypeFieldsClass;
+import org.msgpack.testclasses.PrimitiveTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.ReferenceCycleTypeFieldsClass;
+import org.msgpack.testclasses.ReferenceCycleTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.ReferenceTypeFieldsClass;
+import org.msgpack.testclasses.ReferenceTypeFieldsClassNotNullable;
+import org.msgpack.testclasses.UserDefinedTypeFieldsClass;
+import org.msgpack.testclasses.UserDefinedTypeFieldsClassNotNullable;
+import org.msgpack.unpacker.BufferUnpacker;
+
+public class TestTemplatePreCompilerBufferPackBufferUnpack extends TestSet {
+
+    @Test
+    @Override
+    public void testPrimitiveTypeFieldsClass() throws Exception {
+        super.testPrimitiveTypeFieldsClass();
+    }
+
+    @Override
+    public void testPrimitiveTypeFieldsClass(PrimitiveTypeFieldsClass v)
+            throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    PrimitiveTypeFieldsClass.class);
+            Template<PrimitiveTypeFieldsClass> tmpl = msgpack
+                    .lookup(PrimitiveTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            PrimitiveTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(PrimitiveTypeFieldsClass.class);
+            msgpack.unregister(PrimitiveTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testPrimitiveTypeFieldsClassNotNullable() throws Exception {
+        super.testPrimitiveTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testPrimitiveTypeFieldsClassNotNullable(
+            PrimitiveTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    PrimitiveTypeFieldsClassNotNullable.class);
+            Template<PrimitiveTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(PrimitiveTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            PrimitiveTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(PrimitiveTypeFieldsClassNotNullable.class);
+            msgpack.unregister(PrimitiveTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testReferenceTypeFieldsClass() throws Exception {
+        super.testReferenceTypeFieldsClass();
+    }
+
+    @Override
+    public void testReferenceTypeFieldsClass(ReferenceTypeFieldsClass v)
+            throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ReferenceTypeFieldsClass.class);
+            Template<ReferenceTypeFieldsClass> tmpl = msgpack
+                    .lookup(ReferenceTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ReferenceTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ReferenceTypeFieldsClass.class);
+            msgpack.unregister(ReferenceTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testReferenceTypeFieldsClassNotNullable() throws Exception {
+        super.testReferenceTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testReferenceTypeFieldsClassNotNullable(
+            ReferenceTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ReferenceTypeFieldsClassNotNullable.class);
+            Template<ReferenceTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(ReferenceTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ReferenceTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ReferenceTypeFieldsClassNotNullable.class);
+            msgpack.unregister(ReferenceTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testListTypeFieldsClass() throws Exception {
+        super.testListTypeFieldsClass();
+    }
+
+    @Override
+    public void testListTypeFieldsClass(ListTypeFieldsClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ListTypeFieldsClass.class);
+            Template<ListTypeFieldsClass> tmpl = msgpack
+                    .lookup(ListTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ListTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler.deleteTemplateClass(ListTypeFieldsClass.class);
+            msgpack.unregister(ListTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testListTypeFieldsClassNotNullable() throws Exception {
+        super.testListTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testListTypeFieldsClassNotNullable(
+            ListTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ListTypeFieldsClassNotNullable.class);
+            Template<ListTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(ListTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ListTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ListTypeFieldsClassNotNullable.class);
+            msgpack.unregister(ListTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testMapTypeFieldsClass() throws Exception {
+        super.testMapTypeFieldsClass();
+    }
+
+    @Override
+    public void testMapTypeFieldsClass(MapTypeFieldsClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    MapTypeFieldsClass.class);
+            Template<MapTypeFieldsClass> tmpl = msgpack
+                    .lookup(MapTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            MapTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler.deleteTemplateClass(MapTypeFieldsClass.class);
+            msgpack.unregister(MapTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testMapTypeFieldsClassNotNullable() throws Exception {
+        super.testMapTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testMapTypeFieldsClassNotNullable(
+            MapTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    MapTypeFieldsClassNotNullable.class);
+            Template<MapTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(MapTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            MapTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(MapTypeFieldsClassNotNullable.class);
+            msgpack.unregister(MapTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testFinalClass() throws Exception {
+        super.testFinalClass();
+    }
+
+    @Override
+    public void testFinalClass(FinalClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    FinalClass.class);
+            Template<FinalClass> tmpl = msgpack.lookup(FinalClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            FinalClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler.deleteTemplateClass(FinalClass.class);
+            msgpack.unregister(FinalClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testModifiersFieldsClass() throws Exception {
+        super.testModifiersFieldsClass();
+    }
+
+    @Override
+    public void testModifiersFieldsClass(ModifiersFieldsClass v)
+            throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ModifiersFieldsClass.class);
+            Template<ModifiersFieldsClass> tmpl = msgpack
+                    .lookup(ModifiersFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ModifiersFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler.deleteTemplateClass(ModifiersFieldsClass.class);
+            msgpack.unregister(ModifiersFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testModifiersFieldsClassNotNullable() throws Exception {
+        super.testModifiersFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testModifiersFieldsClassNotNullable(
+            ModifiersFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ModifiersFieldsClassNotNullable.class);
+            Template<ModifiersFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(ModifiersFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ModifiersFieldsClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ModifiersFieldsClassNotNullable.class);
+            msgpack.unregister(ModifiersFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testUserDefinedTypeFieldsClass() throws Exception {
+        super.testUserDefinedTypeFieldsClass();
+    }
+
+    @Override
+    public void testUserDefinedTypeFieldsClass(UserDefinedTypeFieldsClass v)
+            throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    UserDefinedTypeFieldsClass.class);
+            Template<UserDefinedTypeFieldsClass> tmpl = msgpack
+                    .lookup(UserDefinedTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            UserDefinedTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(UserDefinedTypeFieldsClass.class);
+            msgpack.unregister(UserDefinedTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testUserDefinedTypeFieldsClassNotNullable() throws Exception {
+        super.testUserDefinedTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testUserDefinedTypeFieldsClassNotNullable(
+            UserDefinedTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    UserDefinedTypeFieldsClassNotNullable.class);
+            Template<UserDefinedTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(UserDefinedTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            UserDefinedTypeFieldsClassNotNullable ret = tmpl.read(unpacker,
+                    null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(UserDefinedTypeFieldsClassNotNullable.class);
+            msgpack.unregister(UserDefinedTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @org.junit.Ignore
+    @Test
+    @Override
+    // FIXME #MN next version
+    public void testReferenceCycleTypeFieldsClass() throws Exception {
+        super.testReferenceCycleTypeFieldsClass();
+    }
+
+    @org.junit.Ignore
+    @Override
+    // FIXME #MN next version
+    public void testReferenceCycleTypeFieldsClass(
+            ReferenceCycleTypeFieldsClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ReferenceCycleTypeFieldsClass.class);
+            Template<ReferenceCycleTypeFieldsClass> tmpl = msgpack
+                    .lookup(ReferenceCycleTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ReferenceCycleTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ReferenceCycleTypeFieldsClass.class);
+            msgpack.unregister(ReferenceCycleTypeFieldsClass.class);
+        }
+    }
+
+    @org.junit.Ignore
+    @Test
+    @Override
+    // FIXME #MN next version
+    public void testReferenceCycleTypeFieldsClassNotNullable() throws Exception {
+        super.testReferenceCycleTypeFieldsClassNotNullable();
+    }
+
+    @org.junit.Ignore
+    @Override
+    // FIXME #MN next version
+    public void testReferenceCycleTypeFieldsClassNotNullable(
+            ReferenceCycleTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    ReferenceCycleTypeFieldsClassNotNullable.class);
+            Template<ReferenceCycleTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(ReferenceCycleTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            ReferenceCycleTypeFieldsClassNotNullable ret = tmpl.read(unpacker,
+                    null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(ReferenceCycleTypeFieldsClassNotNullable.class);
+            msgpack.unregister(ReferenceCycleTypeFieldsClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testInheritanceClass() throws Exception {
+        super.testInheritanceClass();
+    }
+
+    @Override
+    public void testInheritanceClass(InheritanceClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    InheritanceClass.class);
+            Template<InheritanceClass> tmpl = msgpack
+                    .lookup(InheritanceClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            InheritanceClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler.deleteTemplateClass(InheritanceClass.class);
+            msgpack.unregister(InheritanceClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testInheritanceClassNotNullable() throws Exception {
+        super.testInheritanceClassNotNullable();
+    }
+
+    @Override
+    public void testInheritanceClassNotNullable(InheritanceClassNotNullable v)
+            throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    InheritanceClassNotNullable.class);
+            Template<InheritanceClassNotNullable> tmpl = msgpack
+                    .lookup(InheritanceClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            InheritanceClassNotNullable ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(InheritanceClassNotNullable.class);
+            msgpack.unregister(InheritanceClassNotNullable.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testMessagePackableTypeFieldsClass() throws Exception {
+        super.testMessagePackableTypeFieldsClass();
+    }
+
+    @Override
+    public void testMessagePackableTypeFieldsClass(
+            MessagePackableTypeFieldsClass v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    MessagePackableTypeFieldsClass.class);
+            Template<MessagePackableTypeFieldsClass> tmpl = msgpack
+                    .lookup(MessagePackableTypeFieldsClass.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            MessagePackableTypeFieldsClass ret = tmpl.read(unpacker, null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(MessagePackableTypeFieldsClass.class);
+            msgpack.unregister(MessagePackableTypeFieldsClass.class);
+        }
+    }
+
+    @Test
+    @Override
+    public void testMessagePackableTypeFieldsClassNotNullable()
+            throws Exception {
+        super.testMessagePackableTypeFieldsClassNotNullable();
+    }
+
+    @Override
+    public void testMessagePackableTypeFieldsClassNotNullable(
+            MessagePackableTypeFieldsClassNotNullable v) throws Exception {
+        System.getProperties().setProperty(TemplatePrecompiler.DEST,
+                "./target/test-classes");
+        MessagePack msgpack = new MessagePack();
+        try {
+            TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
+                    MessagePackableTypeFieldsClassNotNullable.class);
+            Template<MessagePackableTypeFieldsClassNotNullable> tmpl = msgpack
+                    .lookup(MessagePackableTypeFieldsClassNotNullable.class);
+            BufferPacker packer = msgpack.createBufferPacker();
+            tmpl.write(packer, v);
+            byte[] bytes = packer.toByteArray();
+            BufferUnpacker unpacker = msgpack.createBufferUnpacker();
+            unpacker.wrap(bytes);
+            MessagePackableTypeFieldsClassNotNullable ret = tmpl.read(unpacker,
+                    null);
+            assertEquals(v, ret);
+        } finally {
+            TemplatePrecompiler
+                    .deleteTemplateClass(MessagePackableTypeFieldsClassNotNullable.class);
+            msgpack.unregister(MessagePackableTypeFieldsClassNotNullable.class);
+        }
+    }
+
+}