java: write test programs for OptionalTemplate.java

19 files changed, 2754 insertions, 452 deletions

diff --git a/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java b/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java
index 081b28c..f9eb227 100644
--- a/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java
+++ b/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java
@@ -6,7 +6,6 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 @Target(ElementType.FIELD)
-@Retention(RetentionPolicy.CLASS)
+@Retention(RetentionPolicy.RUNTIME)
 public @interface MessagePackOptional {
-	int value() default -1;
 }
\ No newline at end of file
diff --git a/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java b/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java
deleted file mode 100644
index e268c4f..0000000
--- a/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package org.msgpack.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.FIELD)
-@Retention(RetentionPolicy.CLASS)
-public @interface MessagePackRequired {
-	int value() default -1;
-}
\ No newline at end of file
diff --git a/java/src/main/java/org/msgpack/template/MapTemplate.java b/java/src/main/java/org/msgpack/template/MapTemplate.java
index d2b4eff..6b8457d 100644
--- a/java/src/main/java/org/msgpack/template/MapTemplate.java
+++ b/java/src/main/java/org/msgpack/template/MapTemplate.java
@@ -42,6 +42,7 @@ public class MapTemplate implements Template {
 		return map;
 	}
 
+	@SuppressWarnings("unchecked")
 	public Object convert(MessagePackObject from) throws MessageTypeException {
 		Map<MessagePackObject,MessagePackObject> src = from.asMap();
 		Map<Object,Object> map = new HashMap();
diff --git a/java/src/main/java/org/msgpack/template/OptionalTemplate.java b/java/src/main/java/org/msgpack/template/OptionalTemplate.java
index 6be16c1..f288fc4 100644
--- a/java/src/main/java/org/msgpack/template/OptionalTemplate.java
+++ b/java/src/main/java/org/msgpack/template/OptionalTemplate.java
@@ -17,8 +17,6 @@
 //
 package org.msgpack.template;
 
-import java.util.List;
-import java.util.ArrayList;
 import java.io.IOException;
 import org.msgpack.*;
 
diff --git a/java/src/main/java/org/msgpack/util/codegen/Constants.java b/java/src/main/java/org/msgpack/util/codegen/Constants.java
index e32e6ad..8a4b708 100644
--- a/java/src/main/java/org/msgpack/util/codegen/Constants.java
+++ b/java/src/main/java/org/msgpack/util/codegen/Constants.java
@@ -9,96 +9,20 @@ public interface Constants {
 
 	String POSTFIX_TYPE_NAME_TEMPLATE = "_$$_Template";
 
-	String KEYWORD_MODIFIER_PUBLIC = "public";
+	String STRING_NAME_COMMA_SPACE = ", ";
 
-	String KEYWORD_CATCH = "catch";
-
-	String KEYWORD_ELSE = "else";
-
-	String KEYWORD_ELSEIF = "else if";
-
-	String KEYWORD_FOR = "for";
-
-	String KEYWORD_IF = "if";
-
-	String KEYWORD_INSTANCEOF = "instanceof";
-
-	String KEYWORD_NEW = "new";
-
-	String KEYWORD_NULL = "null";
-
-	String KEYWORD_RETURN = "return";
-
-	String KEYWORD_THROW = "throw";
-
-	String KEYWORD_THROWS = "throws";
-
-	String KEYWORD_TRY = "try";
+	String STRING_NAME_LEFT_RIGHT_SQUARE_BRACKET = "[]";
 
 	String CHAR_NAME_SPACE = " ";
 
-	String CHAR_NAME_COMMA = ",";
-
-	String CHAR_NAME_EQUAL = "=";
-
-	String CHAR_NAME_PLUS = "+";
-
-	String CHAR_NAME_MINUS = "-";
-
-	String CHAR_NAME_UNDERSCORE = "_";
-
-	String CHAR_NAME_LESSTHAN = "<";
-
-	String CHAR_NAME_RIGHT_PARENTHESIS = ")";
-
-	String CHAR_NAME_LEFT_PARENTHESIS = "(";
-
 	String CHAR_NAME_RIGHT_CURLY_BRACKET = "}";
 
 	String CHAR_NAME_LEFT_CURLY_BRACKET = "{";
 
-	String CHAR_NAME_RIGHT_SQUARE_BRACKET = "]";
-
-	String CHAR_NAME_LEFT_SQUARE_BRACKET = "[";
-
-	String CHAR_NAME_DOT = ".";
-
-	String CHAR_NAME_SEMICOLON = ";";
-
-	String VARIABLE_NAME_PK = "_$$_pk";
-
-	String VARIABLE_NAME_OBJECT = "_$$_obj";
-
-	String VARIABLE_NAME_TARGET = "_$$_t";
-
-	String VARIABLE_NAME_SIZE = "_$$_len";
-
-	String VARIABLE_NAME_ARRAY = "_$$_ary";
-
-	String VARIABLE_NAME_LIST = "_$$_list";
-
-	String VARIABLE_NAME_MAP = "_$$_map";
-
-	String VARIABLE_NAME_KEY = "_$$_key";
-
-	String VARIABLE_NAME_VAL = "_$$_val";
-
-	String VARIABLE_NAME_ITER = "_$$_iter";
-
-	String VARIABLE_NAME_MPO = "_$$_mpo";
-
-	String VARIABLE_NAME_I = "i";
-
 	String VARIABLE_NAME_TEMPLATES = "_$$_templates";
 
-	String VARIABLE_NAME_TEMPLATES0 = "_$$_tmpls";
-
 	String VARIABLE_NAME_CLIENT = "_$$_client";
 
-	String VARIABLE_NAME_CLIENT0 = "_$$_c";
-
-	String METHOD_NAME_VALUEOF = "valueOf";
-
 	String METHOD_NAME_BOOLEANVALUE = "booleanValue";
 
 	String METHOD_NAME_BYTEVALUE = "byteValue";
@@ -113,38 +37,14 @@ public interface Constants {
 
 	String METHOD_NAME_DOUBLEVALUE = "doubleValue";
 
-	String METHOD_NAME_ADD = "add";
-
-	String METHOD_NAME_PUT = "put";
-
-	String METHOD_NAME_GET = "get";
-
-	String METHOD_NAME_SIZE = "size";
-
-	String METHOD_NAME_KEYSET = "keySet";
-
-	String METHOD_NAME_ITERATOR = "iterator";
-
-	String METHOD_NAME_HASNEXT = "hasNext";
-
-	String METHOD_NAME_NEXT = "next";
-
-	String METHOD_NAME_ORDINAL = "ordinal";
-
 	String METHOD_NAME_GETENUMCONSTANTS = "getEnumConstants";
 
 	String METHOD_NAME_CONVERT = "convert";
 
-	String METHOD_NAME_MSGCONVERT = "messageConvert";
-
 	String METHOD_NAME_SETTEMPLATES = "setTemplates";
 
-	String METHOD_NAME_SETCLIENT = "setClient";
-
 	String METHOD_NAME_PACK = "pack";
 
-	String METHOD_NAME_PACKARRAY = "packArray";
-
 	String METHOD_NAME_UNPACK = "unpack";
 
 	String METHOD_NAME_UNPACKBOOLEAN = "unpackBoolean";
@@ -207,13 +107,11 @@ public interface Constants {
 
 	String STATEMENT_PACKER_PACKERMETHODBODY_04 = "$1.pack(((java.lang.Enum)_$$_t).ordinal()); ";
 
-	String STATEMENT_PACKER_PACKERMETHODBODY_05 = "if (_$$_nullCheck && $2 == null) { $1.packNil(); return; } ";
-
 	String STATEMENT_TMPL_UNPACKERMETHODBODY_01 = "%s _$$_t = new %s(); ";
 
 	String STATEMENT_TMPL_UNPACKERMETHODBODY_02 = "$1.unpackArray(); ";
 
-	String STATEMENT_TMPL_UNPACKERMETHODBODY_03 = "if (!_$$_nullCheck || !$1.tryUnpackNull()) { _$$_t.%s = %s(%s)_$$_templates[%d].unpack($1)%s; } ";
+	String STATEMENT_TMPL_UNPACKERMETHODBODY_03 = "_$$_t.%s = %s(%s)_$$_templates[%d].unpack($1)%s; ";
 
 	String STATEMENT_TMPL_UNPACKERMETHODBODY_04 = "return _$$_t; ";
 
@@ -221,13 +119,9 @@ public interface Constants {
 
 	String STATEMENT_TMPL_UNPACKERMETHODBODY_06 = "return %s.class.getEnumConstants()[i]; ";
 
-	String STATEMENT_TMPL_UNPACKERMETHODBODY_07 = "if (_$$_nullCheck && $1.tryUnpackNull()) { return null; } ";
-
 	String STATEMENT_TMPL_CONVERTMETHODBODY_01 = "%s _$$_ary = $1.asArray(); ";
 
-	String STATEMENT_TMPL_CONVERTMETHODBODY_02 = "if (!_$$_nullCheck || !_$$_ary[%d].isNil()) { _$$_t.%s = %s(%s)_$$_templates[%d].convert(_$$_ary[%d])%s; } ";
+	String STATEMENT_TMPL_CONVERTMETHODBODY_02 = "_$$_t.%s = %s(%s)_$$_templates[%d].convert(_$$_ary[%d])%s; ";
 
 	String STATEMENT_TMPL_CONVERTMETHODBODY_03 = "int i = _$$_ary[0].asInt(); ";
-
-	String STATEMENT_TMPL_CONVERTMETHODBODY_04 = "if (_$$_nullCheck && $1.isNil()) { return null; } ";
 }
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java
index 677ace9..bb9cdd5 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java
@@ -1,6 +1,7 @@
 package org.msgpack.util.codegen;
 
 import java.io.IOException;
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -27,7 +28,9 @@ import org.msgpack.Template;
 import org.msgpack.Unpacker;
 import org.msgpack.annotation.MessagePackDelegate;
 import org.msgpack.annotation.MessagePackMessage;
+import org.msgpack.annotation.MessagePackOptional;
 import org.msgpack.annotation.MessagePackOrdinalEnum;
+import org.msgpack.template.OptionalTemplate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -61,7 +64,8 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		return tmplCache.get(type.getName());
 	}
 
-	public Class<?> generateMessagePackerClass(Class<?> origClass) {
+	public Class<?> generateMessagePackerClass(Class<?> origClass,
+			List<FieldOption> fieldOpts) {
 		try {
 			LOG.debug("start generating a packer class for "
 					+ origClass.getName());
@@ -70,10 +74,12 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 			checkTypeValidation(origClass);
 			checkDefaultConstructorValidation(origClass);
 			CtClass packerCtClass = pool.makeClass(packerName);
-			setSuperclass(packerCtClass, NullCheckerImpl.class);
 			setInterface(packerCtClass, MessagePacker.class);
 			addDefaultConstructor(packerCtClass);
 			Field[] fields = getDeclaredFields(origClass);
+			if (fieldOpts != null) {
+				fields = sortFields(fields, fieldOpts);
+			}
 			addPackMethod(packerCtClass, origClass, fields, false);
 			Class<?> packerClass = createClass(packerCtClass);
 			LOG.debug("generated a packer class for " + origClass.getName());
@@ -95,7 +101,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 			String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc();
 			checkTypeValidation(origClass);
 			CtClass packerCtClass = pool.makeClass(packerName);
-			setSuperclass(packerCtClass, NullCheckerImpl.class);
 			setInterface(packerCtClass, MessagePacker.class);
 			addDefaultConstructor(packerCtClass);
 			addPackMethod(packerCtClass, origClass, null, true);
@@ -111,7 +116,8 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		}
 	}
 
-	public Class<?> generateTemplateClass(Class<?> origClass) {
+	public Class<?> generateTemplateClass(Class<?> origClass,
+			List<FieldOption> fieldOpts) {
 		try {
 			LOG.debug("start generating a template class for "
 					+ origClass.getName());
@@ -120,11 +126,17 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 			checkTypeValidation(origClass);
 			checkDefaultConstructorValidation(origClass);
 			CtClass tmplCtClass = pool.makeClass(tmplName);
-			setSuperclass(tmplCtClass, TemplateTemplate.class);
+			setSuperclass(tmplCtClass, TemplateAccessorImpl.class);
 			setInterface(tmplCtClass, Template.class);
 			addDefaultConstructor(tmplCtClass);
 			Field[] fields = getDeclaredFields(origClass);
-			Template[] tmpls = createTemplates(fields);
+			Template[] tmpls = null;
+			if (fieldOpts != null) {
+				fields = sortFields(fields, fieldOpts);
+				tmpls = createTemplates(fieldOpts);
+			} else {
+				tmpls = createTemplates(fields);
+			}
 			setTemplates(origClass, tmpls);
 			addUnpackMethod(tmplCtClass, origClass, fields, false);
 			addConvertMethod(tmplCtClass, origClass, fields, false);
@@ -152,7 +164,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 			checkTypeValidation(origClass);
 			String tmplName = origName + POSTFIX_TYPE_NAME_TEMPLATE + inc();
 			CtClass tmplCtClass = pool.makeClass(tmplName);
-			setSuperclass(tmplCtClass, TemplateTemplate.class);
+			setSuperclass(tmplCtClass, TemplateAccessorImpl.class);
 			setInterface(tmplCtClass, Template.class);
 			addDefaultConstructor(tmplCtClass);
 			addUnpackMethod(tmplCtClass, origClass, null, true);
@@ -240,6 +252,41 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		}
 	}
 
+	Field[] sortFields(Field[] fields, List<FieldOption> fieldOpts) {
+		if (fields.length != fieldOpts.size()) {
+			throwFieldSortingException(String.format(
+					"Mismatch: public field num: %d, option num: %d",
+					new Object[] { fields.length, fieldOpts.size() }));
+		}
+		Field[] sorted = new Field[fields.length];
+		for (int i = 0; i < sorted.length; ++i) {
+			FieldOption opt = fieldOpts.get(i);
+			Field match = null;
+			for (Field f : fields) {
+				if (opt.name.equals(f.getName())) {
+					match = f;
+					break;
+				}
+			}
+			if (match != null) {
+				sorted[i] = match;
+			} else {
+				throwFieldSortingException(String.format(
+						"Mismatch: a %s field option is not declared",
+						new Object[] { opt.name }));
+			}
+		}
+		return sorted;
+	}
+
+	Template[] createTemplates(List<FieldOption> fieldOpts) {
+		Template[] tmpls = new Template[fieldOpts.size()];
+		for (int i = 0; i < tmpls.length; ++i) {
+			tmpls[i] = fieldOpts.get(i).tmpl;
+		}
+		return tmpls;
+	}
+
 	Template[] createTemplates(Field[] fields) {
 		Template[] tmpls = new Template[fields.length];
 		for (int i = 0; i < tmpls.length; ++i) {
@@ -249,12 +296,23 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 	}
 
 	Template createTemplate(Field field) {
+		boolean isOptional = isAnnotated(field, MessagePackOptional.class);
 		Class<?> c = field.getType();
+		Template tmpl = null;
 		if (List.class.isAssignableFrom(c) || Map.class.isAssignableFrom(c)) {
-			return createTemplate(field.getGenericType());
+			tmpl = createTemplate(field.getGenericType());
 		} else {
-			return createTemplate(c);
+			tmpl = createTemplate(c);
 		}
+		if (isOptional) {
+			return new OptionalTemplate(tmpl);
+		} else {
+			return tmpl;
+		}
+	}
+	
+	private boolean isAnnotated(Field field, Class<? extends Annotation> with) {
+		return field.getAnnotation(with) != null;
 	}
 
 	private void addPackMethod(CtClass packerCtClass, Class<?> c, Field[] fs,
@@ -297,8 +355,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		// void pack(Packer packer, Object target) throws IOException;
 		sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
 		sb.append(CHAR_NAME_SPACE);
-		Object[] args2 = new Object[0];
-		sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_05, args2));
 		String typeName = classToString(type);
 		Object[] args0 = new Object[] { typeName, typeName };
 		sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0));
@@ -357,8 +413,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		// void pack(Packer packer, Object target) throws IOException;
 		sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
 		sb.append(CHAR_NAME_SPACE);
-		Object[] args3 = new Object[0];
-		sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_05, args3));
 		String typeName = classToString(c);
 		Object[] args0 = new Object[] { typeName, typeName };
 		sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0));
