diff --git a/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java b/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java index 081b28c0..f9eb2270 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 e268c4f5..00000000 --- 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 d2b4effc..6b8457d4 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 src = from.asMap(); Map 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 6be16c1a..f288fc45 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 e32e6ad7..8a4b7085 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 677ace90..bb9cdd56 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 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 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 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 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 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 0f8cace8..95c37482 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 defb3c90..df1f2e72 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 ab599f14..8919a67a 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 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 643ff525..fbd019dd 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 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 60a51e8d..673c344e 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 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 83590ced..8b927cba 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 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 723a765a..127688dc 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 98caf820..26f3313d 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); @@ -35,9 +133,30 @@ public class TestPackConvert extends TestCase { assertEquals(src.intValue(), obj.asInt()); } + @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); @@ -59,9 +178,30 @@ public class TestPackConvert extends TestCase { assertEquals(src.longValue(), obj.asLong()); } + @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)); @@ -86,9 +226,31 @@ public class TestPackConvert extends TestCase { assertEquals(src, obj.asBigInteger()); } + @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); @@ -112,9 +274,30 @@ public class TestPackConvert extends TestCase { assertEquals(src.floatValue(), obj.asFloat(), 10e-10); } + @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); @@ -137,9 +320,30 @@ public class TestPackConvert extends TestCase { assertEquals(src.doubleValue(), obj.asDouble(), 10e-10); } + @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); } @@ -152,9 +356,30 @@ public class TestPackConvert extends TestCase { assertEquals(src.booleanValue(), obj.asBoolean()); } + @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 f1d7842e..2dd631d5 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); @@ -36,9 +140,32 @@ public class TestPackUnpack extends TestCase { assertEquals(src.intValue(), unpacker.unpackInt()); } + @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); @@ -61,9 +188,32 @@ public class TestPackUnpack extends TestCase { assertEquals(src.longValue(), unpacker.unpackLong()); } + @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)); @@ -89,9 +239,33 @@ public class TestPackUnpack extends TestCase { assertEquals(src, unpacker.unpackBigInteger()); } + @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); @@ -116,9 +290,32 @@ public class TestPackUnpack extends TestCase { assertEquals(src.floatValue(), unpacker.unpackFloat(), 10e-10); } + @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); @@ -142,9 +339,32 @@ public class TestPackUnpack extends TestCase { assertEquals(src.doubleValue(), unpacker.unpackDouble(), 10e-10); } + @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); } @@ -158,9 +378,32 @@ public class TestPackUnpack extends TestCase { assertEquals(src.booleanValue(), unpacker.unpackBoolean()); } + @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 15237b6d..01063a51 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); @@ -41,9 +41,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst); } + @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); @@ -66,9 +85,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst); } + @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)); @@ -94,9 +132,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst); } + @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); @@ -121,9 +178,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst, 10e-10); } + @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); @@ -148,9 +224,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst, 10e-10); } + @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); } @@ -164,9 +259,28 @@ public class TestPackConvert extends TestCase { assertEquals(src, dst); } + @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 emptyList = new ArrayList(); { ByteArrayOutputStream out = new ByteArrayOutputStream(); @@ -261,10 +394,31 @@ public class TestPackConvert extends TestCase { } } + @SuppressWarnings("unchecked") + @Test + public void testNullList() throws Exception { + List src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + new Packer(out).pack(src); + MessagePackObject obj = Util.unpackOne(out.toByteArray()); + Template tmpl = new ListTemplate(StringTemplate.getInstance()); + List dst = null; + try { + dst = (List) 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) tmpl.convert(obj); + assertEquals(src, dst); + } + @SuppressWarnings("unchecked") @Test public void testMap() throws Exception { - // nullMap // FIXME Map emptyMap = new HashMap(); { ByteArrayOutputStream out = new ByteArrayOutputStream(); @@ -317,4 +471,27 @@ public class TestPackConvert extends TestCase { } } } + + @SuppressWarnings("unchecked") + @Test + public void testNullMap() throws Exception { + Map 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 dst = null; + try { + dst = (Map) 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) 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 fbd510fd..29ee78da 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); @@ -40,9 +40,31 @@ public class TestPackUnpack extends TestCase { assertEquals(src, dst); } + @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); @@ -65,9 +87,31 @@ public class TestPackUnpack extends TestCase { assertEquals(src, dst); } + @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)); @@ -93,9 +137,31 @@ public class TestPackUnpack extends TestCase { assertEquals(src, dst); } + @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); @@ -147,9 +212,31 @@ public class TestPackUnpack extends TestCase { assertEquals(src, dst, 10e-10); } + @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); } @@ -163,9 +250,31 @@ public class TestPackUnpack extends TestCase { assertEquals(src, dst); } + @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 emptyList = new ArrayList(); { ByteArrayOutputStream out = new ByteArrayOutputStream(); @@ -262,10 +393,34 @@ public class TestPackUnpack extends TestCase { } } + @SuppressWarnings("unchecked") + @Test + public void testNullList() throws Exception { + List src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + new Packer(out).pack(src); + byte[] bytes = out.toByteArray(); + Template tmpl = null; + Unpacker unpacker = new Unpacker(); + List dst = null; + try { + tmpl = new ListTemplate(StringTemplate.getInstance()); + unpacker.wrap(bytes); + dst = (List) tmpl.unpack(unpacker); + fail(); + } catch (Exception e) { + assertTrue(e instanceof MessageTypeException); + } + unpacker.wrap(bytes); + tmpl = new OptionalTemplate(new ListTemplate(StringTemplate + .getInstance())); + dst = (List) tmpl.unpack(unpacker); + assertEquals(src, dst); + } + @SuppressWarnings("unchecked") @Test public void testMap() throws Exception { - // nullMap // FIXME Map emptyMap = new HashMap(); { ByteArrayOutputStream out = new ByteArrayOutputStream(); @@ -323,4 +478,30 @@ public class TestPackUnpack extends TestCase { } } } + + @SuppressWarnings("unchecked") + @Test + public void testNullMap() throws Exception { + Map src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + new Packer(out).pack(src); + byte[] bytes = out.toByteArray(); + Template tmpl = null; + Unpacker unpacker = new Unpacker(); + Map dst = null; + try { + tmpl = new MapTemplate(StringTemplate.getInstance(), StringTemplate + .getInstance()); + unpacker.wrap(bytes); + dst = (Map) 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) 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 d2cf35cf..63532a00 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,38 +66,14 @@ public class TestPackConvert extends TestCase { @Test public void testPrimitiveTypeFields01() throws Exception { - PrimitiveTypeFieldsClass src = new PrimitiveTypeFieldsClass(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(PrimitiveTypeFieldsClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate.create(PrimitiveTypeFieldsClass.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) 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 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)); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -118,6 +97,105 @@ public class TestPackConvert 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); + Unpacker pac = new Unpacker(in); + Iterator 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); + 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 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); + Unpacker pac = new Unpacker(in); + Iterator 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); + 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 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 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(); @@ -159,54 +237,15 @@ public class TestPackConvert extends TestCase { } @Test - public void XtestGeneralReferenceTypeFieldsClass01() throws Exception { - GeneralReferenceTypeFieldsClass src = new GeneralReferenceTypeFieldsClass(); - src.f0 = null; - src.f1 = null; - src.f2 = null; - src.f3 = null; - src.f4 = null; - src.f5 = null; - src.f6 = null; - src.f7 = null; - src.f8 = null; - src.f9 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(GeneralReferenceTypeFieldsClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate - .create(GeneralReferenceTypeFieldsClass.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) 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, dst.f9); - assertFalse(it.hasNext()); - } - - @Test - public void XtestGeneralReferenceTypeFieldsClass02() throws Exception { + public void testGeneralReferenceTypeFieldsClass01() throws Exception { GeneralReferenceTypeFieldsClass src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(GeneralReferenceTypeFieldsClass.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(GeneralReferenceTypeFieldsClass.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(GeneralReferenceTypeFieldsClass.class)); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -233,6 +272,134 @@ public class TestPackConvert extends TestCase { } } + @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 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; + src.f3 = null; + src.f4 = null; + src.f5 = null; + src.f6 = null; + src.f7 = null; + src.f8 = null; + src.f9 = null; + 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 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, dst.f9); + assertFalse(it.hasNext()); + } + + @Test + public void testOptionalGeneralReferenceTypeFieldsClass02() + throws Exception { + OptionalGeneralReferenceTypeFieldsClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(OptionalGeneralReferenceTypeFieldsClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(OptionalGeneralReferenceTypeFieldsClass.class)); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + OptionalGeneralReferenceTypeFieldsClass dst = (OptionalGeneralReferenceTypeFieldsClass) tmpl + .convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + 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 OptionalGeneralReferenceTypeFieldsClass() { + } + } + @Test public void testListTypes00() throws Exception { SampleListTypes src = new SampleListTypes(); @@ -293,38 +460,14 @@ public class TestPackConvert extends TestCase { @Test public void testListTypes01() throws Exception { - SampleListTypes src = new SampleListTypes(); - src.f0 = new ArrayList(); - src.f1 = null; - src.f2 = new ArrayList(); - src.f3 = null; - src.f4 = new ArrayList(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleListTypes.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate.create(SampleListTypes.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleListTypes dst = (SampleListTypes) tmpl.convert(mpo); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2.size(), dst.f2.size()); - assertEquals(src.f3, dst.f3); - assertEquals(src.f4.size(), dst.f4.size()); - assertFalse(it.hasNext()); - } - - @Test - public void testListTypes02() throws Exception { SampleListTypes src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleListTypes.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleListTypes.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(SampleListTypes.class)); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -354,6 +497,141 @@ public class TestPackConvert extends TestCase { } } + @Test + public void testOptionalListTypes00() throws Exception { + SampleOptionalListTypes src = new SampleOptionalListTypes(); + src.f0 = new ArrayList(); + src.f1 = new ArrayList(); + src.f1.add(1); + src.f1.add(2); + src.f1.add(3); + src.f2 = new ArrayList(); + src.f2.add("e1"); + src.f2.add("e2"); + src.f2.add("e3"); + src.f3 = new ArrayList>(); + src.f3.add(src.f2); + src.f4 = new ArrayList(); + 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 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 srclist = src.f3.get(i); + List 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(); + src.f1 = null; + src.f2 = new ArrayList(); + src.f3 = null; + src.f4 = new ArrayList(); + 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 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, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + assertEquals(src.f3, dst.f3); + assertEquals(src.f4.size(), dst.f4.size()); + assertFalse(it.hasNext()); + } + + @Test + public void testOptionalListTypes02() throws Exception { + SampleOptionalListTypes src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleOptionalListTypes.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleOptionalListTypes.class)); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + SampleOptionalListTypes dst = (SampleOptionalListTypes) tmpl + .convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + public static class SampleOptionalListTypes { + @MessagePackOptional + public List f0; + @MessagePackOptional + public List f1; + @MessagePackOptional + public List f2; + @MessagePackOptional + public List> f3; + @MessagePackOptional + public List f4; + + public SampleOptionalListTypes() { + } + } + + @MessagePackMessage + public static class SampleOptionalListNestedType { + @MessagePackOptional + public byte[] f0; + @MessagePackOptional + public String f1; + + public SampleOptionalListNestedType() { + } + } + @Test public void testMapTypes00() throws Exception { SampleMapTypes src = new SampleMapTypes(); @@ -398,36 +676,16 @@ public class TestPackConvert extends TestCase { assertFalse(it.hasNext()); } - @Test - public void testMapTypes01() throws Exception { - SampleMapTypes src = new SampleMapTypes(); - src.f0 = new HashMap(); - src.f1 = null; - src.f2 = new HashMap(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleMapTypes.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate.create(SampleMapTypes.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleMapTypes dst = (SampleMapTypes) tmpl.convert(mpo); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2.size(), dst.f2.size()); - assertFalse(it.hasNext()); - } - @Test public void testMapTypes02() throws Exception { SampleMapTypes src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleMapTypes.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleMapTypes.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(SampleMapTypes.class)); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -446,6 +704,105 @@ public class TestPackConvert extends TestCase { } } + @Test + public void testOptionalMapTypes00() throws Exception { + SampleOptionalMapTypes src = new SampleOptionalMapTypes(); + src.f0 = new HashMap(); + src.f1 = new HashMap(); + src.f1.put(1, 1); + src.f1.put(2, 2); + src.f1.put(3, 3); + src.f2 = new HashMap(); + 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 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 srcf1 = src.f1.keySet().iterator(); + Iterator 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 srcf2 = src.f2.keySet().iterator(); + Iterator 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(); + src.f1 = null; + src.f2 = new HashMap(); + 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 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, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + assertFalse(it.hasNext()); + } + + @Test + public void testOptionalMapTypes02() throws Exception { + SampleOptionalMapTypes src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleOptionalMapTypes.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleOptionalMapTypes.class)); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl.convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + public static class SampleOptionalMapTypes { + @MessagePackOptional + public Map f0; + @MessagePackOptional + public Map f1; + @MessagePackOptional + public Map f2; + + public SampleOptionalMapTypes() { + } + } + @Test public void testDefaultConstructorModifiers01() throws Exception { try { @@ -687,31 +1044,14 @@ public class TestPackConvert extends TestCase { @Test public void testEnumTypeForOrdinal01() throws Exception { - SampleEnumFieldClass src = new SampleEnumFieldClass(); - src.f1 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleEnumFieldClass dst = (SampleEnumFieldClass) 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; 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 it = pac.iterator(); assertTrue(it.hasNext()); @@ -723,7 +1063,6 @@ public class TestPackConvert extends TestCase { public static class SampleEnumFieldClass { public int f0; - public SampleEnum f1; public SampleEnumFieldClass() { @@ -735,6 +1074,86 @@ public class TestPackConvert extends TestCase { 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 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 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 testOptionalEnumTypeForOrdinal02() throws Exception { + SampleOptionalEnumFieldClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleOptionalEnumFieldClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleOptionalEnumFieldClass.class)); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + SampleOptionalEnumFieldClass dst = (SampleOptionalEnumFieldClass) tmpl + .convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + public static class SampleOptionalEnumFieldClass { + @MessagePackOptional + public int f0; + @MessagePackOptional + public SampleOptionalEnum f1; + + public SampleOptionalEnumFieldClass() { + } + } + + @MessagePackOrdinalEnum + public enum SampleOptionalEnum { + ONE, TWO, THREE; + } + @Test public void testFieldModifiers() throws Exception { FieldModifiersClass src = new FieldModifiersClass(); @@ -771,6 +1190,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 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); @@ -801,53 +1261,29 @@ public class TestPackConvert extends TestCase { assertFalse(it.hasNext()); } - @Test - 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); - 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(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - packer1.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - BaseClass dst = (BaseClass) tmpl1.convert(mpo); - assertTrue(src.f0 == dst.f0); - assertEquals(src.f1, dst.f1); - assertFalse(it.hasNext()); - } - @Test 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); + 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 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()); } @@ -867,6 +1303,107 @@ public class TestPackConvert extends TestCase { } } + @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 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 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 testOptionalNestedFieldClass02() throws Exception { + MessagePacker packer2 = DynamicPacker.create(NestedClass.class); + CustomPacker.register(NestedClass.class, packer2); + 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 tmpl = new OptionalTemplate(DynamicTemplate + .create(BaseClass.class)); + CustomUnpacker.register(BaseClass.class, tmpl); + CustomConverter.register(BaseClass.class, tmpl); + BaseClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + BaseClass dst = (BaseClass) tmpl.convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + 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(); @@ -889,36 +1426,20 @@ public class TestPackConvert extends TestCase { assertFalse(it.hasNext()); } - @Test - public void testMessagePackMessageFieldClass01() throws Exception { - BaseClass2 src = new BaseClass2(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(BaseClass2.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - Template tmpl = DynamicTemplate.create(BaseClass2.class); - BaseClass2 dst = (BaseClass2) 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; 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 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()); @@ -940,6 +1461,84 @@ public class TestPackConvert 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()); + Unpacker pac = new Unpacker(in); + Iterator 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 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 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()); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(OptionalBaseClass2.class)); + OptionalBaseClass2 dst = (OptionalBaseClass2) tmpl.convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + 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(); @@ -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 it = pac.iterator(); assertTrue(it.hasNext()); @@ -1012,6 +1613,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 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 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(); @@ -1047,39 +1725,14 @@ public class TestPackConvert extends TestCase { @Test public void testMessagePackableUnpackableClass01() throws Exception { - BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass(); - src.f0 = null; - src.f1 = 1; - src.f2 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(BaseMessagePackableConvertableClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate - .create(BaseMessagePackableConvertableClass.class); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl - .convert(mpo); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - assertFalse(it.hasNext()); - } - - @Test - public void testMessagePackableUnpackableClass02() throws Exception { BaseMessagePackableConvertableClass src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(BaseMessagePackableConvertableClass.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(BaseMessagePackableConvertableClass.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(BaseMessagePackableConvertableClass.class)); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -1092,9 +1745,7 @@ public class TestPackConvert extends TestCase { public static class BaseMessagePackableConvertableClass { public MessagePackableConvertableClass f0; - public int f1; - public List f2; public BaseMessagePackableConvertableClass() { @@ -1103,9 +1754,7 @@ public class TestPackConvert extends TestCase { public static class MessagePackableConvertableClass implements MessagePackable, MessageConvertable { - public int f0; - public int f1; public MessagePackableConvertableClass() { @@ -1129,4 +1778,124 @@ public class TestPackConvert extends TestCase { f1 = objs[1].asInt(); } } + + @Test + public void testOptionalMessagePackableUnpackableClass00() throws Exception { + OptionalBaseMessagePackableConvertableClass src = new OptionalBaseMessagePackableConvertableClass(); + OptionalMessagePackableConvertableClass src1 = new OptionalMessagePackableConvertableClass(); + List src2 = new ArrayList(); + 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 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(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 it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + OptionalBaseMessagePackableConvertableClass dst = (OptionalBaseMessagePackableConvertableClass) tmpl + .convert(mpo); + assertEquals(src.f0, dst.f0); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2, dst.f2); + assertFalse(it.hasNext()); + } + + @Test + public void testOptionalMessagePackableUnpackableClass02() throws Exception { + OptionalBaseMessagePackableConvertableClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(OptionalBaseMessagePackableConvertableClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(OptionalBaseMessagePackableConvertableClass.class)); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + OptionalBaseMessagePackableConvertableClass dst = (OptionalBaseMessagePackableConvertableClass) tmpl + .convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + public static class OptionalBaseMessagePackableConvertableClass { + @MessagePackOptional + public OptionalMessagePackableConvertableClass f0; + @MessagePackOptional + public int f1; + + @MessagePackOptional + public List f2; + + public OptionalBaseMessagePackableConvertableClass() { + } + } + + public static class OptionalMessagePackableConvertableClass implements + MessagePackable, MessageConvertable { + @MessagePackOptional + public int f0; + @MessagePackOptional + public int f1; + + public OptionalMessagePackableConvertableClass() { + } + + @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(); + } + } } 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 b7ac7eb2..9496604c 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); @@ -102,6 +106,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(); @@ -139,48 +227,14 @@ public class TestPackUnpack extends TestCase { @Test public void testGeneralReferenceTypeFieldsClass01() throws Exception { - GeneralReferenceTypeFieldsClass src = new GeneralReferenceTypeFieldsClass(); - src.f0 = null; - src.f1 = null; - src.f2 = null; - src.f3 = null; - src.f4 = null; - src.f5 = null; - src.f6 = null; - src.f7 = null; - src.f8 = null; - src.f9 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(GeneralReferenceTypeFieldsClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate - .create(GeneralReferenceTypeFieldsClass.class); - GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) 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, dst.f9); - } - - @Test - public void testGeneralReferenceTypeFieldsClass02() throws Exception { GeneralReferenceTypeFieldsClass src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(GeneralReferenceTypeFieldsClass.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(GeneralReferenceTypeFieldsClass.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(GeneralReferenceTypeFieldsClass.class)); GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl .unpack(new Unpacker(in)); assertEquals(src, dst); @@ -202,6 +256,119 @@ public class TestPackUnpack extends TestCase { } } + @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; + src.f3 = null; + src.f4 = null; + src.f5 = null; + src.f6 = null; + src.f7 = null; + src.f8 = null; + src.f9 = null; + 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, dst.f9); + } + + @Test + public void testGeneralOptionalReferenceTypeFieldsClass02() + throws Exception { + GeneralOptionalReferenceTypeFieldsClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(GeneralOptionalReferenceTypeFieldsClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(GeneralOptionalReferenceTypeFieldsClass.class)); + GeneralOptionalReferenceTypeFieldsClass dst = (GeneralOptionalReferenceTypeFieldsClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + 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 GeneralOptionalReferenceTypeFieldsClass() { + } + } + @Test public void testListTypes00() throws Exception { SampleListTypes src = new SampleListTypes(); @@ -257,33 +424,14 @@ public class TestPackUnpack extends TestCase { @Test public void testListTypes01() throws Exception { - SampleListTypes src = new SampleListTypes(); - src.f0 = new ArrayList(); - src.f1 = null; - src.f2 = new ArrayList(); - src.f3 = new ArrayList>(); - src.f4 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleListTypes.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)); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2.size(), dst.f2.size()); - assertEquals(src.f3.size(), dst.f3.size()); - assertEquals(src.f4, dst.f4); - } - - @Test - public void testListTypes02() throws Exception { SampleListTypes src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleListTypes.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleListTypes.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(SampleListTypes.class)); SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in)); assertEquals(src, dst); } @@ -308,6 +456,125 @@ public class TestPackUnpack extends TestCase { } } + @Test + public void testOptionalListTypes00() throws Exception { + SampleOptionalListTypes src = new SampleOptionalListTypes(); + src.f0 = new ArrayList(); + src.f1 = new ArrayList(); + src.f1.add(1); + src.f1.add(2); + src.f1.add(3); + src.f2 = new ArrayList(); + src.f2.add("e1"); + src.f2.add("e2"); + src.f2.add("e3"); + src.f3 = new ArrayList>(); + src.f3.add(src.f2); + src.f4 = new ArrayList(); + 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 srclist = src.f3.get(i); + List 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(); + src.f1 = null; + src.f2 = new ArrayList(); + src.f3 = new ArrayList>(); + src.f4 = null; + 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, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + assertEquals(src.f3.size(), dst.f3.size()); + assertEquals(src.f4, dst.f4); + } + + @Test + public void testOptionalListTypes02() throws Exception { + SampleListTypes src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleOptionalListTypes.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleOptionalListTypes.class)); + SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + public static class SampleOptionalListTypes { + @MessagePackOptional + public List f0; + @MessagePackOptional + public List f1; + @MessagePackOptional + public List f2; + @MessagePackOptional + public List> f3; + @MessagePackOptional + public List f4; + + public SampleOptionalListTypes() { + } + } + + @MessagePackMessage + public static class SampleOptionalListNestedType { + @MessagePackOptional + public byte[] f0; + @MessagePackOptional + public String f1; + + public SampleOptionalListNestedType() { + } + } + @Test public void testMapTypes00() throws Exception { SampleMapTypes src = new SampleMapTypes(); @@ -349,29 +616,14 @@ public class TestPackUnpack extends TestCase { @Test public void testMapTypes01() throws Exception { - SampleMapTypes src = new SampleMapTypes(); - src.f0 = new HashMap(); - src.f1 = null; - src.f2 = new HashMap(); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleMapTypes.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)); - 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; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleMapTypes.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleMapTypes.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(SampleMapTypes.class)); SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in)); assertEquals(src, dst); } @@ -385,6 +637,93 @@ public class TestPackUnpack extends TestCase { } } + @Test + public void testOptionalMapTypes00() throws Exception { + SampleOptionalMapTypes src = new SampleOptionalMapTypes(); + src.f0 = new HashMap(); + src.f1 = new HashMap(); + src.f1.put(1, 1); + src.f1.put(2, 2); + src.f1.put(3, 3); + src.f2 = new HashMap(); + 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 srcf1 = src.f1.keySet().iterator(); + Iterator 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 srcf2 = src.f2.keySet().iterator(); + Iterator 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(); + src.f1 = null; + src.f2 = new HashMap(); + 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, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + } + + @Test + public void testOptionalMapTypes02() throws Exception { + SampleOptionalMapTypes src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleOptionalMapTypes.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleOptionalMapTypes.class)); + SampleOptionalMapTypes dst = (SampleOptionalMapTypes) tmpl + .unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + public static class SampleOptionalMapTypes { + @MessagePackOptional + public Map f0; + @MessagePackOptional + public Map f1; + @MessagePackOptional + public Map f2; + + public SampleOptionalMapTypes() { + } + } + @Test public void testDefaultConstructorModifiers00() throws Exception { try { @@ -615,27 +954,14 @@ public class TestPackUnpack extends TestCase { @Test public void testEnumTypeForOrdinal01() throws Exception { - SampleEnumFieldClass src = new SampleEnumFieldClass(); - src.f1 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker.create(SampleEnumFieldClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate.create(SampleEnumFieldClass.class); - SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl - .unpack(new Unpacker(in)); - assertTrue(src.f0 == dst.f0); - assertEquals(src.f1, dst.f1); - } - - @Test - public void testEnumTypeForOrdinal02() 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); @@ -655,6 +981,72 @@ public class TestPackUnpack extends TestCase { 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 testOptionalEnumTypeForOrdinal02() throws Exception { + SampleEnumFieldClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(SampleEnumFieldClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(SampleEnumFieldClass.class)); + SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + public static class SampleOptionalEnumFieldClass { + @MessagePackOptional + public int f0; + + @MessagePackOptional + public SampleOptionalEnum f1; + + public SampleOptionalEnumFieldClass() { + } + } + + @MessagePackOrdinalEnum + public enum SampleOptionalEnum { + ONE, TWO, THREE; + } + @Test public void testFieldModifiers() throws Exception { FieldModifiersClass src = new FieldModifiersClass(); @@ -687,27 +1079,63 @@ public class TestPackUnpack 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); + OptionalFieldModifiersClass dst = (OptionalFieldModifiersClass) 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); + } + + 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); - 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(); 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.f2 == dst.f1.f2); } @@ -716,41 +1144,21 @@ public class TestPackUnpack extends TestCase { 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); - BaseClass src = new BaseClass(); - src.f1 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - packer1.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - BaseClass dst = (BaseClass) tmpl1.unpack(new Unpacker(in)); - assertTrue(src.f0 == dst.f0); - assertTrue(src.f1 == dst.f1); - } - - @Test - 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); - 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); } @@ -769,6 +1177,96 @@ public class TestPackUnpack extends TestCase { } } + @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()); + OptionalBaseClass dst = (OptionalBaseClass) tmpl + .unpack(new Unpacker(in)); + assertTrue(src.f0 == dst.f0); + assertTrue(src.f1.f2 == dst.f1.f2); + } + + @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(); + 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(); @@ -788,26 +1286,14 @@ public class TestPackUnpack extends TestCase { @Test public void testMessagePackMessageFieldClass01() throws Exception { - BaseClass2 src = new BaseClass2(); - src.f1 = null; - 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); - } - - @Test - 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()); - 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); } @@ -828,6 +1314,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(); @@ -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); } @@ -890,6 +1445,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(); @@ -920,34 +1544,14 @@ public class TestPackUnpack extends TestCase { @Test public void testMessagePackableUnpackableClass01() throws Exception { - BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass(); - src.f0 = null; - src.f1 = 1; - src.f2 = null; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(BaseMessagePackableUnpackableClass.class); - packer.pack(new Packer(out), src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate - .create(BaseMessagePackableUnpackableClass.class); - BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl - .unpack(new Unpacker(in)); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - } - - @Test - public void testMessagePackableUnpackableClass02() throws Exception { BaseMessagePackableUnpackableClass src = null; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicPacker - .create(BaseMessagePackableUnpackableClass.class); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(BaseMessagePackableUnpackableClass.class)); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicTemplate - .create(BaseMessagePackableUnpackableClass.class); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(BaseMessagePackableUnpackableClass.class)); BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl .unpack(new Unpacker(in)); assertEquals(src, dst); @@ -955,9 +1559,7 @@ public class TestPackUnpack extends TestCase { public static class BaseMessagePackableUnpackableClass { public MessagePackableUnpackableClass f0; - public int f1; - public List f2; public BaseMessagePackableUnpackableClass() { @@ -966,9 +1568,7 @@ public class TestPackUnpack extends TestCase { public static class MessagePackableUnpackableClass implements MessagePackable, MessageUnpackable { - public int f0; - public int f1; public MessagePackableUnpackableClass() { @@ -992,4 +1592,108 @@ public class TestPackUnpack extends TestCase { f1 = unpacker.unpackInt(); } } + + @Test + public void testOptionalMessagePackableUnpackableClass00() throws Exception { + OptionalBaseMessagePackableUnpackableClass src = new OptionalBaseMessagePackableUnpackableClass(); + OptionalMessagePackableUnpackableClass src1 = new OptionalMessagePackableUnpackableClass(); + List src2 = new ArrayList(); + 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(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, dst.f0); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2, dst.f2); + } + + @Test + public void testOptionalMessagePackableUnpackableClass02() throws Exception { + OptionalBaseMessagePackableUnpackableClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = new OptionalPacker(DynamicPacker + .create(OptionalBaseMessagePackableUnpackableClass.class)); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = new OptionalTemplate(DynamicTemplate + .create(OptionalBaseMessagePackableUnpackableClass.class)); + OptionalBaseMessagePackableUnpackableClass dst = (OptionalBaseMessagePackableUnpackableClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + public static class OptionalBaseMessagePackableUnpackableClass { + @MessagePackOptional + public OptionalMessagePackableUnpackableClass f0; + @MessagePackOptional + public int f1; + @MessagePackOptional + public List f2; + + public OptionalBaseMessagePackableUnpackableClass() { + } + } + + public static class OptionalMessagePackableUnpackableClass implements + MessagePackable, MessageUnpackable { + @MessagePackOptional + public int f0; + @MessagePackOptional + public int f1; + + public OptionalMessagePackableUnpackableClass() { + } + + @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(); + } + } }