From 5e4c47f33b8e25feb59ab4599231b1b8d3150de8 Mon Sep 17 00:00:00 2001
From: Eugene Burmako <xeno.by@gmail.com>
Date: Sat, 14 Apr 2012 21:11:37 +0200
Subject: implements reification of tough types

---
 test/files/jvm/manifests.scala | 112 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 test/files/jvm/manifests.scala

(limited to 'test/files/jvm/manifests.scala')

diff --git a/test/files/jvm/manifests.scala b/test/files/jvm/manifests.scala
new file mode 100644
index 0000000000..935427f5d4
--- /dev/null
+++ b/test/files/jvm/manifests.scala
@@ -0,0 +1,112 @@
+object Test extends App {
+  Test1
+  Test2
+}
+
+class Foo[T](x: T)
+trait Bar[T] { def f: T }
+
+object Test1 extends TestUtil {
+  print(())
+  print(true)
+  print('a')
+  print(1)
+  print("abc")
+  print('abc)
+  println()
+
+  print(List(()))
+  print(List(true))
+  print(List(1))
+  print(List("abc"))
+  print(List('abc))
+  println()
+
+  //print(Array(()))  //Illegal class name "[V" in class file Test$
+  print(Array(true))
+  print(Array('a'))
+  print(Array(1))
+  print(Array("abc"))
+  print(Array('abc))
+  println()
+
+  print(((), ()))
+  print((true, false))
+  print((1, 2))
+  print(("abc", "xyz"))
+  print(('abc, 'xyz))
+  println()
+
+  // Disabled: should these work? changing the inference for objects from
+  // "object Test" to "Test.type" drags in a singleton manifest which for
+  // some reason leads to serialization failure.
+  // print(Test)
+  // print(List)
+  println()
+
+  print(new Foo(2))
+  print(new Foo(List(2)))
+  print(new Foo(new Foo(2)))
+  print(new Foo(List(new Foo(2))))
+  println()
+
+  print(new Bar[String] { def f = "abc" });
+  {print(new Bar[String] { def f = "abc" })}
+  println()
+}
+
+object Test2 {
+  import scala.util.Marshal._
+  println("()="+load[Unit](dump(())))
+  println("true="+load[Boolean](dump(true)))
+  println("a="+load[Char](dump('a')))
+  println("1="+load[Int](dump(1)))
+  println("'abc="+load[Symbol](dump('abc)))
+  println()
+
+  println("List(())="+load[List[Unit]](dump(List(()))))
+  println("List(true)="+load[List[Boolean]](dump(List(true))))
+  println("List('abc)="+load[List[Symbol]](dump(List('abc))))
+  println()
+
+  def loadArray[T](x: Array[Byte])(implicit m: reflect.Manifest[Array[T]]) =
+    load[Array[T]](x)(m).deep.toString
+  println("Array()="+loadArray[Int](dump(Array(): Array[Int])))
+  println("Array(true)="+loadArray[Boolean](dump(Array(true))))
+  println("Array(a)="+loadArray[Char](dump(Array('a'))))
+  println("Array(1)="+loadArray[Int](dump(Array(1))))
+  println()
+
+  println("((),())="+load[(Unit, Unit)](dump(((), ()))))
+  println("(true,false)="+load[(Boolean, Boolean)](dump((true, false))))
+  println()
+
+  println("List(List(1), List(2))="+load[List[List[Int]]](dump(List(List(1), List(2)))))
+  println()
+
+  println("Array(Array(1), Array(2))="+loadArray[Array[Int]](dump(Array(Array(1), Array(2)))))
+  println()
+}
+
+trait TestUtil {
+  import java.io._
+  def write[A](o: A): Array[Byte] = {
+    val ba = new ByteArrayOutputStream(512)
+    val out = new ObjectOutputStream(ba)
+    out.writeObject(o)
+    out.close()
+    ba.toByteArray()
+  }
+  def read[A](buffer: Array[Byte]): A = {
+    val in = new ObjectInputStream(new ByteArrayInputStream(buffer))
+    in.readObject().asInstanceOf[A]
+  }
+  import scala.reflect._
+  def print[T](x: T)(implicit m: Manifest[T]) {
+    // manifests are no longer serializable
+//    val m1: Manifest[T] = read(write(m))
+    val m1: Manifest[T] = m
+    val x1 = x.toString.replaceAll("@[0-9a-z]+$", "")
+    println("x="+x1+", m="+m1+", k="+m1.tpe.kind+", s="+m1.sym.toString)
+  }
+}
-- 
cgit v1.2.3