Fleshed out the mock code a little further so i...

Fleshed out the mock code a little further so it's easy for closures to
become SAMs.

// implicit not necessary, but improves fun factor
scala> implicit def mkUFn(x: AnyRef) = scala.tools.reflect.UniversalFn(x)
mkUFn: (x: AnyRef)scala.tools.reflect.UniversalFn

scala> (() => 5*5*5).as[java.util.concurrent.Callable[Int]]

res1: java.util.concurrent.Callable[Int] = <function1>

scala> res1.call
res2: Int = 125

No review.

1 files changed, 29 insertions, 0 deletions

diff --git a/test/files/run/mock.scala b/test/files/run/mock.scala
new file mode 100644
index 0000000000..e414e51e2d
--- /dev/null
+++ b/test/files/run/mock.scala
@@ -0,0 +1,29 @@
+import scala.tools.reflect._
+import java.util.concurrent.Callable
+import java.io.Closeable
+
+object Test {
+  // It'd be really nice about now if functions had a common parent.
+  implicit def interfaceify(x: AnyRef): UniversalFn = UniversalFn(x)
+
+  def runner(x: Runnable) = x.run()
+  def caller[T](x: Callable[T]): T = x.call()
+  def closer(x: Closeable) = x.close()
+
+  def main(args: Array[String]): Unit = {
+    var counter = 0
+    val closure = () => {
+      counter += 1
+      println("Hi, thanks for calling: that makes " + counter + " times.")
+      counter
+    }
+
+    val int1 = closure.as[Runnable]
+    val int2 = closure.as[Callable[Int]]
+    val int3 = closure.as[Closeable]
+
+    runner(int1)
+    caller(int2)
+    closer(int3)
+  }
+}