blob: 91de1fce5e383a44dd8be35291683a15e11c818e (
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
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
trait Output {
val buffer = new StringBuilder
def bufferPrintln(a: Any): Unit = buffer.synchronized {
buffer.append(a.toString + "\n")
}
}
trait MinimalScalaTest extends Output {
val throwables = mutable.ArrayBuffer[Throwable]()
def check() {
if (throwables.nonEmpty) println(buffer.toString)
}
implicit def stringops(s: String) = new {
def should[U](snippets: =>U): U = {
bufferPrintln(s + " should:")
snippets
}
def in[U](snippet: =>U): Unit = {
try {
bufferPrintln("- " + s)
snippet
bufferPrintln("[OK] Test passed.")
} catch {
case e: Throwable =>
bufferPrintln("[FAILED] " + e)
bufferPrintln(e.getStackTrace().mkString("\n"))
throwables += e
}
}
}
implicit def objectops(obj: Any) = new {
def mustBe(other: Any) = assert(obj == other, obj + " is not " + other)
def mustEqual(other: Any) = mustBe(other)
}
def intercept[T <: Throwable: ClassTag](body: =>Any): T = {
try {
body
throw new Exception("Exception of type %s was not thrown".format(classTag[T]))
} catch {
case t: Throwable =>
if (classTag[T].runtimeClass != t.getClass) throw t
else t.asInstanceOf[T]
}
}
def checkType[T: ClassTag, S](in: Future[T], refclasstag: ClassTag[S]): Boolean = classTag[T] == refclasstag
}
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("Timeout of %s." format (atMost.toString))
this
}
@throws(classOf[Exception])
def result(atMost: Duration)(implicit permit: CanAwait): Unit = {
ready(atMost)
}
}
|
