summaryrefslogtreecommitdiff
path: root/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
diff options
context:
space:
mode:
authorDen Shabalin <den.shabalin@gmail.com>2013-09-02 16:46:25 +0200
committerDen Shabalin <den.shabalin@gmail.com>2013-09-05 14:35:06 +0200
commitc701fb647ac47f66ae2831d085588328a6851c33 (patch)
treea5ff3d26e3ef7e413e4bc7c1ffe2052cd8df7249 /test/files/scalacheck/quasiquotes/TermConstructionProps.scala
parent652e96911378e9c53a485263425a26ba687f6540 (diff)
downloadscala-c701fb647ac47f66ae2831d085588328a6851c33.tar.gz
scala-c701fb647ac47f66ae2831d085588328a6851c33.tar.bz2
scala-c701fb647ac47f66ae2831d085588328a6851c33.zip
refactor definition tests into separate subsuite
Diffstat (limited to 'test/files/scalacheck/quasiquotes/TermConstructionProps.scala')
-rw-r--r--test/files/scalacheck/quasiquotes/TermConstructionProps.scala201
1 files changed, 9 insertions, 192 deletions
diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
index b14945f24b..5a765f7911 100644
--- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
+++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala
@@ -7,16 +7,6 @@ import scala.reflect.runtime.universe._
import Flag._
object TermConstructionProps extends QuasiquoteProperties("term construction") {
- val anyRef = Select(Ident(TermName("scala")), TypeName("AnyRef"))
- val emtpyConstructor =
- DefDef(
- Modifiers(), nme.CONSTRUCTOR, List(),
- List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(()))))
-
- def classWithMethods(name: TypeName, methods: List[DefDef] = Nil) =
- ClassDef(
- Modifiers(), name, List(),
- Template(List(anyRef), emptyValDef, List(emtpyConstructor) ++ methods))
property("splice single tree return tree itself") = forAll { (t: Tree) =>
q"$t" ≈ t
@@ -26,22 +16,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
q"if($t1) $t2 else $t3" ≈ If(t1, t2, t3)
}
- property("splice term name into val") = forAll { (name: TermName) =>
- q"val $name = 0" ≈ ValDef(Modifiers(), name, TypeTree(), Literal(Constant(0)))
- }
-
- property("splice type name into typedef") = forAll { (name1: TypeName, name2: TypeName) =>
- q"type $name1 = $name2" ≈ TypeDef(Modifiers(), name1, List(), Ident(name2))
- }
-
- property("splice term name into class") = forAll { (name: TypeName) =>
- q"class $name" ≈ classWithMethods(name)
- }
-
- property("splice method into class") = forAll { (name: TypeName, method: DefDef) =>
- q"class $name { $method }" ≈ classWithMethods(name, List(method))
- }
-
property("splice trees into ascriptiopn") = forAll { (t1: Tree, t2: Tree) =>
q"$t1 : $t2" ≈ Typed(t1, t2)
}
@@ -69,19 +43,13 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
}
property("splice trees into block") = forAll { (t1: Tree, t2: Tree, t3: Tree) =>
- q"""{
+ blockInvariant(q"""{
$t1
$t2
$t3
- }""" ≈ Block(List(t1, t2), t3)
+ }""", List(t1, t2, t3))
}
- property("splice type name into class parents") = forAll { (name: TypeName, parent: TypeName) =>
- q"class $name extends $parent" ≈
- ClassDef(
- Modifiers(), name, List(),
- Template(List(Ident(parent)), emptyValDef, List(emtpyConstructor)))
- }
property("splice tree into new") = forAll { (tree: Tree) =>
q"new $tree" ≈ Apply(Select(New(tree), nme.CONSTRUCTOR), List())
@@ -101,13 +69,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
q"$fun($arg1, $arg2, ..$args)" ≈ Apply(fun, List(arg1) ++ List(arg2) ++ args)
}
- property("splice members into class") = forAll { (name: TypeName, defs: List[DefDef], extra: DefDef) =>
- q"""class $name {
- ..$defs
- $extra
- }""" ≈ classWithMethods(name, defs ++ List(extra))
- }
-
property("splice into new") = forAll { (name: TypeName, body: List[Tree]) =>
q"new $name { ..$body }" ≈
q"""{
@@ -118,11 +79,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
}"""
}
-
- property("splice tree into singleton type tree") = forAll { (name: TypeName, t: Tree) =>
- q"type $name = $t.type" ≈ q"type $name = ${SingletonTypeTree(t)}"
- }
-
property("splice type name into this") = forAll { (T: TypeName) =>
q"$T.this" ≈ This(T)
}
@@ -135,65 +91,6 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
q"$fun[..$types]" ≈ TypeApply(fun, types)
}
- property("splice type names into type bounds") = forAll { (T1: TypeName, T2: TypeName, T3: TypeName) =>
- q"type $T1 >: $T2 <: $T3" ≈
- TypeDef(
- Modifiers(DEFERRED), T1, List(),
- TypeBoundsTree(Ident(T2), Ident(T3)))
- }
-
- property("splice trees names into type bounds") = forAll { (T: TypeName, t1: Tree, t2: Tree) =>
- q"type $T >: $t1 <: $t2" ≈
- TypeDef(
- Modifiers(DEFERRED), T, List(),
- TypeBoundsTree(t1, t2))
- }
-
- property("splice tparams into typedef (1)") = forAll { (T: TypeName, targs: List[TypeDef], t: Tree) =>
- q"type $T[..$targs] = $t" ≈ TypeDef(Modifiers(), T, targs, t)
- }
-
- property("splice tparams into typedef (2)") = forAll { (T: TypeName, targs1: List[TypeDef], targs2: List[TypeDef], t: Tree) =>
- q"type $T[..$targs1, ..$targs2] = $t" ≈ TypeDef(Modifiers(), T, targs1 ++ targs2, t)
- }
-
- property("splice tparams into typedef (3)") = forAll { (T: TypeName, targ: TypeDef, targs: List[TypeDef], t: Tree) =>
- q"type $T[$targ, ..$targs] = $t" ≈ TypeDef(Modifiers(), T, targ :: targs, t)
- }
-
- property("splice typename into typedef with default bounds") = forAll { (T1: TypeName, T2: TypeName, t: Tree) =>
- q"type $T1[$T2 >: Any <: Nothing] = $t" ≈
- TypeDef(
- Modifiers(), T1,
- List(TypeDef(
- Modifiers(PARAM), T2,
- List(),
- TypeBoundsTree(
- Ident(TypeName("Any")),
- Ident(TypeName("Nothing"))))),
- t)
- }
-
- property("splice type names into compound type tree") = forAll { (T: TypeName, A: TypeName, B: TypeName) =>
- q"type $T = $A with $B" ≈
- TypeDef(
- Modifiers(), T, List(),
- CompoundTypeTree(
- Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), nme.WILDCARD, TypeTree(), EmptyTree), List())))
- }
-
- property("splice trees into existential type tree") = forAll {
- (T1: TypeName, T2: TypeName, X: TypeName, Lo: TypeName, Hi: TypeName) =>
-
- q"type $T1 = $T2[$X] forSome { type $X >: $Lo <: $Hi }" ≈
- TypeDef(
- Modifiers(), T1, List(),
- ExistentialTypeTree(
- AppliedTypeTree(Ident(T2), List(Ident(X))),
- List(
- TypeDef(Modifiers(DEFERRED), X, List(), TypeBoundsTree(Ident(Lo), Ident(Hi))))))
- }
-
property("splice names into import selector") = forAll {
(expr: Tree, plain: Name, oldname: Name, newname: Name, discard: Name) =>
@@ -223,95 +120,22 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
CaseDef(Alternative(List(A, B)), EmptyTree, Literal(Constant(())))))
}
- property("splice into applied type tree") = forAll { (T1: TypeName, T2: TypeName, args: List[Tree]) =>
- q"type $T1 = $T2[..$args]" ≈
- TypeDef(
- Modifiers(), T1, List(),
- AppliedTypeTree(Ident(T2), args))
- }
-
- property("splice list of trees into block (1)") = forAll { (trees: List[Tree]) =>
- q"{ ..$trees }" ≈ (trees match {
+ def blockInvariant(quote: Tree, trees: List[Tree]) =
+ quote ≈ (trees match {
case Nil => Block(Nil, q"()")
case _ => Block(trees.init, trees.last)
})
+
+ property("splice list of trees into block (1)") = forAll { (trees: List[Tree]) =>
+ blockInvariant(q"{ ..$trees }", trees)
}
property("splice list of trees into block (2)") = forAll { (trees1: List[Tree], trees2: List[Tree]) =>
- q"{ ..$trees1 ; ..$trees2 }" ≈ ((trees1 ++ trees2) match {
- case Nil => Block(Nil, Literal(Constant(())))
- case trees => Block(trees.init, trees.last)
- })
+ blockInvariant(q"{ ..$trees1 ; ..$trees2 }", trees1 ++ trees2)
}
property("splice list of trees into block (3)") = forAll { (trees: List[Tree], tree: Tree) =>
- q"{ ..$trees; $tree }" ≈ Block(trees, tree)
- }
-
- def assertSameAnnots(tree: {def mods: Modifiers}, annots: List[Tree]) =
- assert(tree.mods.annotations ≈ annots,
- s"${tree.mods.annotations} =/= ${annots}")
-
- def assertSameAnnots(tree1: {def mods: Modifiers}, tree2: {def mods: Modifiers}) =
- assert(tree1.mods.annotations ≈ tree2.mods.annotations,
- s"${tree1.mods.annotations} =/= ${tree2.mods.annotations}")
-
- property("splice type name into annotation") = test {
- val name = TypeName("annot")
- assertSameAnnots(q"@$name def foo", List(annot(name)))
- }
-
- property("splice ident into annotation") = test {
- val name = TypeName("annot")
- val ident = Ident(name)
- assertSameAnnots(q"@$ident def foo", List(annot(name)))
- }
-
- property("splice idents into annotation") = test {
- val idents = List(Ident(TypeName("annot1")), Ident(TypeName("annot2")))
- assertSameAnnots(q"@..$idents def foo",
- idents.map { ident => Apply(Select(New(ident), nme.CONSTRUCTOR), List()) })
- }
-
- property("splice constructor calls into annotation") = test {
- val ctorcalls = List(annot("a1"), annot("a2"))
- assertSameAnnots(q"@..$ctorcalls def foo", ctorcalls)
- }
-
- property("splice multiple annotations (1)") = test {
- val annot1 = annot("a1")
- val annot2 = annot("a2")
- val res = q"@$annot1 @$annot2 def foo"
- assertSameAnnots(res, List(annot1, annot2))
- }
-
- property("splice multiple annotations (2)") = test {
- val annot1 = annot("a1")
- val annots = List(annot("a2"), annot("a3"))
- val res = q"@$annot1 @..$annots def foo"
- assertSameAnnots(res, annot1 :: annots)
- }
-
- property("splice annotations with arguments (1)") = test {
- val a = annot("a", List(q"x"))
- assertSameAnnots(q"@$a def foo", q"@a(x) def foo")
- }
-
- property("splice annotations with arguments (2)") = test {
- val a = newTypeName("a")
- assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
- }
-
- property("splice annotations with arguments (3") = test {
- val a = Ident(newTypeName("a"))
- assertSameAnnots(q"@$a(x) def foo", q"@a(x) def foo")
- }
-
- property("can't splice annotations with arguments specificed twice") = test {
- val a = annot("a", List(q"x"))
- assertThrows[IllegalArgumentException] {
- q"@$a(y) def foo"
- }
+ blockInvariant(q"{ ..$trees; $tree }", trees :+ tree)
}
property("splice term into brackets") = test {
@@ -331,11 +155,4 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") {
val empty = List[Tree]()
assert(q"(..$empty)" ≈ q"()")
}
-
- property("splice improper tree into annot") = test {
- val t = tq"Foo[Baz]"
- assertThrows[IllegalArgumentException] {
- q"@$t def foo"
- }
- }
}