@@ -412,8 +466,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		sb.append(CHAR_NAME_SPACE);
 		// Foo _$$_t = new Foo();
 		String typeName = classToString(type);
-		Object[] args3 = new Object[0];
-		sb.append(String.format(STATEMENT_TMPL_UNPACKERMETHODBODY_07, args3));
 		Object[] args0 = new Object[] { typeName, typeName };
 		sb.append(String.format(STATEMENT_TMPL_UNPACKERMETHODBODY_01, args0));
 		// $1.unpackArray();
@@ -453,8 +505,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		// Object unpack(Unpacker u) throws IOException, MessageTypeException;
 		sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
 		sb.append(CHAR_NAME_SPACE);
-		Object[] args3 = new Object[0];
-		sb.append(String.format(STATEMENT_TMPL_UNPACKERMETHODBODY_07, args3));
 		// $1.unpackArray();
 		Object[] args0 = new Object[0];
 		sb.append(String.format(STATEMENT_TMPL_UNPACKERMETHODBODY_02, args0));
@@ -506,8 +556,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		// Object convert(MessagePackObject mpo) throws MessageTypeException;
 		sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
 		sb.append(CHAR_NAME_SPACE);
-		Object[] args3 = new Object[0];
-		sb.append(String.format(STATEMENT_TMPL_CONVERTMETHODBODY_04, args3));
 		// Foo _$$_t = new Foo();
 		String typeName = classToString(type);
 		Object[] args0 = new Object[] { typeName, typeName };
