1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
* Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
*/
package scala.async
package run
package toughtype
import language.{reflectiveCalls, postfixOps}
import scala.concurrent._
import scala.concurrent.duration._
import scala.async.Async._
import org.junit.Test
import scala.async.internal.AsyncId
object ToughTypeObject {
import ExecutionContext.Implicits.global
class Inner
def m2 = async[(List[_], ToughTypeObject.Inner)] {
val y = await(future[List[_]](Nil))
val z = await(future[Inner](new Inner))
(y, z)
}
}
class ToughTypeSpec {
@Test def `propogates tough types`() {
val fut = ToughTypeObject.m2
val res: (List[_], scala.async.run.toughtype.ToughTypeObject.Inner) = Await.result(fut, 2 seconds)
res._1 mustBe (Nil)
}
@Test def patternMatchingPartialFunction() {
import AsyncId.{await, async}
async {
await(1)
val a = await(1)
val f = { case x => x + a }: PartialFunction[Int, Int]
await(f(2))
} mustBe 3
}
@Test def patternMatchingPartialFunctionNested() {
import AsyncId.{await, async}
async {
await(1)
val neg1 = -1
val a = await(1)
val f = { case x => ({case x => neg1 * x}: PartialFunction[Int, Int])(x + a) }: PartialFunction[Int, Int]
await(f(2))
} mustBe -3
}
@Test def patternMatchingFunction() {
import AsyncId.{await, async}
async {
await(1)
val a = await(1)
val f = { case x => x + a }: Function[Int, Int]
await(f(2))
} mustBe 3
}
@Test def existentialBindIssue19() {
import AsyncId.{await, async}
def m7(a: Any) = async {
a match {
case s: Seq[_] =>
val x = s.size
var ss = s
ss = s
await(x)
}
}
m7(Nil) mustBe 0
}
@Test def existentialBind2Issue19() {
import scala.async.Async._, scala.concurrent.ExecutionContext.Implicits.global
def conjure[T]: T = null.asInstanceOf[T]
def m3 = async {
val p: List[Option[_]] = conjure[List[Option[_]]]
await(future(1))
}
def m4 = async {
await(future[List[_]](Nil))
}
}
@Test def singletonTypeIssue17() {
import AsyncId.{async, await}
class A { class B }
async {
val a = new A
def foo(b: a.B) = 0
await(foo(new a.B))
}
}
@Test def existentialMatch() {
import AsyncId.{async, await}
trait Container[+A]
case class ContainerImpl[A](value: A) extends Container[A]
def foo: Container[_] = async {
val a: Any = List(1)
a match {
case buf: Seq[_] =>
val foo = await(5)
val e0 = buf(0)
ContainerImpl(e0)
}
}
foo
}
@Test def existentialIfElse0() {
import AsyncId.{async, await}
trait Container[+A]
case class ContainerImpl[A](value: A) extends Container[A]
def foo: Container[_] = async {
val a: Any = List(1)
if (true) {
val buf: Seq[_] = List(1)
val foo = await(5)
val e0 = buf(0)
ContainerImpl(e0)
} else ???
}
foo
}
}
|
