blob: af5b04ef156d62ae22ccee9c7849f29827c4e5a0 (
plain) (
blame)
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
|
package scala.async
import language.reflectiveCalls
import language.postfixOps
import language.implicitConversions
import scala.reflect.{ClassTag, classTag}
import scala.collection.mutable
import scala.concurrent.{Future, Awaitable, CanAwait}
import java.util.concurrent.{TimeoutException, CountDownLatch, TimeUnit}
import scala.concurrent.duration.Duration
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
trait Output {
val buffer = new StringBuilder
def bufferPrintln(a: Any): Unit = buffer.synchronized {
buffer.append(a.toString + "\n")
}
}
trait MinimalScalaTest extends Output {
implicit class objectops(obj: Any) {
def mustBe(other: Any) = assert(obj == other, obj + " is not " + other)
def mustEqual(other: Any) = mustBe(other)
}
implicit class stringops(text: String) {
def mustContain(substring: String) = assert(text contains substring, text)
}
def intercept[T <: Throwable : ClassTag](body: => Any): T = {
try {
body
throw new Exception(s"Exception of type ${classTag[T]} was not thrown")
} catch {
case t: Throwable =>
if (classTag[T].runtimeClass != t.getClass) throw t
else t.asInstanceOf[T]
}
}
}
object TestLatch {
val DefaultTimeout = Duration(5, TimeUnit.SECONDS)
def apply(count: Int = 1) = new TestLatch(count)
}
class TestLatch(count: Int = 1) extends Awaitable[Unit] {
private var latch = new CountDownLatch(count)
def countDown() = latch.countDown()
def isOpen: Boolean = latch.getCount == 0
def open() = while (!isOpen) countDown()
def reset() = latch = new CountDownLatch(count)
@throws(classOf[TimeoutException])
def ready(atMost: Duration)(implicit permit: CanAwait) = {
val opened = latch.await(atMost.toNanos, TimeUnit.NANOSECONDS)
if (!opened) throw new TimeoutException(s"Timeout of ${(atMost.toString)}.")
this
}
@throws(classOf[Exception])
def result(atMost: Duration)(implicit permit: CanAwait): Unit = {
ready(atMost)
}
}
|