@@ -533,7 +581,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		Class<?> returnType = field.getType();
 		boolean isPrim = returnType.isPrimitive();
 		Object[] args = new Object[] {
-				i,
 				field.getName(),
 				isPrim ? "(" : "",
 				isPrim ? getPrimToWrapperType(returnType).getName()
@@ -550,8 +597,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
 		// Object convert(MessagePackObject mpo) throws MessageTypeException;
 		sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
 		sb.append(CHAR_NAME_SPACE);
-		Object[] args3 = new Object[0];
-		sb.append(String.format(STATEMENT_TMPL_CONVERTMETHODBODY_04, args3));
 		// MessagePackObject[] _$$_ary = $1.asArray();
 		Object[] args0 = new Object[] { classToString(MessagePackObject[].class) };
 		sb.append(String.format(STATEMENT_TMPL_CONVERTMETHODBODY_01, args0));
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 0f8cace..95c3748 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java
@@ -41,10 +41,6 @@ public class DynamicCodeGenBase implements Constants {
 	private static Logger LOG = LoggerFactory
 			.getLogger(DynamicCodeGenBase.class);
 
-	public static interface NullChecker {
-		void setNullCheck(boolean nullCheck);
-	}
-
 	public static class MessageUnpackableConvertableTemplate implements
 			Template {
 
@@ -86,23 +82,13 @@ public class DynamicCodeGenBase implements Constants {
 				throw new MessageTypeException(e.getMessage(), e);
 			}
 		}
-
-	}
-
-	public static class NullCheckerImpl implements NullChecker {
-		public boolean _$$_nullCheck = true;
-
-		public void setNullCheck(boolean _$$_check) {
-			_$$_nullCheck = _$$_check;
-		}
 	}
 
 	public static interface TemplateAccessor {
 		void setTemplates(Template[] templates);
 	}
 
-	public static class TemplateTemplate extends NullCheckerImpl implements
-			TemplateAccessor {
+	public static class TemplateAccessorImpl implements TemplateAccessor {
 		public Template[] _$$_templates;
 
 		public void setTemplates(Template[] _$$_tmpls) {
@@ -160,6 +146,12 @@ public class DynamicCodeGenBase implements Constants {
 		throw e;
 	}
 
+	protected void throwFieldSortingException(String message) {
+		DynamicCodeGenException e = new DynamicCodeGenException(message);
+		LOG.debug(e.getMessage(), e);
+		throw e;
+	}
+
 	protected static void throwMethodValidationException(Method method,
 			String message) throws DynamicCodeGenException {
 		DynamicCodeGenException e = new DynamicCodeGenException(String.format(
@@ -207,7 +199,7 @@ public class DynamicCodeGenBase implements Constants {
 
 	protected void addTemplateArrayField(CtClass newCtClass)
 			throws NotFoundException, CannotCompileException {
-		CtClass acsCtClass = pool.get(TemplateTemplate.class.getName());
+		CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
 		CtField tmplsField = acsCtClass
 				.getDeclaredField(VARIABLE_NAME_TEMPLATES);
 		CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField
@@ -217,7 +209,7 @@ public class DynamicCodeGenBase implements Constants {
 
 	protected void addSetTemplatesMethod(CtClass newCtClass)
 			throws NotFoundException, CannotCompileException {
-		CtClass acsCtClass = pool.get(TemplateTemplate.class.getName());
+		CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
 		CtMethod settmplsMethod = acsCtClass
 				.getDeclaredMethod(METHOD_NAME_SETTEMPLATES);
 		CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass,
@@ -425,8 +417,7 @@ public class DynamicCodeGenBase implements Constants {
 		Class<?> t = getArrayBaseType(type);
 		sb.append(t.getName());
 		for (int i = 0; i < dim; ++i) {
-			sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
-			sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			sb.append(STRING_NAME_LEFT_RIGHT_SQUARE_BRACKET);
 		}
 		return sb.toString();
 	}
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenException.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenException.java
index defb3c9..df1f2e7 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenException.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenException.java
@@ -1,5 +1,6 @@
 package org.msgpack.util.codegen;
 
+@SuppressWarnings("serial")
 public class DynamicCodeGenException extends RuntimeException {
 
 	public DynamicCodeGenException(String reason) {
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java b/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java
index ab599f1..8919a67 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java
@@ -1,9 +1,16 @@
 package org.msgpack.util.codegen;
 
+import java.util.List;
+
 import org.msgpack.MessageConverter;
 
 public class DynamicConverter {
 	public static MessageConverter create(Class<?> c) {
-		return DynamicTemplate.create(c);
+		return create(c, null);
+	}
+
+	public static MessageConverter create(Class<?> c,
+			List<FieldOption> fieldOpts) {
+		return DynamicTemplate.create(c, fieldOpts);
 	}
 }
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java
index 643ff52..fbd019d 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java
@@ -1,13 +1,19 @@
 package org.msgpack.util.codegen;
 
+import java.util.List;
+
 import org.msgpack.MessagePacker;
 
 public class DynamicPacker {
 
 	public static MessagePacker create(Class<?> c) {
+		return create(c, null);
+	}
+
+	public static MessagePacker create(Class<?> c, List<FieldOption> fieldOpts) {
 		try {
 			DynamicCodeGen gen = DynamicCodeGen.getInstance();
-			Class<?> packerClass = gen.generateMessagePackerClass(c);
+			Class<?> packerClass = gen.generateMessagePackerClass(c, fieldOpts);
 			return (MessagePacker) packerClass.newInstance();
 		} catch (InstantiationException e) {
 			throw new DynamicCodeGenException(e.getMessage(), e);
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java b/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java
index 60a51e8..673c344 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java
@@ -1,13 +1,19 @@
 package org.msgpack.util.codegen;
 
+import java.util.List;
+
 import org.msgpack.Template;
 import org.msgpack.util.codegen.DynamicCodeGenBase.TemplateAccessor;
 
 public class DynamicTemplate {
 	public static Template create(Class<?> c) {
+		return create(c, null);
+	}
+
+	public static Template create(Class<?> c, List<FieldOption> fieldOpts) {
 		try {
 			DynamicCodeGen gen = DynamicCodeGen.getInstance();
-			Class<?> tmplClass = gen.generateTemplateClass(c);
+			Class<?> tmplClass = gen.generateTemplateClass(c, fieldOpts);
 			Object obj = tmplClass.newInstance();
 			((TemplateAccessor) obj).setTemplates(gen.getTemplates(c));
 			return (Template) obj;
diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java
index 83590ce..8b927cb 100644
--- a/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java
+++ b/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java
@@ -1,9 +1,15 @@
 package org.msgpack.util.codegen;
 
+import java.util.List;
+
 import org.msgpack.MessageUnpacker;
 
 public class DynamicUnpacker {
 	public static MessageUnpacker create(Class<?> c) {
-		return DynamicTemplate.create(c);
+		return create(c, null);
+	}
+
+	public static MessageUnpacker create(Class<?> c, List<FieldOption> fieldOpts) {
+		return DynamicTemplate.create(c, fieldOpts);
 	}
 }
diff --git a/java/src/main/java/org/msgpack/util/codegen/FieldOption.java b/java/src/main/java/org/msgpack/util/codegen/FieldOption.java
index 723a765..127688d 100644
--- a/java/src/main/java/org/msgpack/util/codegen/FieldOption.java
+++ b/java/src/main/java/org/msgpack/util/codegen/FieldOption.java
@@ -4,7 +4,22 @@ import org.msgpack.Template;
 
 public class FieldOption {
 
-    public String name;
-    
-    public Template tmpl;
+	private static final String NULL_ERR_MSG = "param is FieldOption is null.";
+
+	String name;
+
+	Template tmpl;
+
+	public FieldOption(final String name, final Template tmpl) {
+		if (name == null) {
+			throw new NullPointerException(String.format("%s %s", new Object[] {
+					"1st", NULL_ERR_MSG }));
+		}
+		if (tmpl == null) {
+			throw new NullPointerException(String.format("%s %s", new Object[] {
+					"2nd", NULL_ERR_MSG }));
+		}
+		this.name = name;
+		this.tmpl = tmpl;
+	}
 }
diff --git a/java/src/test/java/org/msgpack/packer/TestPackConvert.java b/java/src/test/java/org/msgpack/packer/TestPackConvert.java
index 98caf82..26f3313 100644
--- a/java/src/test/java/org/msgpack/packer/TestPackConvert.java
+++ b/java/src/test/java/org/msgpack/packer/TestPackConvert.java
@@ -9,13 +9,111 @@ import junit.framework.TestCase;
 import org.junit.Test;
 import org.msgpack.MessagePackObject;
 import org.msgpack.MessagePacker;
+import org.msgpack.MessageTypeException;
 import org.msgpack.Packer;
+import org.msgpack.Template;
 import org.msgpack.Util;
+import org.msgpack.template.BigIntegerTemplate;
+import org.msgpack.template.BooleanTemplate;
+import org.msgpack.template.ByteTemplate;
+import org.msgpack.template.DoubleTemplate;
+import org.msgpack.template.FloatTemplate;
+import org.msgpack.template.IntegerTemplate;
+import org.msgpack.template.LongTemplate;
+import org.msgpack.template.OptionalTemplate;
+import org.msgpack.template.ShortTemplate;
+import org.msgpack.template.StringTemplate;
 
 public class TestPackConvert extends TestCase {
+
+	@Test
+	public void testByte() throws Exception {
+		_testByte((byte) 0);
+		_testByte((byte) -1);
+		_testByte((byte) 1);
+		_testByte(Byte.MIN_VALUE);
+		_testByte(Byte.MAX_VALUE);
+		Random rand = new Random();
+		for (int i = 0; i < 1000; i++) {
+			_testByte((byte) rand.nextInt());
+		}
+	}
+
+	static void _testByte(Byte src) throws Exception {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = BytePacker.getInstance();
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		assertEquals(src.byteValue(), obj.asByte());
+	}
+
+	@Test
+	public void testNullByte() throws Exception {
+		Byte src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BytePacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Byte dst = null;
+		try {
+			tmpl = ByteTemplate.getInstance();
+			dst = (Byte) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(ByteTemplate.getInstance());
+		dst = (Byte) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
+	public void testShort() throws Exception {
+		_testShort((short) 0);
+		_testShort((short) -1);
+		_testShort((short) 1);
+		_testShort(Short.MIN_VALUE);
+		_testShort(Short.MAX_VALUE);
+		Random rand = new Random();
+		for (int i = 0; i < 1000; i++) {
+			_testShort((short) rand.nextInt());
+		}
+	}
+
+	static void _testShort(Short src) throws Exception {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = ShortPacker.getInstance();
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		assertEquals(src.shortValue(), obj.asShort());
+	}
+
+	@Test
+	public void testNullShort() throws Exception {
+		Short src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(ShortPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Short dst = null;
+		try {
+			tmpl = ShortTemplate.getInstance();
+			dst = (Short) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(ShortTemplate.getInstance());
+		dst = (Short) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
 	@Test
 	public void testInteger() throws Exception {
-		// _testInteger(null); // FIXME
 		_testInteger(0);
 		_testInteger(-1);
 		_testInteger(1);
@@ -36,8 +134,29 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullInteger() throws Exception {
+		Integer src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(IntegerPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Integer dst = null;
+		try {
+			tmpl = IntegerTemplate.getInstance();
+			dst = (Integer) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(IntegerTemplate.getInstance());
+		dst = (Integer) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testLong() throws Exception {
-		// _testLong((null); // FIXME
 		_testLong((long) 0);
 		_testLong((long) -1);
 		_testLong((long) 1);
@@ -60,8 +179,29 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullLong() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(LongPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Long dst = null;
+		try {
+			tmpl = LongTemplate.getInstance();
+			dst = (Long) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(LongTemplate.getInstance());
+		dst = (Long) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBigInteger() throws Exception {
-		// _testBigInteger(null); // FIXME
 		_testBigInteger(BigInteger.valueOf(0));
 		_testBigInteger(BigInteger.valueOf(-1));
 		_testBigInteger(BigInteger.valueOf(1));
@@ -87,8 +227,30 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullBigInteger() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BigIntegerPacker
+				.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		BigInteger dst = null;
+		try {
+			tmpl = BigIntegerTemplate.getInstance();
+			dst = (BigInteger) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(BigIntegerTemplate.getInstance());
+		dst = (BigInteger) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testFloat() throws Exception {
-		// _testFloat(null); // FIXME
 		_testFloat((float) 0.0);
 		_testFloat((float) -0.0);
 		_testFloat((float) 1.0);
@@ -113,8 +275,29 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullFloat() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(FloatPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Float dst = null;
+		try {
+			tmpl = FloatTemplate.getInstance();
+			dst = (Float) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(FloatTemplate.getInstance());
+		dst = (Float) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testDouble() throws Exception {
-		// _testDouble(null); // FIXME
 		_testDouble((double) 0.0);
 		_testDouble((double) -0.0);
 		_testDouble((double) 1.0);
@@ -138,8 +321,29 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullDouble() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DoublePacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Double dst = null;
+		try {
+			tmpl = DoubleTemplate.getInstance();
+			dst = (Double) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(DoubleTemplate.getInstance());
+		dst = (Double) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBoolean() throws Exception {
-		// _testBoolean(null); // FIXME
 		_testBoolean(false);
 		_testBoolean(true);
 	}
@@ -153,8 +357,29 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullBoolean() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BooleanPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		Boolean dst = null;
+		try {
+			tmpl = BooleanTemplate.getInstance();
+			dst = (Boolean) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(BooleanTemplate.getInstance());
+		dst = (Boolean) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testString() throws Exception {
-		// _testString(null); // FIXME
 		_testString("");
 		_testString("a");
 		_testString("ab");
@@ -198,4 +423,26 @@ public class TestPackConvert extends TestCase {
 		MessagePackObject obj = Util.unpackOne(out.toByteArray());
 		assertEquals(src, obj.asString());
 	}
+
+	@Test
+	public void testNullString() throws Exception {
+		String src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(StringPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = null;
+		String dst = null;
+		try {
+			tmpl = StringTemplate.getInstance();
+			dst = (String) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(StringTemplate.getInstance());
+		dst = (String) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
 }
diff --git a/java/src/test/java/org/msgpack/packer/TestPackUnpack.java b/java/src/test/java/org/msgpack/packer/TestPackUnpack.java
index f1d7842..2dd631d 100644
--- a/java/src/test/java/org/msgpack/packer/TestPackUnpack.java
+++ b/java/src/test/java/org/msgpack/packer/TestPackUnpack.java
@@ -9,13 +9,117 @@ import junit.framework.TestCase;
 
 import org.junit.Test;
 import org.msgpack.MessagePacker;
+import org.msgpack.MessageTypeException;
 import org.msgpack.Packer;
+import org.msgpack.Template;
 import org.msgpack.Unpacker;
+import org.msgpack.template.BigIntegerTemplate;
+import org.msgpack.template.BooleanTemplate;
+import org.msgpack.template.ByteTemplate;
+import org.msgpack.template.DoubleTemplate;
+import org.msgpack.template.FloatTemplate;
+import org.msgpack.template.IntegerTemplate;
+import org.msgpack.template.LongTemplate;
+import org.msgpack.template.OptionalTemplate;
+import org.msgpack.template.ShortTemplate;
+import org.msgpack.template.StringTemplate;
 
 public class TestPackUnpack extends TestCase {
+
+	@Test
+	public void testByte() throws Exception {
+		_testByte((byte) 0);
+		_testByte((byte) -1);
+		_testByte((byte) 1);
+		_testByte(Byte.MIN_VALUE);
+		_testByte(Byte.MAX_VALUE);
+		Random rand = new Random();
+		for (int i = 0; i < 1000; i++) {
+			_testByte((byte) rand.nextInt());
+		}
+	}
+
+	static void _testByte(Byte src) throws Exception {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = BytePacker.getInstance();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker unpacker = new Unpacker(in);
+		assertEquals(src.byteValue(), unpacker.unpackByte());
+	}
+
+	@Test
+	public void testNullByte() throws Exception {
+		Byte src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BytePacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Byte dst = null;
+		try {
+			tmpl = ByteTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Byte) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(ByteTemplate.getInstance());
+		dst = (Byte) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
+	public void testSort() throws Exception {
+		_testShort((short) 0);
+		_testShort((short) -1);
+		_testShort((short) 1);
+		_testShort(Short.MIN_VALUE);
+		_testShort(Short.MAX_VALUE);
+		Random rand = new Random();
+		for (int i = 0; i < 1000; i++) {
+			_testShort((short) rand.nextInt());
+		}
+	}
+
+	static void _testShort(Short src) throws Exception {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = ShortPacker.getInstance();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker unpacker = new Unpacker(in);
+		assertEquals(src.shortValue(), unpacker.unpackShort());
+	}
+
+	@Test
+	public void testNullShort() throws Exception {
+		Short src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(ShortPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Short dst = null;
+		try {
+			tmpl = ShortTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Short) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(ShortTemplate.getInstance());
+		dst = (Short) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
 	@Test
 	public void testInteger() throws Exception {
-		// _testInteger(null); // FIXME
 		_testInteger(0);
 		_testInteger(-1);
 		_testInteger(1);
@@ -37,8 +141,31 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullInteger() throws Exception {
+		Integer src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(IntegerPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Integer dst = null;
+		try {
+			tmpl = IntegerTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Integer) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(IntegerTemplate.getInstance());
+		dst = (Integer) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testLong() throws Exception {
-		// _testLong((null); // FIXME
 		_testLong((long) 0);
 		_testLong((long) -1);
 		_testLong((long) 1);
@@ -62,8 +189,31 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullLong() throws Exception {
+		Integer src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(LongPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Long dst = null;
+		try {
+			tmpl = LongTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Long) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(LongTemplate.getInstance());
+		dst = (Long) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBigInteger() throws Exception {
-		// _testBigInteger(null); // FIXME
 		_testBigInteger(BigInteger.valueOf(0));
 		_testBigInteger(BigInteger.valueOf(-1));
 		_testBigInteger(BigInteger.valueOf(1));
@@ -90,8 +240,32 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullBigInteger() throws Exception {
+		BigInteger src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BigIntegerPacker
+				.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		BigInteger dst = null;
+		try {
+			tmpl = BigIntegerTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (BigInteger) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(BigIntegerTemplate.getInstance());
+		dst = (BigInteger) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testFloat() throws Exception {
-		// _testFloat(null); // FIXME
 		_testFloat((float) 0.0);
 		_testFloat((float) -0.0);
 		_testFloat((float) 1.0);
@@ -117,8 +291,31 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullFloat() throws Exception {
+		Float src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(FloatPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Float dst = null;
+		try {
+			tmpl = FloatTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Float) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(FloatTemplate.getInstance());
+		dst = (Float) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testDouble() throws Exception {
-		// _testDouble(null); // FIXME
 		_testDouble((double) 0.0);
 		_testDouble((double) -0.0);
 		_testDouble((double) 1.0);
@@ -143,8 +340,31 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullDouble() throws Exception {
+		Double src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DoublePacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Double dst = null;
+		try {
+			tmpl = DoubleTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Double) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(DoubleTemplate.getInstance());
+		dst = (Double) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBoolean() throws Exception {
-		// _testBoolean(null); // FIXME
 		_testBoolean(false);
 		_testBoolean(true);
 	}
@@ -159,8 +379,31 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullBoolean() throws Exception {
+		Boolean src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(BooleanPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Boolean dst = null;
+		try {
+			tmpl = BooleanTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Boolean) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(BooleanTemplate.getInstance());
+		dst = (Boolean) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testString() throws Exception {
-		// _testString(null); // FIXME
 		_testString("");
 		_testString("a");
 		_testString("ab");
@@ -205,4 +448,28 @@ public class TestPackUnpack extends TestCase {
 		Unpacker unpacker = new Unpacker(in);
 		assertEquals(src, unpacker.unpackString());
 	}
+
+	@Test
+	public void testNullString() throws Exception {
+		String src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(StringPacker.getInstance());
+		packer.pack(new Packer(out), src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		String dst = null;
+		try {
+			tmpl = StringTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (String) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(StringTemplate.getInstance());
+		dst = (String) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
 }
diff --git a/java/src/test/java/org/msgpack/template/TestPackConvert.java b/java/src/test/java/org/msgpack/template/TestPackConvert.java
index 15237b6..01063a5 100644
--- a/java/src/test/java/org/msgpack/template/TestPackConvert.java
+++ b/java/src/test/java/org/msgpack/template/TestPackConvert.java
@@ -10,6 +10,7 @@ import java.util.Random;
 
 import org.junit.Test;
 import org.msgpack.MessagePackObject;
+import org.msgpack.MessageTypeException;
 import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Util;
@@ -20,7 +21,6 @@ public class TestPackConvert extends TestCase {
 
 	@Test
 	public void testInteger() throws Exception {
-		// _testInteger(null); // FIXME
 		_testInteger(0);
 		_testInteger(-1);
 		_testInteger(1);
@@ -42,8 +42,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullInteger() throws Exception {
+		Integer src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = IntegerTemplate.getInstance();
+		Integer dst = null;
+		try {
+			dst = (Integer) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(IntegerTemplate.getInstance());
+		dst = (Integer) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testLong() throws Exception {
-		// _testLong(null); // FIXME
 		_testLong((long) 0);
 		_testLong((long) -1);
 		_testLong((long) 1);
@@ -67,8 +86,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullLong() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = LongTemplate.getInstance();
+		Long dst = null;
+		try {
+			dst = (Long) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(LongTemplate.getInstance());
+		dst = (Long) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBiginteger() throws Exception {
-		// _testBigInteger(null); // FIXME
 		_testBigInteger(BigInteger.valueOf(0));
 		_testBigInteger(BigInteger.valueOf(-1));
 		_testBigInteger(BigInteger.valueOf(1));
@@ -95,8 +133,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullBigInteger() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = BigIntegerTemplate.getInstance();
+		BigInteger dst = null;
+		try {
+			dst = (BigInteger) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(BigIntegerTemplate.getInstance());
+		dst = (BigInteger) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testFloat() throws Exception {
-		// _testFloat(null); // FIXME
 		_testFloat((float) 0.0);
 		_testFloat((float) -0.0);
 		_testFloat((float) 1.0);
@@ -122,8 +179,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullFloat() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = FloatTemplate.getInstance();
+		Float dst = null;
+		try {
+			dst = (Float) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(FloatTemplate.getInstance());
+		dst = (Float) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testDouble() throws Exception {
-		// _testDouble(null); // FIXME
 		_testDouble((double) 0.0);
 		_testDouble((double) -0.0);
 		_testDouble((double) 1.0);
@@ -149,8 +225,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullDouble() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = DoubleTemplate.getInstance();
+		Double dst = null;
+		try {
+			dst = (Double) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(DoubleTemplate.getInstance());
+		dst = (Double) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBoolean() throws Exception {
-		// _testBoolean(null); // FIXME
 		_testBoolean(false);
 		_testBoolean(true);
 	}
@@ -165,8 +260,27 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testNullBoolean() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = BooleanTemplate.getInstance();
+		Boolean dst = null;
+		try {
+			dst = (Boolean) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(BooleanTemplate.getInstance());
+		dst = (Boolean) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testString() throws Exception {
-		// _testString(null); // FIXME
 		_testString("");
 		_testString("a");
 		_testString("ab");
@@ -212,10 +326,29 @@ public class TestPackConvert extends TestCase {
 		assertEquals(src, dst);
 	}
 
+	@Test
+	public void testNullString() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = StringTemplate.getInstance();
+		String dst = null;
+		try {
+			dst = (String) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(StringTemplate.getInstance());
+		dst = (String) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testList() throws Exception {
-		// nullList // FIXME
 		List<Integer> emptyList = new ArrayList<Integer>();
 		{
 			ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -263,8 +396,29 @@ public class TestPackConvert extends TestCase {
 
 	@SuppressWarnings("unchecked")
 	@Test
+	public void testNullList() throws Exception {
+		List<String> src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = new ListTemplate(StringTemplate.getInstance());
+		List<String> dst = null;
+		try {
+			dst = (List<String>) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(new ListTemplate(StringTemplate
+				.getInstance()));
+		dst = (List<String>) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Test
 	public void testMap() throws Exception {
-		// nullMap // FIXME
 		Map<Integer, Integer> emptyMap = new HashMap<Integer, Integer>();
 		{
 			ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -317,4 +471,27 @@ public class TestPackConvert extends TestCase {
 			}
 		}
 	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void testNullMap() throws Exception {
+		Map<String, String> src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		MessagePackObject obj = Util.unpackOne(out.toByteArray());
+		Template tmpl = new MapTemplate(StringTemplate.getInstance(),
+				StringTemplate.getInstance());
+		Map<String, String> dst = null;
+		try {
+			dst = (Map<String, String>) tmpl.convert(obj);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		obj = Util.unpackOne(out.toByteArray());
+		tmpl = new OptionalTemplate(new MapTemplate(StringTemplate
+				.getInstance(), StringTemplate.getInstance()));
+		dst = (Map<String, String>) tmpl.convert(obj);
+		assertEquals(src, dst);
+	}
 }
diff --git a/java/src/test/java/org/msgpack/template/TestPackUnpack.java b/java/src/test/java/org/msgpack/template/TestPackUnpack.java
index fbd510f..29ee78d 100644
--- a/java/src/test/java/org/msgpack/template/TestPackUnpack.java
+++ b/java/src/test/java/org/msgpack/template/TestPackUnpack.java
@@ -10,6 +10,7 @@ import java.util.Map;
 import java.util.Random;
 
 import org.junit.Test;
+import org.msgpack.MessageTypeException;
 import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Unpacker;
@@ -19,7 +20,6 @@ import junit.framework.TestCase;
 public class TestPackUnpack extends TestCase {
 	@Test
 	public void testInteger() throws Exception {
-		// _testInteger(null); // FIXME
 		_testInteger(0);
 		_testInteger(-1);
 		_testInteger(1);
@@ -41,8 +41,30 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullInteger() throws Exception {
+		Integer src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Integer dst = null;
+		try {
+			tmpl = IntegerTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Integer) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(IntegerTemplate.getInstance());
+		dst = (Integer) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testLong() throws Exception {
-		// _testLong(null); // FIXME
 		_testLong((long) 0);
 		_testLong((long) -1);
 		_testLong((long) 1);
@@ -66,8 +88,30 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullLong() throws Exception {
+		Long src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Long dst = null;
+		try {
+			tmpl = LongTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Long) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(LongTemplate.getInstance());
+		dst = (Long) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBigInteger() throws Exception {
-		// _testBigInteger(null); // FIXME
 		_testBigInteger(BigInteger.valueOf(0));
 		_testBigInteger(BigInteger.valueOf(-1));
 		_testBigInteger(BigInteger.valueOf(1));
@@ -94,8 +138,30 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullBigInteger() throws Exception {
+		BigInteger src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		BigInteger dst = null;
+		try {
+			tmpl = BigIntegerTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (BigInteger) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(BigIntegerTemplate.getInstance());
+		dst = (BigInteger) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testFloat() throws Exception {
-		// _testFloat(null); // FIXME
 		_testFloat((float) 0.0);
 		_testFloat((float) -0.0);
 		_testFloat((float) 1.0);
@@ -122,7 +188,6 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testDouble() throws Exception {
-		// _testDouble(null); // FIXME
 		_testDouble((double) 0.0);
 		_testDouble((double) -0.0);
 		_testDouble((double) 1.0);
@@ -148,8 +213,30 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullDouble() throws Exception {
+		Double src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Double dst = null;
+		try {
+			tmpl = DoubleTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Double) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(DoubleTemplate.getInstance());
+		dst = (Double) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testBoolean() throws Exception {
-		// _testBoolean(null); // FIXME
 		_testBoolean(false);
 		_testBoolean(true);
 	}
@@ -164,8 +251,30 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testNullBoolean() throws Exception {
+		Boolean src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Boolean dst = null;
+		try {
+			tmpl = BooleanTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (Boolean) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(BooleanTemplate.getInstance());
+		dst = (Boolean) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@Test
 	public void testString() throws Exception {
-		// _testString(null); // FIXME
 		_testString("");
 		_testString("a");
 		_testString("ab");
@@ -211,10 +320,32 @@ public class TestPackUnpack extends TestCase {
 		assertEquals(src, dst);
 	}
 
+	@Test
+	public void testNullString() throws Exception {
+		String src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		String dst = null;
+		try {
+			tmpl = StringTemplate.getInstance();
+			unpacker.wrap(bytes);
+			dst = (String) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(StringTemplate.getInstance());
+		dst = (String) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testList() throws Exception {
-		// nullList // FIXME
 		List<Integer> emptyList = new ArrayList<Integer>();
 		{
 			ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -264,8 +395,32 @@ public class TestPackUnpack extends TestCase {
 
 	@SuppressWarnings("unchecked")
 	@Test
+	public void testNullList() throws Exception {
+		List<String> src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		List<String> dst = null;
+		try {
+			tmpl = new ListTemplate(StringTemplate.getInstance());
+			unpacker.wrap(bytes);
+			dst = (List<String>) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(new ListTemplate(StringTemplate
+				.getInstance()));
+		dst = (List<String>) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Test
 	public void testMap() throws Exception {
-		// nullMap // FIXME
 		Map<Integer, Integer> emptyMap = new HashMap<Integer, Integer>();
 		{
 			ByteArrayOutputStream out = new ByteArrayOutputStream();
@@ -323,4 +478,30 @@ public class TestPackUnpack extends TestCase {
 			}
 		}
 	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void testNullMap() throws Exception {
+		Map<String, String> src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		byte[] bytes = out.toByteArray();
+		Template tmpl = null;
+		Unpacker unpacker = new Unpacker();
+		Map<String, String> dst = null;
+		try {
+			tmpl = new MapTemplate(StringTemplate.getInstance(), StringTemplate
+					.getInstance());
+			unpacker.wrap(bytes);
+			dst = (Map<String, String>) tmpl.unpack(unpacker);
+			fail();
+		} catch (Exception e) {
+			assertTrue(e instanceof MessageTypeException);
+		}
+		unpacker.wrap(bytes);
+		tmpl = new OptionalTemplate(new MapTemplate(StringTemplate
+				.getInstance(), StringTemplate.getInstance()));
+		dst = (Map<String, String>) tmpl.unpack(unpacker);
+		assertEquals(src, dst);
+	}
 }
diff --git a/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java b/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java
index d2cf35c..63532a0 100644
--- a/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java
+++ b/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java
@@ -25,12 +25,15 @@ import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Unpacker;
 import org.msgpack.annotation.MessagePackMessage;
+import org.msgpack.annotation.MessagePackOptional;
 import org.msgpack.annotation.MessagePackOrdinalEnum;
+import org.msgpack.packer.OptionalPacker;
+import org.msgpack.template.OptionalTemplate;
 
 public class TestPackConvert extends TestCase {
 
 	@Test
-	public void testPrimitiveTypeField00s() throws Exception {
+	public void testPrimitiveTypeFields00() throws Exception {
 		PrimitiveTypeFieldsClass src = new PrimitiveTypeFieldsClass();
 		src.f0 = (byte) 0;
 		src.f1 = 1;
@@ -63,19 +66,60 @@ public class TestPackConvert extends TestCase {
 
 	@Test
 	public void testPrimitiveTypeFields01() throws Exception {
-		PrimitiveTypeFieldsClass src = new PrimitiveTypeFieldsClass();
+		PrimitiveTypeFieldsClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(PrimitiveTypeFieldsClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(PrimitiveTypeFieldsClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(PrimitiveTypeFieldsClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(PrimitiveTypeFieldsClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
 		PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl
 				.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class PrimitiveTypeFieldsClass {
+		public byte f0;
+		public short f1;
+		public int f2;
+		public long f3;
+		public float f4;
+		public double f5;
+		public boolean f6;
+
+		public PrimitiveTypeFieldsClass() {
+		}
+	}
+
+	@Test
+	public void testOptionalPrimitiveTypeFields00() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = new OptionalPrimitiveTypeFieldsClass();
+		src.f0 = (byte) 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f6 = false;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
+				.convert(mpo);
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
 		assertEquals(src.f2, dst.f2);
@@ -87,34 +131,68 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testPrimitiveTypeFields02() throws Exception {
-		PrimitiveTypeFieldsClass src = null;
+	public void testOptionalPrimitiveTypeFields01() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = new OptionalPrimitiveTypeFieldsClass();
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker
-				.create(PrimitiveTypeFieldsClass.class);
+				.create(OptionalPrimitiveTypeFieldsClass.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(PrimitiveTypeFieldsClass.class);
+		Template tmpl = DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class);
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
+				.convert(mpo);
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalPrimitiveTypeFields02() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalPrimitiveTypeFieldsClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class));
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
 				.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class PrimitiveTypeFieldsClass {
+	public static class OptionalPrimitiveTypeFieldsClass {
+		@MessagePackOptional
 		public byte f0;
+		@MessagePackOptional
 		public short f1;
+		@MessagePackOptional
 		public int f2;
+		@MessagePackOptional
 		public long f3;
+		@MessagePackOptional
 		public float f4;
+		@MessagePackOptional
 		public double f5;
+		@MessagePackOptional
 		public boolean f6;
 
-		public PrimitiveTypeFieldsClass() {
+		public OptionalPrimitiveTypeFieldsClass() {
 		}
 	}
 
@@ -159,8 +237,86 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void XtestGeneralReferenceTypeFieldsClass01() throws Exception {
-		GeneralReferenceTypeFieldsClass src = new GeneralReferenceTypeFieldsClass();
+	public void testGeneralReferenceTypeFieldsClass01() throws Exception {
+		GeneralReferenceTypeFieldsClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(GeneralReferenceTypeFieldsClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(GeneralReferenceTypeFieldsClass.class));
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+				.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class GeneralReferenceTypeFieldsClass {
+		public Byte f0;
+		public Short f1;
+		public Integer f2;
+		public Long f3;
+		public Float f4;
+		public Double f5;
+		public Boolean f6;
+		public BigInteger f7;
+		public String f8;
+		public byte[] f9;
+
+		public GeneralReferenceTypeFieldsClass() {
+		}
+	}
+
+	@Test
+	public void testOptionalGeneralReferenceTypeFieldsClass00()
+			throws Exception {
+		OptionalGeneralReferenceTypeFieldsClass src = new OptionalGeneralReferenceTypeFieldsClass();
+		src.f0 = 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = (long) 3;
+		src.f4 = (float) 4;
+		src.f5 = (double) 5;
+		src.f6 = false;
+		src.f7 = new BigInteger("7");
+		src.f8 = "8";
+		src.f9 = new byte[] { 0x01, 0x02 };
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(OptionalGeneralReferenceTypeFieldsClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalGeneralReferenceTypeFieldsClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalGeneralReferenceTypeFieldsClass dst = (OptionalGeneralReferenceTypeFieldsClass) tmpl
+				.convert(mpo);
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+		assertEquals(src.f7, dst.f7);
+		assertEquals(src.f8, dst.f8);
+		assertEquals(src.f9[0], dst.f9[0]);
+		assertEquals(src.f9[1], dst.f9[1]);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalGeneralReferenceTypeFieldsClass01()
+			throws Exception {
+		OptionalGeneralReferenceTypeFieldsClass src = new OptionalGeneralReferenceTypeFieldsClass();
 		src.f0 = null;
 		src.f1 = null;
 		src.f2 = null;
@@ -173,16 +329,16 @@ public class TestPackConvert extends TestCase {
 		src.f9 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker
-				.create(GeneralReferenceTypeFieldsClass.class);
+				.create(OptionalGeneralReferenceTypeFieldsClass.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Template tmpl = DynamicTemplate
-				.create(GeneralReferenceTypeFieldsClass.class);
+				.create(OptionalGeneralReferenceTypeFieldsClass.class);
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+		OptionalGeneralReferenceTypeFieldsClass dst = (OptionalGeneralReferenceTypeFieldsClass) tmpl
 				.convert(mpo);
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
@@ -198,38 +354,49 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void XtestGeneralReferenceTypeFieldsClass02() throws Exception {
-		GeneralReferenceTypeFieldsClass src = null;
+	public void testOptionalGeneralReferenceTypeFieldsClass02()
+			throws Exception {
+		OptionalGeneralReferenceTypeFieldsClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(GeneralReferenceTypeFieldsClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalGeneralReferenceTypeFieldsClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate
-				.create(GeneralReferenceTypeFieldsClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalGeneralReferenceTypeFieldsClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+		OptionalGeneralReferenceTypeFieldsClass dst = (OptionalGeneralReferenceTypeFieldsClass) tmpl
 				.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class GeneralReferenceTypeFieldsClass {
+	public static class OptionalGeneralReferenceTypeFieldsClass {
+		@MessagePackOptional
 		public Byte f0;
+		@MessagePackOptional
 		public Short f1;
+		@MessagePackOptional
 		public Integer f2;
+		@MessagePackOptional
 		public Long f3;
+		@MessagePackOptional
 		public Float f4;
+		@MessagePackOptional
 		public Double f5;
+		@MessagePackOptional
 		public Boolean f6;
+		@MessagePackOptional
 		public BigInteger f7;
+		@MessagePackOptional
 		public String f8;
+		@MessagePackOptional
 		public byte[] f9;
 
-		public GeneralReferenceTypeFieldsClass() {
+		public OptionalGeneralReferenceTypeFieldsClass() {
 		}
 	}
 
@@ -293,22 +460,123 @@ public class TestPackConvert extends TestCase {
 
 	@Test
 	public void testListTypes01() throws Exception {
-		SampleListTypes src = new SampleListTypes();
+		SampleListTypes src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleListTypes.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleListTypes.class));
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleListTypes dst = (SampleListTypes) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class SampleListTypes {
+		public List<Integer> f0;
+		public List<Integer> f1;
+		public List<String> f2;
+		public List<List<String>> f3;
+		public List<SampleListNestedType> f4;
+
+		public SampleListTypes() {
+		}
+	}
+
+	@MessagePackMessage
+	public static class SampleListNestedType {
+		public byte[] f0;
+		public String f1;
+
+		public SampleListNestedType() {
+		}
+	}
+
+	@Test
+	public void testOptionalListTypes00() throws Exception {
+		SampleOptionalListTypes src = new SampleOptionalListTypes();
+		src.f0 = new ArrayList<Integer>();
+		src.f1 = new ArrayList<Integer>();
+		src.f1.add(1);
+		src.f1.add(2);
+		src.f1.add(3);
+		src.f2 = new ArrayList<String>();
+		src.f2.add("e1");
+		src.f2.add("e2");
+		src.f2.add("e3");
+		src.f3 = new ArrayList<List<String>>();
+		src.f3.add(src.f2);
+		src.f4 = new ArrayList<SampleOptionalListNestedType>();
+		SampleOptionalListNestedType slnt = new SampleOptionalListNestedType();
+		slnt.f0 = new byte[] { 0x01, 0x02 };
+		slnt.f1 = "muga";
+		src.f4.add(slnt);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalListTypes.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalListTypes.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl
+				.convert(mpo);
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		for (int i = 0; i < src.f1.size(); ++i) {
+			assertEquals(src.f1.get(i), dst.f1.get(i));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		for (int i = 0; i < src.f2.size(); ++i) {
+			assertEquals(src.f2.get(i), dst.f2.get(i));
+		}
+		assertEquals(src.f3.size(), dst.f3.size());
+		for (int i = 0; i < src.f3.size(); ++i) {
+			List<String> srclist = src.f3.get(i);
+			List<String> dstlist = dst.f3.get(i);
+			assertEquals(srclist.size(), dstlist.size());
+			for (int j = 0; j < srclist.size(); ++j) {
+				assertEquals(srclist.get(j), dstlist.get(j));
+			}
+		}
+		assertEquals(src.f4.size(), dst.f4.size());
+		for (int i = 0; i < src.f4.size(); ++i) {
+			SampleOptionalListNestedType s = src.f4.get(i);
+			SampleOptionalListNestedType d = dst.f4.get(i);
+			assertEquals(s.f0[0], d.f0[0]);
+			assertEquals(s.f0[1], d.f0[1]);
+			assertEquals(s.f1, d.f1);
+		}
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalListTypes01() throws Exception {
+		SampleOptionalListTypes src = new SampleOptionalListTypes();
 		src.f0 = new ArrayList<Integer>();
 		src.f1 = null;
 		src.f2 = new ArrayList<String>();
 		src.f3 = null;
-		src.f4 = new ArrayList<SampleListNestedType>();
+		src.f4 = new ArrayList<SampleOptionalListNestedType>();
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleListTypes.class);
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalListTypes.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleListTypes.class);
+		Template tmpl = DynamicTemplate.create(SampleOptionalListTypes.class);
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		SampleListTypes dst = (SampleListTypes) tmpl.convert(mpo);
+		SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl
+				.convert(mpo);
 		assertEquals(src.f0.size(), dst.f0.size());
 		assertEquals(src.f1, dst.f1);
 		assertEquals(src.f2.size(), dst.f2.size());
@@ -318,39 +586,49 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testListTypes02() throws Exception {
-		SampleListTypes src = null;
+	public void testOptionalListTypes02() throws Exception {
+		SampleOptionalListTypes src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleListTypes.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalListTypes.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleListTypes.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalListTypes.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		SampleListTypes dst = (SampleListTypes) tmpl.convert(mpo);
+		SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl
+				.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class SampleListTypes {
+	public static class SampleOptionalListTypes {
+		@MessagePackOptional
 		public List<Integer> f0;
+		@MessagePackOptional
 		public List<Integer> f1;
+		@MessagePackOptional
 		public List<String> f2;
+		@MessagePackOptional
 		public List<List<String>> f3;
-		public List<SampleListNestedType> f4;
+		@MessagePackOptional
+		public List<SampleOptionalListNestedType> f4;
 
-		public SampleListTypes() {
+		public SampleOptionalListTypes() {
 		}
 	}
 
 	@MessagePackMessage
-	public static class SampleListNestedType {
+	public static class SampleOptionalListNestedType {
+		@MessagePackOptional
 		public byte[] f0;
+		@MessagePackOptional
 		public String f1;
 
-		public SampleListNestedType() {
+		public SampleOptionalListNestedType() {
 		}
 	}
 
@@ -399,21 +677,95 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testMapTypes01() throws Exception {
-		SampleMapTypes src = new SampleMapTypes();
+	public void testMapTypes02() throws Exception {
+		SampleMapTypes src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleMapTypes.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleMapTypes.class));
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleMapTypes dst = (SampleMapTypes) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class SampleMapTypes {
+		public Map<Integer, Integer> f0;
+		public Map<Integer, Integer> f1;
+		public Map<String, Integer> f2;
+
+		public SampleMapTypes() {
+		}
+	}
+
+	@Test
+	public void testOptionalMapTypes00() throws Exception {
+		SampleOptionalMapTypes src = new SampleOptionalMapTypes();
+		src.f0 = new HashMap<Integer, Integer>();
+		src.f1 = new HashMap<Integer, Integer>();
+		src.f1.put(1, 1);
+		src.f1.put(2, 2);
+		src.f1.put(3, 3);
+		src.f2 = new HashMap<String, Integer>();
+		src.f2.put("k1", 1);
+		src.f2.put("k2", 2);
+		src.f2.put("k3", 3);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalMapTypes.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalMapTypes.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl.convert(mpo);
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		Iterator<Integer> srcf1 = src.f1.keySet().iterator();
+		Iterator<Integer> dstf1 = dst.f1.keySet().iterator();
+		while (srcf1.hasNext()) {
+			Integer s1 = srcf1.next();
+			Integer d1 = dstf1.next();
+			assertEquals(s1, d1);
+			assertEquals(src.f1.get(s1), dst.f1.get(d1));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		Iterator<String> srcf2 = src.f2.keySet().iterator();
+		Iterator<String> dstf2 = dst.f2.keySet().iterator();
+		while (srcf2.hasNext()) {
+			String s2 = srcf2.next();
+			String d2 = dstf2.next();
+			assertEquals(s2, d2);
+			assertEquals(src.f2.get(s2), dst.f2.get(d2));
+		}
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalMapTypes01() throws Exception {
+		SampleOptionalMapTypes src = new SampleOptionalMapTypes();
 		src.f0 = new HashMap<Integer, Integer>();
 		src.f1 = null;
 		src.f2 = new HashMap<String, Integer>();
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleMapTypes.class);
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalMapTypes.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
+		Template tmpl = DynamicTemplate.create(SampleOptionalMapTypes.class);
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		SampleMapTypes dst = (SampleMapTypes) tmpl.convert(mpo);
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl.convert(mpo);
 		assertEquals(src.f0.size(), dst.f0.size());
 		assertEquals(src.f1, dst.f1);
 		assertEquals(src.f2.size(), dst.f2.size());
@@ -421,28 +773,33 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testMapTypes02() throws Exception {
-		SampleMapTypes src = null;
+	public void testOptionalMapTypes02() throws Exception {
+		SampleOptionalMapTypes src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleMapTypes.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalMapTypes.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalMapTypes.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		SampleMapTypes dst = (SampleMapTypes) tmpl.convert(mpo);
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class SampleMapTypes {
+	public static class SampleOptionalMapTypes {
+		@MessagePackOptional
 		public Map<Integer, Integer> f0;
+		@MessagePackOptional
 		public Map<Integer, Integer> f1;
+		@MessagePackOptional
 		public Map<String, Integer> f2;
 
-		public SampleMapTypes() {
+		public SampleOptionalMapTypes() {
 		}
 	}
 
@@ -687,51 +1044,113 @@ public class TestPackConvert extends TestCase {
 
 	@Test
 	public void testEnumTypeForOrdinal01() throws Exception {
-		SampleEnumFieldClass src = new SampleEnumFieldClass();
-		src.f1 = null;
+		SampleEnumFieldClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleEnumFieldClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleEnumFieldClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
 		SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class SampleEnumFieldClass {
+		public int f0;
+		public SampleEnum f1;
+
+		public SampleEnumFieldClass() {
+		}
+	}
+
+	@MessagePackOrdinalEnum
+	public enum SampleEnum {
+		ONE, TWO, THREE;
+	}
+
+	@Test
+	public void testOptionalEnumTypeForOrdinal00() throws Exception {
+		SampleOptionalEnumFieldClass src = new SampleOptionalEnumFieldClass();
+		src.f0 = 0;
+		src.f1 = SampleOptionalEnum.ONE;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalEnumFieldClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(SampleOptionalEnumFieldClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl
+				.convert(mpo);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalEnumTypeForOrdinal01() throws Exception {
+		SampleOptionalEnumFieldClass src = new SampleOptionalEnumFieldClass();
+		src.f1 = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalEnumFieldClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(SampleOptionalEnumFieldClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl
+				.convert(mpo);
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
 		assertFalse(it.hasNext());
 	}
 
 	@Test
-	public void testEnumTypeForOrdinal02() throws Exception {
-		SampleEnumFieldClass src = null;
+	public void testOptionalEnumTypeForOrdinal02() throws Exception {
+		SampleOptionalEnumFieldClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalEnumFieldClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalEnumFieldClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl.convert(mpo);
+		SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl
+				.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class SampleEnumFieldClass {
+	public static class SampleOptionalEnumFieldClass {
+		@MessagePackOptional
 		public int f0;
+		@MessagePackOptional
+		public SampleOptionalEnum f1;
 
-		public SampleEnum f1;
-
-		public SampleEnumFieldClass() {
+		public SampleOptionalEnumFieldClass() {
 		}
 	}
 
 	@MessagePackOrdinalEnum
-	public enum SampleEnum {
+	public enum SampleOptionalEnum {
 		ONE, TWO, THREE;
 	}
 
@@ -772,6 +1191,47 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testOptionalFieldModifiers() throws Exception {
+		OptionalFieldModifiersClass src = new OptionalFieldModifiersClass();
+		src.f0 = 0;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(OptionalFieldModifiersClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalFieldModifiersClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalFieldModifiersClass dst = (OptionalFieldModifiersClass) tmpl
+				.convert(mpo);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 != dst.f3);
+		assertTrue(src.f4 != dst.f4);
+		assertFalse(it.hasNext());
+	}
+
+	public static class OptionalFieldModifiersClass {
+		@MessagePackOptional
+		public int f0;
+		@MessagePackOptional
+		public final int f1 = 1;
+		private int f2;
+		protected int f3;
+		int f4;
+
+		public OptionalFieldModifiersClass() {
+		}
+	}
+
+	@Test
 	public void testNestedFieldClass00() throws Exception {
 		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
 		CustomPacker.register(NestedClass.class, packer2);
@@ -802,68 +1262,145 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testNestedFieldClass01() throws Exception {
+	public void testNestedFieldClass02() throws Exception {
 		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
 		CustomPacker.register(NestedClass.class, packer2);
-		MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
-		CustomPacker.register(BaseClass.class, packer1);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseClass.class));
+		CustomPacker.register(BaseClass.class, packer);
 		Template tmpl2 = DynamicTemplate.create(NestedClass.class);
 		CustomUnpacker.register(NestedClass.class, tmpl2);
 		CustomConverter.register(NestedClass.class, tmpl2);
-		Template tmpl1 = DynamicTemplate.create(BaseClass.class);
-		CustomUnpacker.register(BaseClass.class, tmpl1);
-		CustomConverter.register(BaseClass.class, tmpl1);
-		BaseClass src = new BaseClass();
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(BaseClass.class));
+		CustomUnpacker.register(BaseClass.class, tmpl);
+		CustomConverter.register(BaseClass.class, tmpl);
+		BaseClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		packer1.pack(new Packer(out), src);
+		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		BaseClass dst = (BaseClass) tmpl1.convert(mpo);
+		BaseClass dst = (BaseClass) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class BaseClass {
+		public int f0;
+		public NestedClass f1;
+
+		public BaseClass() {
+		}
+	}
+
+	public static class NestedClass {
+		public int f2;
+
+		public NestedClass() {
+		}
+	}
+
+	@Test
+	public void testOptionalNestedFieldClass00() throws Exception {
+		MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
+		CustomPacker.register(OptionalNestedClass.class, packer2);
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
+		CustomPacker.register(OptionalBaseClass.class, packer);
+		Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
+		CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
+		CustomConverter.register(OptionalNestedClass.class, tmpl2);
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
+		CustomUnpacker.register(OptionalBaseClass.class, tmpl);
+		CustomConverter.register(OptionalBaseClass.class, tmpl);
+		OptionalBaseClass src = new OptionalBaseClass();
+		OptionalNestedClass src2 = new OptionalNestedClass();
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalBaseClass dst = (OptionalBaseClass) tmpl.convert(mpo);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1.f2 == dst.f1.f2);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalNestedFieldClass01() throws Exception {
+		MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
+		CustomPacker.register(OptionalNestedClass.class, packer2);
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
+		CustomPacker.register(OptionalBaseClass.class, packer);
+		Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
+		CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
+		CustomConverter.register(OptionalNestedClass.class, tmpl2);
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
+		CustomUnpacker.register(OptionalBaseClass.class, tmpl);
+		CustomConverter.register(OptionalBaseClass.class, tmpl);
+		OptionalBaseClass src = new OptionalBaseClass();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalBaseClass dst = (OptionalBaseClass) tmpl.convert(mpo);
 		assertTrue(src.f0 == dst.f0);
 		assertEquals(src.f1, dst.f1);
 		assertFalse(it.hasNext());
 	}
 
 	@Test
-	public void testNestedFieldClass02() throws Exception {
+	public void testOptionalNestedFieldClass02() throws Exception {
 		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
 		CustomPacker.register(NestedClass.class, packer2);
-		MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
-		CustomPacker.register(BaseClass.class, packer1);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseClass.class));
+		CustomPacker.register(BaseClass.class, packer);
 		Template tmpl2 = DynamicTemplate.create(NestedClass.class);
 		CustomUnpacker.register(NestedClass.class, tmpl2);
 		CustomConverter.register(NestedClass.class, tmpl2);
-		Template tmpl1 = DynamicTemplate.create(BaseClass.class);
-		CustomUnpacker.register(BaseClass.class, tmpl1);
-		CustomConverter.register(BaseClass.class, tmpl1);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(BaseClass.class));
+		CustomUnpacker.register(BaseClass.class, tmpl);
+		CustomConverter.register(BaseClass.class, tmpl);
 		BaseClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		packer1.pack(new Packer(out), src);
+		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		BaseClass dst = (BaseClass) tmpl1.convert(mpo);
+		BaseClass dst = (BaseClass) tmpl.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class BaseClass {
+	public static class OptionalBaseClass {
+		@MessagePackOptional
 		public int f0;
-		public NestedClass f1;
+		@MessagePackOptional
+		public OptionalNestedClass f1;
 
-		public BaseClass() {
+		public OptionalBaseClass() {
 		}
 	}
 
-	public static class NestedClass {
+	public static class OptionalNestedClass {
+		@MessagePackOptional
 		public int f2;
 
-		public NestedClass() {
+		public OptionalNestedClass() {
 		}
 	}
 
@@ -890,53 +1427,115 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testMessagePackMessageFieldClass01() throws Exception {
-		BaseClass2 src = new BaseClass2();
+	public void testMessagePackMessageFieldClass02() throws Exception {
+		BaseClass2 src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(BaseClass2.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseClass2.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		Template tmpl = DynamicTemplate.create(BaseClass2.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(BaseClass2.class));
 		BaseClass2 dst = (BaseClass2) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class BaseClass2 {
+		public int f0;
+		public MessagePackMessageClass2 f1;
+
+		public BaseClass2() {
+		}
+	}
+
+	@MessagePackMessage
+	public static class MessagePackMessageClass2 {
+		public int f2;
+
+		public MessagePackMessageClass2() {
+		}
+	}
+
+	@Test
+	public void testOptionalMessagePackMessageFieldClass00() throws Exception {
+		OptionalBaseClass2 src = new OptionalBaseClass2();
+		OptionalMessagePackMessageClass2 src2 = new OptionalMessagePackMessageClass2();
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass2.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass2.class);
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.convert(mpo);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1.f2 == dst.f1.f2);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalMessagePackMessageFieldClass01() throws Exception {
+		OptionalBaseClass2 src = new OptionalBaseClass2();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass2.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass2.class);
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.convert(mpo);
 		assertTrue(src.f0 == dst.f0);
 		assertEquals(src.f1, dst.f1);
 		assertFalse(it.hasNext());
 	}
 
 	@Test
-	public void testMessagePackMessageFieldClass02() throws Exception {
-		BaseClass2 src = null;
+	public void testOptionalMessagePackMessageFieldClass02() throws Exception {
+		OptionalBaseClass2 src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(BaseClass2.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalBaseClass2.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		Template tmpl = DynamicTemplate.create(BaseClass2.class);
-		BaseClass2 dst = (BaseClass2) tmpl.convert(mpo);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalBaseClass2.class));
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class BaseClass2 {
+	public static class OptionalBaseClass2 {
+		@MessagePackOptional
 		public int f0;
-		public MessagePackMessageClass2 f1;
+		@MessagePackOptional
+		public OptionalMessagePackMessageClass2 f1;
 
-		public BaseClass2() {
+		public OptionalBaseClass2() {
 		}
 	}
 
 	@MessagePackMessage
-	public static class MessagePackMessageClass2 {
+	public static class OptionalMessagePackMessageClass2 {
+		@MessagePackOptional
 		public int f2;
 
-		public MessagePackMessageClass2() {
+		public OptionalMessagePackMessageClass2() {
 		}
 	}
 
@@ -976,10 +1575,12 @@ public class TestPackConvert extends TestCase {
 	public void testExtendedClass01() throws Exception {
 		SampleSubClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleSubClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleSubClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleSubClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleSubClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
@@ -1013,6 +1614,83 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
+	public void testOptionalExtendedClass00() throws Exception {
+		SampleOptionalSubClass src = new SampleOptionalSubClass();
+		src.f0 = 0;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f8 = 8;
+		src.f9 = 9;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalSubClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalSubClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalSubClass dst = (SampleOptionalSubClass) tmpl.convert(mpo);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 != dst.f3);
+		assertTrue(src.f4 != dst.f4);
+		assertTrue(src.f5 == dst.f5);
+		assertTrue(src.f6 == dst.f6);
+		assertTrue(src.f8 != dst.f8);
+		assertTrue(src.f9 != dst.f9);
+		assertFalse(it.hasNext());
+	}
+
+	@Test
+	public void testOptionalExtendedClass01() throws Exception {
+		SampleOptionalSubClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalSubClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalSubClass.class));
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleOptionalSubClass dst = (SampleOptionalSubClass) tmpl.convert(mpo);
+		assertEquals(src, dst);
+		assertFalse(it.hasNext());
+	}
+
+	public static class SampleOptionalSubClass extends SampleOptionalSuperClass {
+		@MessagePackOptional
+		public int f0;
+		public final int f1 = 1;
+		private int f2;
+		protected int f3;
+		int f4;
+
+		public SampleOptionalSubClass() {
+		}
+	}
+
+	public static class SampleOptionalSuperClass {
+		@MessagePackOptional
+		public int f5;
+		public final int f6 = 2;
+		@SuppressWarnings("unused")
+		private int f7;
+		protected int f8;
+		int f9;
+
+		public SampleOptionalSuperClass() {
+		}
+	}
+
+	@Test
 	public void testMessagePackableUnpackableClass00() throws Exception {
 		BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass();
 		MessagePackableConvertableClass src1 = new MessagePackableConvertableClass();
@@ -1047,22 +1725,111 @@ public class TestPackConvert extends TestCase {
 
 	@Test
 	public void testMessagePackableUnpackableClass01() throws Exception {
-		BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass();
+		BaseMessagePackableConvertableClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseMessagePackableConvertableClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(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.packArray(2);
+			packer.pack(f0);
+			packer.pack(f1);
+		}
+
+		@Override
+		public void messageConvert(MessagePackObject from)
+				throws MessageTypeException {
+			if (from.isNil()) {
+				return;
+			}
+			MessagePackObject[] objs = from.asArray();
+			f0 = objs[0].asInt();
+			f1 = objs[1].asInt();
+		}
+	}
+
+	@Test
+	public void testOptionalMessagePackableUnpackableClass00() throws Exception {
+		OptionalBaseMessagePackableConvertableClass src = new OptionalBaseMessagePackableConvertableClass();
+		OptionalMessagePackableConvertableClass src1 = new OptionalMessagePackableConvertableClass();
+		List<OptionalMessagePackableConvertableClass> src2 = new ArrayList<OptionalMessagePackableConvertableClass>();
+		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(OptionalBaseMessagePackableConvertableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalBaseMessagePackableConvertableClass.class);
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		OptionalBaseMessagePackableConvertableClass dst = (OptionalBaseMessagePackableConvertableClass) 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 testOptionalMessagePackableUnpackableClass01() throws Exception {
+		OptionalBaseMessagePackableConvertableClass src = new OptionalBaseMessagePackableConvertableClass();
 		src.f0 = null;
 		src.f1 = 1;
 		src.f2 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker
-				.create(BaseMessagePackableConvertableClass.class);
+				.create(OptionalBaseMessagePackableConvertableClass.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Template tmpl = DynamicTemplate
-				.create(BaseMessagePackableConvertableClass.class);
+				.create(OptionalBaseMessagePackableConvertableClass.class);
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl
+		OptionalBaseMessagePackableConvertableClass dst = (OptionalBaseMessagePackableConvertableClass) tmpl
 				.convert(mpo);
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
@@ -1071,44 +1838,46 @@ public class TestPackConvert extends TestCase {
 	}
 
 	@Test
-	public void testMessagePackableUnpackableClass02() throws Exception {
-		BaseMessagePackableConvertableClass src = null;
+	public void testOptionalMessagePackableUnpackableClass02() throws Exception {
+		OptionalBaseMessagePackableConvertableClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(BaseMessagePackableConvertableClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalBaseMessagePackableConvertableClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate
-				.create(BaseMessagePackableConvertableClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalBaseMessagePackableConvertableClass.class));
 		Unpacker pac = new Unpacker(in);
 		Iterator<MessagePackObject> it = pac.iterator();
 		assertTrue(it.hasNext());
 		MessagePackObject mpo = it.next();
-		BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl
+		OptionalBaseMessagePackableConvertableClass dst = (OptionalBaseMessagePackableConvertableClass) tmpl
 				.convert(mpo);
 		assertEquals(src, dst);
 		assertFalse(it.hasNext());
 	}
 
-	public static class BaseMessagePackableConvertableClass {
-		public MessagePackableConvertableClass f0;
-
+	public static class OptionalBaseMessagePackableConvertableClass {
+		@MessagePackOptional
+		public OptionalMessagePackableConvertableClass f0;
+		@MessagePackOptional
 		public int f1;
 
-		public List<MessagePackableConvertableClass> f2;
+		@MessagePackOptional
+		public List<OptionalMessagePackableConvertableClass> f2;
 
-		public BaseMessagePackableConvertableClass() {
+		public OptionalBaseMessagePackableConvertableClass() {
 		}
 	}
 
-	public static class MessagePackableConvertableClass implements
+	public static class OptionalMessagePackableConvertableClass implements
 			MessagePackable, MessageConvertable {
-
+		@MessagePackOptional
 		public int f0;
-
+		@MessagePackOptional
 		public int f1;
 
-		public MessagePackableConvertableClass() {
+		public OptionalMessagePackableConvertableClass() {
 		}
 
 		@Override
diff --git a/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java b/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java
index b7ac7eb..9496604 100644
--- a/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java
+++ b/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java
@@ -22,7 +22,10 @@ import org.msgpack.Packer;
 import org.msgpack.Template;
 import org.msgpack.Unpacker;
 import org.msgpack.annotation.MessagePackMessage;
+import org.msgpack.annotation.MessagePackOptional;
 import org.msgpack.annotation.MessagePackOrdinalEnum;
+import org.msgpack.packer.OptionalPacker;
+import org.msgpack.template.OptionalTemplate;
 
 import junit.framework.TestCase;
 
@@ -79,11 +82,12 @@ public class TestPackUnpack extends TestCase {
 	public void testPrimitiveTypeFields02() throws Exception {
 		PrimitiveTypeFieldsClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(PrimitiveTypeFieldsClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(PrimitiveTypeFieldsClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(PrimitiveTypeFieldsClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(PrimitiveTypeFieldsClass.class));
 		PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src, dst);
@@ -103,6 +107,90 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testOptionalPrimitiveTypeFields00() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = new OptionalPrimitiveTypeFieldsClass();
+		src.f0 = (byte) 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f6 = false;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+	}
+
+	@Test
+	public void testOptionalPrimitiveTypeFields01() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = new OptionalPrimitiveTypeFieldsClass();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class);
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+	}
+
+	@Test
+	public void testOptionalPrimitiveTypeFields02() throws Exception {
+		OptionalPrimitiveTypeFieldsClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalPrimitiveTypeFieldsClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalPrimitiveTypeFieldsClass.class));
+		OptionalPrimitiveTypeFieldsClass dst = (OptionalPrimitiveTypeFieldsClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class OptionalPrimitiveTypeFieldsClass {
+		@MessagePackOptional
+		public byte f0;
+		@MessagePackOptional
+		public short f1;
+		@MessagePackOptional
+		public int f2;
+		@MessagePackOptional
+		public long f3;
+		@MessagePackOptional
+		public float f4;
+		@MessagePackOptional
+		public double f5;
+		@MessagePackOptional
+		public boolean f6;
+
+		public OptionalPrimitiveTypeFieldsClass() {
+		}
+	}
+
+	@Test
 	public void testGeneralReferenceTypeFieldsClass00() throws Exception {
 		GeneralReferenceTypeFieldsClass src = new GeneralReferenceTypeFieldsClass();
 		src.f0 = 0;
@@ -139,7 +227,75 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testGeneralReferenceTypeFieldsClass01() throws Exception {
-		GeneralReferenceTypeFieldsClass src = new GeneralReferenceTypeFieldsClass();
+		GeneralReferenceTypeFieldsClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(GeneralReferenceTypeFieldsClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(GeneralReferenceTypeFieldsClass.class));
+		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class GeneralReferenceTypeFieldsClass {
+		public Byte f0;
+		public Short f1;
+		public Integer f2;
+		public Long f3;
+		public Float f4;
+		public Double f5;
+		public Boolean f6;
+		public BigInteger f7;
+		public String f8;
+		public byte[] f9;
+
+		public GeneralReferenceTypeFieldsClass() {
+		}
+	}
+
+	@Test
+	public void testGeneralOptionalReferenceTypeFieldsClass00()
+			throws Exception {
+		GeneralOptionalReferenceTypeFieldsClass src = new GeneralOptionalReferenceTypeFieldsClass();
+		src.f0 = 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = (long) 3;
+		src.f4 = (float) 4;
+		src.f5 = (double) 5;
+		src.f6 = false;
+		src.f7 = new BigInteger("7");
+		src.f8 = "8";
+		src.f9 = new byte[] { 0x01, 0x02 };
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(GeneralOptionalReferenceTypeFieldsClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(GeneralOptionalReferenceTypeFieldsClass.class);
+		GeneralOptionalReferenceTypeFieldsClass dst = (GeneralOptionalReferenceTypeFieldsClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+		assertEquals(src.f7, dst.f7);
+		assertEquals(src.f8, dst.f8);
+		assertEquals(src.f9[0], dst.f9[0]);
+		assertEquals(src.f9[1], dst.f9[1]);
+	}
+
+	@Test
+	public void testGeneralOptionalReferenceTypeFieldsClass01()
+			throws Exception {
+		GeneralOptionalReferenceTypeFieldsClass src = new GeneralOptionalReferenceTypeFieldsClass();
 		src.f0 = null;
 		src.f1 = null;
 		src.f2 = null;
@@ -152,12 +308,12 @@ public class TestPackUnpack extends TestCase {
 		src.f9 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker
-				.create(GeneralReferenceTypeFieldsClass.class);
+				.create(GeneralOptionalReferenceTypeFieldsClass.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Template tmpl = DynamicTemplate
-				.create(GeneralReferenceTypeFieldsClass.class);
-		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+				.create(GeneralOptionalReferenceTypeFieldsClass.class);
+		GeneralOptionalReferenceTypeFieldsClass dst = (GeneralOptionalReferenceTypeFieldsClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
@@ -172,33 +328,44 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
-	public void testGeneralReferenceTypeFieldsClass02() throws Exception {
-		GeneralReferenceTypeFieldsClass src = null;
+	public void testGeneralOptionalReferenceTypeFieldsClass02()
+			throws Exception {
+		GeneralOptionalReferenceTypeFieldsClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(GeneralReferenceTypeFieldsClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(GeneralOptionalReferenceTypeFieldsClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate
-				.create(GeneralReferenceTypeFieldsClass.class);
-		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(GeneralOptionalReferenceTypeFieldsClass.class));
+		GeneralOptionalReferenceTypeFieldsClass dst = (GeneralOptionalReferenceTypeFieldsClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
-	public static class GeneralReferenceTypeFieldsClass {
+	public static class GeneralOptionalReferenceTypeFieldsClass {
+		@MessagePackOptional
 		public Byte f0;
+		@MessagePackOptional
 		public Short f1;
+		@MessagePackOptional
 		public Integer f2;
+		@MessagePackOptional
 		public Long f3;
+		@MessagePackOptional
 		public Float f4;
+		@MessagePackOptional
 		public Double f5;
+		@MessagePackOptional
 		public Boolean f6;
+		@MessagePackOptional
 		public BigInteger f7;
+		@MessagePackOptional
 		public String f8;
+		@MessagePackOptional
 		public byte[] f9;
 
-		public GeneralReferenceTypeFieldsClass() {
+		public GeneralOptionalReferenceTypeFieldsClass() {
 		}
 	}
 
@@ -257,18 +424,109 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testListTypes01() throws Exception {
-		SampleListTypes src = new SampleListTypes();
+		SampleListTypes src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleListTypes.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleListTypes.class));
+		SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class SampleListTypes {
+		public List<Integer> f0;
+		public List<Integer> f1;
+		public List<String> f2;
+		public List<List<String>> f3;
+		public List<SampleListNestedType> f4;
+
+		public SampleListTypes() {
+		}
+	}
+
+	@MessagePackMessage
+	public static class SampleListNestedType {
+		public byte[] f0;
+		public String f1;
+
+		public SampleListNestedType() {
+		}
+	}
+
+	@Test
+	public void testOptionalListTypes00() throws Exception {
+		SampleOptionalListTypes src = new SampleOptionalListTypes();
+		src.f0 = new ArrayList<Integer>();
+		src.f1 = new ArrayList<Integer>();
+		src.f1.add(1);
+		src.f1.add(2);
+		src.f1.add(3);
+		src.f2 = new ArrayList<String>();
+		src.f2.add("e1");
+		src.f2.add("e2");
+		src.f2.add("e3");
+		src.f3 = new ArrayList<List<String>>();
+		src.f3.add(src.f2);
+		src.f4 = new ArrayList<SampleOptionalListNestedType>();
+		SampleOptionalListNestedType slnt = new SampleOptionalListNestedType();
+		slnt.f0 = new byte[] { 0x01, 0x02 };
+		slnt.f1 = "muga";
+		src.f4.add(slnt);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalListTypes.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalListTypes.class);
+		SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		for (int i = 0; i < src.f1.size(); ++i) {
+			assertEquals(src.f1.get(i), dst.f1.get(i));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		for (int i = 0; i < src.f2.size(); ++i) {
+			assertEquals(src.f2.get(i), dst.f2.get(i));
+		}
+		assertEquals(src.f3.size(), dst.f3.size());
+		for (int i = 0; i < src.f3.size(); ++i) {
+			List<String> srclist = src.f3.get(i);
+			List<String> dstlist = dst.f3.get(i);
+			assertEquals(srclist.size(), dstlist.size());
+			for (int j = 0; j < srclist.size(); ++j) {
+				assertEquals(srclist.get(j), dstlist.get(j));
+			}
+		}
+		assertEquals(src.f4.size(), dst.f4.size());
+		for (int i = 0; i < src.f4.size(); ++i) {
+			SampleOptionalListNestedType s = src.f4.get(i);
+			SampleOptionalListNestedType d = dst.f4.get(i);
+			assertEquals(s.f0[0], d.f0[0]);
+			assertEquals(s.f0[1], d.f0[1]);
+			assertEquals(s.f1, d.f1);
+		}
+	}
+
+	@Test
+	public void testOptionalListTypes01() throws Exception {
+		SampleOptionalListTypes src = new SampleOptionalListTypes();
 		src.f0 = new ArrayList<Integer>();
 		src.f1 = null;
 		src.f2 = new ArrayList<String>();
 		src.f3 = new ArrayList<List<String>>();
 		src.f4 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleListTypes.class);
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalListTypes.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleListTypes.class);
-		SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in));
+		Template tmpl = DynamicTemplate.create(SampleOptionalListTypes.class);
+		SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl
+				.unpack(new Unpacker(in));
 		assertEquals(src.f0.size(), dst.f0.size());
 		assertEquals(src.f1, dst.f1);
 		assertEquals(src.f2.size(), dst.f2.size());
@@ -277,34 +535,43 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
-	public void testListTypes02() throws Exception {
+	public void testOptionalListTypes02() throws Exception {
 		SampleListTypes src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleListTypes.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalListTypes.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleListTypes.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalListTypes.class));
 		SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
-	public static class SampleListTypes {
+	public static class SampleOptionalListTypes {
+		@MessagePackOptional
 		public List<Integer> f0;
+		@MessagePackOptional
 		public List<Integer> f1;
+		@MessagePackOptional
 		public List<String> f2;
+		@MessagePackOptional
 		public List<List<String>> f3;
-		public List<SampleListNestedType> f4;
+		@MessagePackOptional
+		public List<SampleOptionalListNestedType> f4;
 
-		public SampleListTypes() {
+		public SampleOptionalListTypes() {
 		}
 	}
 
 	@MessagePackMessage
-	public static class SampleListNestedType {
+	public static class SampleOptionalListNestedType {
+		@MessagePackOptional
 		public byte[] f0;
+		@MessagePackOptional
 		public String f1;
 
-		public SampleListNestedType() {
+		public SampleOptionalListNestedType() {
 		}
 	}
 
@@ -349,39 +616,111 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testMapTypes01() throws Exception {
-		SampleMapTypes src = new SampleMapTypes();
+		SampleMapTypes src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleMapTypes.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleMapTypes.class));
+		SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class SampleMapTypes {
+		public Map<Integer, Integer> f0;
+		public Map<Integer, Integer> f1;
+		public Map<String, Integer> f2;
+
+		public SampleMapTypes() {
+		}
+	}
+
+	@Test
+	public void testOptionalMapTypes00() throws Exception {
+		SampleOptionalMapTypes src = new SampleOptionalMapTypes();
+		src.f0 = new HashMap<Integer, Integer>();
+		src.f1 = new HashMap<Integer, Integer>();
+		src.f1.put(1, 1);
+		src.f1.put(2, 2);
+		src.f1.put(3, 3);
+		src.f2 = new HashMap<String, Integer>();
+		src.f2.put("k1", 1);
+		src.f2.put("k2", 2);
+		src.f2.put("k3", 3);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalMapTypes.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalMapTypes.class);
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		Iterator<Integer> srcf1 = src.f1.keySet().iterator();
+		Iterator<Integer> dstf1 = dst.f1.keySet().iterator();
+		while (srcf1.hasNext()) {
+			Integer s1 = srcf1.next();
+			Integer d1 = dstf1.next();
+			assertEquals(s1, d1);
+			assertEquals(src.f1.get(s1), dst.f1.get(d1));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		Iterator<String> srcf2 = src.f2.keySet().iterator();
+		Iterator<String> dstf2 = dst.f2.keySet().iterator();
+		while (srcf2.hasNext()) {
+			String s2 = srcf2.next();
+			String d2 = dstf2.next();
+			assertEquals(s2, d2);
+			assertEquals(src.f2.get(s2), dst.f2.get(d2));
+		}
+	}
+
+	@Test
+	public void testOptionalMapTypes01() throws Exception {
+		SampleOptionalMapTypes src = new SampleOptionalMapTypes();
 		src.f0 = new HashMap<Integer, Integer>();
 		src.f1 = null;
 		src.f2 = new HashMap<String, Integer>();
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleMapTypes.class);
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalMapTypes.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
-		SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in));
+		Template tmpl = DynamicTemplate.create(SampleOptionalMapTypes.class);
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl
+				.unpack(new Unpacker(in));
 		assertEquals(src.f0.size(), dst.f0.size());
 		assertEquals(src.f1, dst.f1);
 		assertEquals(src.f2.size(), dst.f2.size());
 	}
 
 	@Test
-	public void testMapTypes02() throws Exception {
-		SampleMapTypes src = null;
+	public void testOptionalMapTypes02() throws Exception {
+		SampleOptionalMapTypes src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleMapTypes.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalMapTypes.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
-		SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in));
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalMapTypes.class));
+		SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl
+				.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
-	public static class SampleMapTypes {
+	public static class SampleOptionalMapTypes {
+		@MessagePackOptional
 		public Map<Integer, Integer> f0;
+		@MessagePackOptional
 		public Map<Integer, Integer> f1;
+		@MessagePackOptional
 		public Map<String, Integer> f2;
 
-		public SampleMapTypes() {
+		public SampleOptionalMapTypes() {
 		}
 	}
 
@@ -615,43 +954,96 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testEnumTypeForOrdinal01() throws Exception {
-		SampleEnumFieldClass src = new SampleEnumFieldClass();
-		src.f1 = null;
+		SampleEnumFieldClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleEnumFieldClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleEnumFieldClass.class));
 		SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl
 				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class SampleEnumFieldClass {
+		public int f0;
+
+		public SampleEnum f1;
+
+		public SampleEnumFieldClass() {
+		}
+	}
+
+	@MessagePackOrdinalEnum
+	public enum SampleEnum {
+		ONE, TWO, THREE;
+	}
+
+	@Test
+	public void testOptionalEnumTypeForOrdinal00() throws Exception {
+		SampleOptionalEnumFieldClass src = new SampleOptionalEnumFieldClass();
+		src.f0 = 0;
+		src.f1 = SampleOptionalEnum.ONE;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalEnumFieldClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(SampleOptionalEnumFieldClass.class);
+		SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl
+				.unpack(new Unpacker(in));
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+	}
+
+	@Test
+	public void testOptionalEnumTypeForOrdinal01() throws Exception {
+		SampleOptionalEnumFieldClass src = new SampleOptionalEnumFieldClass();
+		src.f1 = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalEnumFieldClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(SampleOptionalEnumFieldClass.class);
+		SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl
+				.unpack(new Unpacker(in));
 		assertTrue(src.f0 == dst.f0);
 		assertEquals(src.f1, dst.f1);
 	}
 
 	@Test
-	public void testEnumTypeForOrdinal02() throws Exception {
+	public void testOptionalEnumTypeForOrdinal02() throws Exception {
 		SampleEnumFieldClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleEnumFieldClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleEnumFieldClass.class));
 		SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
-	public static class SampleEnumFieldClass {
+	public static class SampleOptionalEnumFieldClass {
+		@MessagePackOptional
 		public int f0;
 
-		public SampleEnum f1;
+		@MessagePackOptional
+		public SampleOptionalEnum f1;
 
-		public SampleEnumFieldClass() {
+		public SampleOptionalEnumFieldClass() {
 		}
 	}
 
 	@MessagePackOrdinalEnum
-	public enum SampleEnum {
+	public enum SampleOptionalEnum {
 		ONE, TWO, THREE;
 	}
 
@@ -688,69 +1080,85 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
-	public void testNestedFieldClass00() throws Exception {
-		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
-		CustomPacker.register(NestedClass.class, packer2);
-		MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
-		CustomPacker.register(BaseClass.class, packer1);
-		Template tmpl2 = DynamicTemplate.create(NestedClass.class);
-		CustomUnpacker.register(NestedClass.class, tmpl2);
-		CustomConverter.register(NestedClass.class, tmpl2);
-		Template tmpl1 = DynamicTemplate.create(BaseClass.class);
-		CustomUnpacker.register(BaseClass.class, tmpl1);
-		CustomConverter.register(BaseClass.class, tmpl1);
-		BaseClass src = new BaseClass();
-		NestedClass src2 = new NestedClass();
+	public void testOptionalFieldModifiers() throws Exception {
+		OptionalFieldModifiersClass src = new OptionalFieldModifiersClass();
 		src.f0 = 0;
-		src2.f2 = 2;
-		src.f1 = src2;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		packer1.pack(new Packer(out), src);
+		MessagePacker packer = DynamicPacker
+				.create(OptionalFieldModifiersClass.class);
+		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		BaseClass dst = (BaseClass) tmpl1.unpack(new Unpacker(in));
+		Template tmpl = DynamicTemplate
+				.create(OptionalFieldModifiersClass.class);
+		OptionalFieldModifiersClass dst = (OptionalFieldModifiersClass) tmpl
+				.unpack(new Unpacker(in));
 		assertTrue(src.f0 == dst.f0);
-		assertTrue(src.f1.f2 == dst.f1.f2);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 != dst.f3);
+		assertTrue(src.f4 != dst.f4);
+	}
+
+	public static class OptionalFieldModifiersClass {
+		@MessagePackOptional
+		public int f0;
+		@MessagePackOptional
+		public final int f1 = 1;
+		private int f2;
+		protected int f3;
+		int f4;
+
+		public OptionalFieldModifiersClass() {
+		}
 	}
 
 	@Test
-	public void testNestedFieldClass01() throws Exception {
+	public void testNestedFieldClass00() throws Exception {
 		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
 		CustomPacker.register(NestedClass.class, packer2);
-		MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
-		CustomPacker.register(BaseClass.class, packer1);
+		MessagePacker packer = DynamicPacker.create(BaseClass.class);
+		CustomPacker.register(BaseClass.class, packer);
 		Template tmpl2 = DynamicTemplate.create(NestedClass.class);
 		CustomUnpacker.register(NestedClass.class, tmpl2);
 		CustomConverter.register(NestedClass.class, tmpl2);
-		Template tmpl1 = DynamicTemplate.create(BaseClass.class);
-		CustomUnpacker.register(BaseClass.class, tmpl1);
-		CustomConverter.register(BaseClass.class, tmpl1);
+		Template tmpl = DynamicTemplate.create(BaseClass.class);
+		CustomUnpacker.register(BaseClass.class, tmpl);
+		CustomConverter.register(BaseClass.class, tmpl);
 		BaseClass src = new BaseClass();
-		src.f1 = null;
+		NestedClass src2 = new NestedClass();
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		packer1.pack(new Packer(out), src);
+		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		BaseClass dst = (BaseClass) tmpl1.unpack(new Unpacker(in));
+		BaseClass dst = (BaseClass) tmpl.unpack(new Unpacker(in));
 		assertTrue(src.f0 == dst.f0);
-		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f1.f2 == dst.f1.f2);
 	}
 
 	@Test
-	public void testNestedFieldClass02() throws Exception {
+	public void testNestedFieldClass01() throws Exception {
 		MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
 		CustomPacker.register(NestedClass.class, packer2);
-		MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
-		CustomPacker.register(BaseClass.class, packer1);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseClass.class));
+		CustomPacker.register(BaseClass.class, packer);
 		Template tmpl2 = DynamicTemplate.create(NestedClass.class);
 		CustomUnpacker.register(NestedClass.class, tmpl2);
 		CustomConverter.register(NestedClass.class, tmpl2);
-		Template tmpl1 = DynamicTemplate.create(BaseClass.class);
-		CustomUnpacker.register(BaseClass.class, tmpl1);
-		CustomConverter.register(BaseClass.class, tmpl1);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(BaseClass.class));
+		CustomUnpacker.register(BaseClass.class, tmpl);
+		CustomConverter.register(BaseClass.class, tmpl);
 		BaseClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		packer1.pack(new Packer(out), src);
+		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		BaseClass dst = (BaseClass) tmpl1.unpack(new Unpacker(in));
+		BaseClass dst = (BaseClass) tmpl.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
@@ -770,44 +1178,122 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
-	public void testMessagePackMessageFieldClass00() throws Exception {
-		BaseClass2 src = new BaseClass2();
-		MessagePackMessageClass2 src2 = new MessagePackMessageClass2();
+	public void testOptionalNestedFieldClass00() throws Exception {
+		MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
+		CustomPacker.register(OptionalNestedClass.class, packer2);
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
+		CustomPacker.register(OptionalBaseClass.class, packer);
+		Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
+		CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
+		CustomConverter.register(OptionalNestedClass.class, tmpl2);
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
+		CustomUnpacker.register(OptionalBaseClass.class, tmpl);
+		CustomConverter.register(OptionalBaseClass.class, tmpl);
+		OptionalBaseClass src = new OptionalBaseClass();
+		OptionalNestedClass src2 = new OptionalNestedClass();
 		src.f0 = 0;
 		src2.f2 = 2;
 		src.f1 = src2;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(BaseClass2.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(BaseClass2.class);
-		BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in));
+		OptionalBaseClass dst = (OptionalBaseClass) tmpl
+				.unpack(new Unpacker(in));
 		assertTrue(src.f0 == dst.f0);
 		assertTrue(src.f1.f2 == dst.f1.f2);
 	}
 
 	@Test
-	public void testMessagePackMessageFieldClass01() throws Exception {
-		BaseClass2 src = new BaseClass2();
+	public void testOptionalNestedFieldClass01() throws Exception {
+		MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
+		CustomPacker.register(OptionalNestedClass.class, packer2);
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
+		CustomPacker.register(OptionalBaseClass.class, packer);
+		Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
+		CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
+		CustomConverter.register(OptionalNestedClass.class, tmpl2);
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
+		CustomUnpacker.register(OptionalBaseClass.class, tmpl);
+		CustomConverter.register(OptionalBaseClass.class, tmpl);
+		OptionalBaseClass src = new OptionalBaseClass();
 		src.f1 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		OptionalBaseClass dst = (OptionalBaseClass) tmpl
+				.unpack(new Unpacker(in));
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+	}
+
+	@Test
+	public void testOptionalNestedFieldClass02() throws Exception {
+		MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
+		CustomPacker.register(OptionalNestedClass.class, packer2);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalBaseClass.class));
+		CustomPacker.register(OptionalBaseClass.class, packer);
+		Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
+		CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
+		CustomConverter.register(OptionalNestedClass.class, tmpl2);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalBaseClass.class));
+		CustomUnpacker.register(OptionalBaseClass.class, tmpl);
+		CustomConverter.register(OptionalBaseClass.class, tmpl);
+		OptionalBaseClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		OptionalBaseClass dst = (OptionalBaseClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class OptionalBaseClass {
+		@MessagePackOptional
+		public int f0;
+		@MessagePackOptional
+		public OptionalNestedClass f1;
+
+		public OptionalBaseClass() {
+		}
+	}
+
+	public static class OptionalNestedClass {
+		@MessagePackOptional
+		public int f2;
+
+		public OptionalNestedClass() {
+		}
+	}
+
+	@Test
+	public void testMessagePackMessageFieldClass00() throws Exception {
+		BaseClass2 src = new BaseClass2();
+		MessagePackMessageClass2 src2 = new MessagePackMessageClass2();
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker.create(BaseClass2.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Template tmpl = DynamicTemplate.create(BaseClass2.class);
 		BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in));
 		assertTrue(src.f0 == dst.f0);
-		assertEquals(src.f1, dst.f1);
+		assertTrue(src.f1.f2 == dst.f1.f2);
 	}
 
 	@Test
-	public void testMessagePackMessageFieldClass02() throws Exception {
+	public void testMessagePackMessageFieldClass01() throws Exception {
 		BaseClass2 src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(BaseClass2.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseClass2.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(BaseClass2.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(BaseClass2.class));
 		BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
@@ -829,6 +1315,73 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testOptionalMessagePackMessageFieldClass00() throws Exception {
+		OptionalBaseClass2 src = new OptionalBaseClass2();
+		OptionalMessagePackMessageClass2 src2 = new OptionalMessagePackMessageClass2();
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass2.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass2.class);
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.unpack(new Unpacker(
+				in));
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1.f2 == dst.f1.f2);
+	}
+
+	@Test
+	public void testOptionalMessagePackMessageFieldClass01() throws Exception {
+		OptionalBaseClass2 src = new OptionalBaseClass2();
+		src.f1 = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker.create(OptionalBaseClass2.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(OptionalBaseClass2.class);
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.unpack(new Unpacker(
+				in));
+		assertTrue(src.f0 == dst.f0);
+		assertEquals(src.f1, dst.f1);
+	}
+
+	@Test
+	public void testOptionalMessagePackMessageFieldClass02() throws Exception {
+		OptionalBaseClass2 src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalBaseClass2.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalBaseClass2.class));
+		OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.unpack(new Unpacker(
+				in));
+		assertEquals(src, dst);
+	}
+
+	public static class OptionalBaseClass2 {
+		@MessagePackOptional
+		public int f0;
+		@MessagePackOptional
+		public OptionalMessagePackMessageClass2 f1;
+
+		public OptionalBaseClass2() {
+		}
+	}
+
+	@MessagePackMessage
+	public static class OptionalMessagePackMessageClass2 {
+		@MessagePackOptional
+		public int f2;
+
+		public OptionalMessagePackMessageClass2() {
+		}
+	}
+
+	@Test
 	public void testExtendedClass00() throws Exception {
 		SampleSubClass src = new SampleSubClass();
 		src.f0 = 0;
@@ -859,10 +1412,12 @@ public class TestPackUnpack extends TestCase {
 	public void testExtendedClass01() throws Exception {
 		SampleSubClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker.create(SampleSubClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleSubClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate.create(SampleSubClass.class);
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleSubClass.class));
 		SampleSubClass dst = (SampleSubClass) tmpl.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
@@ -891,6 +1446,75 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
+	public void testOptionalExtendedClass00() throws Exception {
+		SampleOptionalSubClass src = new SampleOptionalSubClass();
+		src.f0 = 0;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f8 = 8;
+		src.f9 = 9;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = DynamicPacker
+				.create(SampleOptionalSubClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate.create(SampleOptionalSubClass.class);
+		SampleOptionalSubClass dst = (SampleOptionalSubClass) tmpl
+				.unpack(new Unpacker(in));
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 != dst.f3);
+		assertTrue(src.f4 != dst.f4);
+		assertTrue(src.f5 == dst.f5);
+		assertTrue(src.f6 == dst.f6);
+		assertTrue(src.f8 != dst.f8);
+		assertTrue(src.f9 != dst.f9);
+	}
+
+	@Test
+	public void testOptionalExtendedClass01() throws Exception {
+		SampleOptionalSubClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(SampleOptionalSubClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(SampleOptionalSubClass.class));
+		SampleOptionalSubClass dst = (SampleOptionalSubClass) tmpl
+				.unpack(new Unpacker(in));
+		assertEquals(src, dst);
+	}
+
+	public static class SampleOptionalSubClass extends SampleOptionalSuperClass {
+		@MessagePackOptional
+		public int f0;
+		public final int f1 = 1;
+		private int f2;
+		protected int f3;
+		int f4;
+
+		public SampleOptionalSubClass() {
+		}
+	}
+
+	public static class SampleOptionalSuperClass {
+		@MessagePackOptional
+		public int f5;
+		public final int f6 = 2;
+		@SuppressWarnings("unused")
+		private int f7;
+		protected int f8;
+		int f9;
+
+		public SampleOptionalSuperClass() {
+		}
+	}
+
+	@Test
 	public void testMessagePackableUnpackableClass00() throws Exception {
 		BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass();
 		MessagePackableUnpackableClass src1 = new MessagePackableUnpackableClass();
@@ -920,18 +1544,97 @@ public class TestPackUnpack extends TestCase {
 
 	@Test
 	public void testMessagePackableUnpackableClass01() throws Exception {
-		BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass();
+		BaseMessagePackableUnpackableClass src = null;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(BaseMessagePackableUnpackableClass.class));
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = new OptionalTemplate(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.packArray(2);
+			packer.pack(f0);
+			packer.pack(f1);
+		}
+
+		@Override
+		public void messageUnpack(Unpacker unpacker) throws IOException,
+				MessageTypeException {
+			if (unpacker.tryUnpackNull()) {
+				return;
+			}
+			unpacker.unpackArray();
+			f0 = unpacker.unpackInt();
+			f1 = unpacker.unpackInt();
+		}
+	}
+
+	@Test
+	public void testOptionalMessagePackableUnpackableClass00() throws Exception {
+		OptionalBaseMessagePackableUnpackableClass src = new OptionalBaseMessagePackableUnpackableClass();
+		OptionalMessagePackableUnpackableClass src1 = new OptionalMessagePackableUnpackableClass();
+		List<OptionalMessagePackableUnpackableClass> src2 = new ArrayList<OptionalMessagePackableUnpackableClass>();
+		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(OptionalBaseMessagePackableUnpackableClass.class);
+		packer.pack(new Packer(out), src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Template tmpl = DynamicTemplate
+				.create(OptionalBaseMessagePackableUnpackableClass.class);
+		OptionalBaseMessagePackableUnpackableClass dst = (OptionalBaseMessagePackableUnpackableClass) 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 testOptionalMessagePackableUnpackableClass01() throws Exception {
+		OptionalBaseMessagePackableUnpackableClass src = new OptionalBaseMessagePackableUnpackableClass();
 		src.f0 = null;
 		src.f1 = 1;
 		src.f2 = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		MessagePacker packer = DynamicPacker
-				.create(BaseMessagePackableUnpackableClass.class);
+				.create(OptionalBaseMessagePackableUnpackableClass.class);
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Template tmpl = DynamicTemplate
-				.create(BaseMessagePackableUnpackableClass.class);
-		BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl
+				.create(OptionalBaseMessagePackableUnpackableClass.class);
+		OptionalBaseMessagePackableUnpackableClass dst = (OptionalBaseMessagePackableUnpackableClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src.f0, dst.f0);
 		assertEquals(src.f1, dst.f1);
@@ -939,39 +1642,40 @@ public class TestPackUnpack extends TestCase {
 	}
 
 	@Test
-	public void testMessagePackableUnpackableClass02() throws Exception {
-		BaseMessagePackableUnpackableClass src = null;
+	public void testOptionalMessagePackableUnpackableClass02() throws Exception {
+		OptionalBaseMessagePackableUnpackableClass src = null;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		MessagePacker packer = DynamicPacker
-				.create(BaseMessagePackableUnpackableClass.class);
+		MessagePacker packer = new OptionalPacker(DynamicPacker
+				.create(OptionalBaseMessagePackableUnpackableClass.class));
 		packer.pack(new Packer(out), src);
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
-		Template tmpl = DynamicTemplate
-				.create(BaseMessagePackableUnpackableClass.class);
-		BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl
+		Template tmpl = new OptionalTemplate(DynamicTemplate
+				.create(OptionalBaseMessagePackableUnpackableClass.class));
+		OptionalBaseMessagePackableUnpackableClass dst = (OptionalBaseMessagePackableUnpackableClass) tmpl
 				.unpack(new Unpacker(in));
 		assertEquals(src, dst);
 	}
 
-	public static class BaseMessagePackableUnpackableClass {
-		public MessagePackableUnpackableClass f0;
-
+	public static class OptionalBaseMessagePackableUnpackableClass {
+		@MessagePackOptional
+		public OptionalMessagePackableUnpackableClass f0;
+		@MessagePackOptional
 		public int f1;
+		@MessagePackOptional
+		public List<OptionalMessagePackableUnpackableClass> f2;
 
-		public List<MessagePackableUnpackableClass> f2;
-
-		public BaseMessagePackableUnpackableClass() {
+		public OptionalBaseMessagePackableUnpackableClass() {
 		}
 	}
 
-	public static class MessagePackableUnpackableClass implements
+	public static class OptionalMessagePackableUnpackableClass implements
 			MessagePackable, MessageUnpackable {
-
+		@MessagePackOptional
 		public int f0;
-
+		@MessagePackOptional
 		public int f1;
 
-		public MessagePackableUnpackableClass() {
+		public OptionalMessagePackableUnpackableClass() {
 		}
 
 		@Override