Add test for scala special classes.

Fix enum template

src/main/scala/org/msgpack/scalautil/ScalaSigUtil.scala

@@ -60,7 +60,10 @@ object ScalaSigUtil {
     methodSymbol.infoType match{
       case NullaryMethodType(returnType) => toJavaClass(returnType)
       case MethodType(returnType,methodParams) => toJavaClass(returnType)
-      case _ => None
+      case trt : TypeRefType => toJavaClass(trt)
+      case _ => {
+        None
+      }
     }
   }
 
@@ -87,7 +90,10 @@ object ScalaSigUtil {
           genericParams.map(p => toJavaClass(p,false).get).toArray))
       }
     }
-    case _ => None
+    case _ => {
+      None
+    }
+
   }
   def forName(name : String) = Class.forName(name)
 

src/main/scala/org/msgpack/template/EnumerationTemplate.scala

@@ -2,6 +2,7 @@ package org.msgpack.template
 
 import org.msgpack.unpacker.Unpacker
 import org.msgpack.packer.Packer
+import java.lang.reflect.InvocationTargetException
 
 /**
  *
@@ -15,7 +16,19 @@ class EnumerationTemplate( e : Class[Enumeration]) extends AbstractTemplate[Enum
   }
 
   def read(u: Unpacker, to: Enumeration#Value, required: Boolean): Enumeration#Value = {
-    e.getMethod("apply",java.lang.Integer.TYPE).invoke(
-      null,new java.lang.Integer(u.readInt())).asInstanceOf[Enumeration#Value]
+    try{
+      e.getMethod("apply",java.lang.Integer.TYPE).invoke(
+        null,new java.lang.Integer(u.readInt())).asInstanceOf[Enumeration#Value]
+    }catch{
+      case e : InvocationTargetException => {
+        e.getCause match{
+          case noSuchElement : NoSuchElementException => {
+            // if not exist value, return null
+            null
+          }
+          case _ => throw e
+        }
+      }
+    }
   }
 }

src/main/scala/org/msgpack/template/ScalaTemplateRegistry.scala

@@ -59,6 +59,8 @@ class ScalaTemplateRegistry extends TemplateRegistry(null){
     register(classOf[scala.collection.immutable.List[_]],new ImmutableListTemplate[Any](anyTemplate))
     register(classOf[java.util.Calendar],new CalendarTemplate)
     register(None.getClass,new OptionTemplate[Any](anyTemplate))
+    register(classOf[Some[_]],new OptionTemplate[Any](anyTemplate))
+    register(classOf[Option[_]],new OptionTemplate[Any](anyTemplate))
     register(classOf[Either[Any,Any]],new EitherTemplate[Any,Any](anyTemplate,anyTemplate))
     register(classOf[Left[Any,Any]],new EitherTemplate[Any,Any](anyTemplate,anyTemplate))
     register(classOf[Right[Any,Any]],new EitherTemplate[Any,Any](anyTemplate,anyTemplate))

src/test/scala/org/msgpack/SpecialObjectTest.scala

@@ -0,0 +1,96 @@
+package org.msgpack
+
+import annotation.Message
+import org.specs.Specification
+import org.specs.runner.{JUnitSuiteRunner, JUnit}
+import org.junit.runner.RunWith
+
+/**
+ * Test special class for Scala
+ * User: takeshita
+ * Create: 12/06/20 23:58
+ */
+
+@RunWith(classOf[JUnitSuiteRunner])
+class SpecialObjectTest  extends Specification with JUnit {
+  import specialobj._
+
+  "Option" should{
+    "ser/des Some" in{
+      val b = ScalaMessagePack.write(Some("aaa"))
+      //ScalaMessagePack.read[Some[String]] must_== Some("aaa") this doesn't work because type info of String is erased at runtime.
+      ScalaMessagePack.read[OptionLike](b) must_== OptionLike(true,"aaa")
+    }
+    "ser/des None" in{
+      val b = ScalaMessagePack.write(None)
+      ScalaMessagePack.read[Option[String]](b) must_== None
+      ScalaMessagePack.read[OptionLike](b) must_== OptionLike(false,null)
+    }
+  }
+  "Either" should{
+    "ser/des Left" in{
+      val b = ScalaMessagePack.write(Left("aaa"))
+      ScalaMessagePack.read[EitherLike](b) must_== EitherLike(false,"aaa",null)
+
+    }
+    "ser/des Right" in{
+      val b = ScalaMessagePack.write(Right("bbb"))
+      ScalaMessagePack.read[EitherLike](b) must_== EitherLike(true,null,"bbb")
+
+    }
+  }
+
+  import ScalaMessagePack._
+  "scala's Enum" should{
+    "ser/des exist id" in{
+
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerClass(ScalaEnum.Zero))) must_== EnumContainerClass(ScalaEnum.Zero)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerClass(ScalaEnum.One))) must_== EnumContainerClass(ScalaEnum.One)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerClass(ScalaEnum.Two))) must_== EnumContainerClass(ScalaEnum.Two)
+    }
+    "ser/des from int" in{
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(0))) must_== EnumContainerClass(ScalaEnum.Zero)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(1))) must_== EnumContainerClass(ScalaEnum.One)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(2))) must_== EnumContainerClass(ScalaEnum.Two)
+    }
+    "des not exist id" in{
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(-1))) must_== EnumContainerClass(null)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(3))) must_== EnumContainerClass(null)
+      read[EnumContainerClass](ScalaMessagePack.write(EnumContainerDummy(324354))) must_== EnumContainerClass(null)
+    }
+  }
+
+}
+package specialobj{
+
+  @Message
+  case class OptionLike(var some_? : Boolean,var  value : String){
+    def this() = this(false,null)
+  }
+  @Message
+  case class EitherLike(var right_? : Boolean ,var left : String, var right : String){
+    def this() = this(false,null,null)
+  }
+
+  @Message
+  case class EnumContainerClass(var enum : ScalaEnum.Value){
+    def this() = this(ScalaEnum.Zero)
+
+  }
+
+  @Message
+  case class EnumContainerDummy(var enumV : Int){
+    def this() = this(0)
+  }
+
+  object ScalaEnum extends Enumeration{
+
+    val Zero = Value(0,"zero")
+    val One = Value(1)
+    val Two = Value(2)
+
+  }
+
+
+}
+