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
|
/* NEST (New Scala Test)
* Copyright 2007-2012 LAMP/EPFL
*/
package scala.tools
import java.io.{ FileNotFoundException, File => JFile }
import nsc.io.{ Path, Directory, File => SFile }
import scala.tools.util.PathResolver
import nsc.Properties.{ propOrElse, propOrNone, propOrEmpty }
import scala.sys.process.javaVmArguments
import java.util.concurrent.Callable
package partest {
class TestState {
def isOk = this eq TestState.Ok
def isFail = this eq TestState.Fail
def isTimeout = this eq TestState.Timeout
}
object TestState {
val Ok = new TestState
val Fail = new TestState
val Timeout = new TestState
}
}
package object partest {
import nest.NestUI
implicit private[partest] def temporaryPath2File(x: Path): JFile = x.jfile
implicit private[partest] def temporaryFile2Path(x: JFile): Path = Path(x)
implicit lazy val postfixOps = scala.language.postfixOps
implicit lazy val implicitConversions = scala.language.implicitConversions
def timed[T](body: => T): (T, Long) = {
val t1 = System.currentTimeMillis
val result = body
val t2 = System.currentTimeMillis
(result, t2 - t1)
}
def callable[T](body: => T): Callable[T] = new Callable[T] { override def call() = body }
def path2String(path: String) = file2String(new JFile(path))
def file2String(f: JFile) =
try SFile(f).slurp()
catch { case _: FileNotFoundException => "" }
def basename(name: String): String = Path(name).stripExtension
def resultsToStatistics(results: Iterable[(_, TestState)]): (Int, Int) = {
val (files, failures) = results map (_._2 == TestState.Ok) partition (_ == true)
(files.size, failures.size)
}
def vmArgString = javaVmArguments.mkString(
"Java VM started with arguments: '",
" ",
"'"
)
def allPropertiesString = {
import scala.collection.JavaConversions._
System.getProperties.toList.sorted map { case (k, v) => "%s -> %s\n".format(k, v) } mkString ""
}
def showAllJVMInfo() {
NestUI.verbose(vmArgString)
NestUI.verbose(allPropertiesString)
}
def isPartestDebug: Boolean =
propOrEmpty("partest.debug") == "true"
import scala.language.experimental.macros
/**
* `trace("".isEmpty)` will return `true` and as a side effect print the following to standard out.
* {{{
* trace> "".isEmpty
* res: Boolean = true
*
* }}}
*
* An alternative to [[scala.tools.partest.ReplTest]] that avoids the inconvenience of embedding
* test code in a string.
*/
def trace[A](a: A) = macro traceImpl[A]
import scala.reflect.macros.Context
def traceImpl[A: c.WeakTypeTag](c: Context)(a: c.Expr[A]): c.Expr[A] = {
import c.universe._
import definitions._
// xeno.by: reify shouldn't be used explicitly before the final release of 2.10.0,
// because this impairs reflection refactorings
//
// val exprCode = c.literal(show(a.tree))
// val exprType = c.literal(show(a.actualType))
// reify {
// println(s"trace> ${exprCode.splice}\nres: ${exprType.splice} = ${a.splice}\n")
// a.splice
// }
c.Expr(Block(
List(Apply(
Select(Ident(PredefModule), newTermName("println")),
List(Apply(
Select(Apply(
Select(Ident(ScalaPackage), newTermName("StringContext")),
List(
Literal(Constant("trace> ")),
Literal(Constant("\\nres: ")),
Literal(Constant(" = ")),
Literal(Constant("\\n")))),
newTermName("s")),
List(
Literal(Constant(show(a.tree))),
Literal(Constant(show(a.actualType))),
a.tree))))),
a.tree))
}
}
|
