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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
package magnolia.tests
import magnolia._
import estrapade._
import contextual.data.scalac._
import contextual.data.fqt._
import contextual.data.txt._
import scala.util._
sealed trait Tree[+T]
case class Leaf[+L](value: L) extends Tree[L]
case class Branch[+B](left: Tree[B], right: Tree[B]) extends Tree[B]
sealed trait Entity
case class Company(name: String) extends Entity
case class Person(name: String, age: Int) extends Entity
case class Address(line1: String, occupant: Person)
class Length(val value: Int) extends AnyVal
case class Lunchbox(fruit: Fruit, drink: String)
object Fruit {
import examples._
implicit val showFruit: Show[String, Fruit] =
new Show[String, Fruit] { def show(f: Fruit): String = f.name }
}
case class Fruit(name: String)
case class Item(name: String, quantity: Int = 1, price: Int)
sealed trait Color
case object Red extends Color
case object Green extends Color
case object Blue extends Color
case class `%%`(`/`: Int, `#`: String)
class ParentClass() {
case class InnerClass(name: String)
}
object Tests extends TestApp {
def tests() = for (i <- 1 to 1000) {
import examples._
test("construct a Show product instance") {
import examples._
Show.gen[Person].show(Person("John Smith", 34))
}.assert(_ == """Person(name=John Smith,age=34)""")
test("construct a Show coproduct instance") {
import examples._
Show.gen[Person].show(Person("John Smith", 34))
}.assert(_ == "Person(name=John Smith,age=34)")
test("serialize a Branch") {
import magnolia.examples._
implicitly[Show[String, Branch[String]]].show(Branch(Leaf("LHS"), Leaf("RHS")))
}.assert(_ == "Branch(left=Leaf(value=LHS),right=Leaf(value=RHS))")
test("local implicit beats Magnolia") {
import magnolia.examples._
implicit val showPerson: Show[String, Person] = new Show[String, Person] {
def show(p: Person) = "nobody"
}
implicitly[Show[String, Address]].show(Address("Home", Person("John Smith", 44)))
}.assert(_ == "Address(line1=Home,occupant=nobody)")
test("even low-priority implicit beats Magnolia for nested case") {
import magnolia.examples._
import Show.gen
implicitly[Show[String, Lunchbox]].show(Lunchbox(Fruit("apple"), "lemonade"))
}.assert(_ == "Lunchbox(fruit=apple,drink=lemonade)")
test("low-priority implicit does not beat Magnolia when not nested") {
import magnolia.examples._
import Show.gen
implicitly[Show[String, Fruit]].show(Fruit("apple"))
}.assert(_ == "Fruit(name=apple)")
test("typeclass implicit scope has lower priority than ADT implicit scope") {
import magnolia.examples._
implicitly[Show[String, Fruit]].show(Fruit("apple"))
}.assert(_ == "apple")
test("test equality false") {
import examples._
Eq.gen[Entity].equal(Person("John Smith", 34), Person("", 0))
}.assert(_ == false)
test("test equality true") {
import examples._
Eq.gen[Entity].equal(Person("John Smith", 34), Person("John Smith", 34))
}.assert(_ == true)
test("test branch equality true") {
import examples._
Eq.gen[Tree[String]].equal(Branch(Leaf("one"), Leaf("two")), Branch(Leaf("one"), Leaf("two")))
}.assert(_ == true)
test("construct a default value") {
Default.gen[Entity].default
}.assert(_ == Company(""))
test("construction of Show instance for Leaf") {
scalac"""
import magnolia.examples._
implicitly[Show[String, Leaf[java.lang.String]]]
"""
}.assert(_ == Returns(fqt"magnolia.examples.Show[String,magnolia.tests.Leaf[String]]"))
test("construction of Show instance for Tree") {
scalac"""
import magnolia.examples._
implicitly[Show[String, Tree[String]]]
"""
}.assert(_ == Returns(fqt"magnolia.examples.Show[String,magnolia.tests.Tree[String]]"))
test("serialize a Leaf") {
implicitly[Show[String, Leaf[String]]].show(Leaf("testing"))
}.assert(_ == "Leaf(value=testing)")
test("serialize a Branch as a Tree") {
implicitly[Show[String, Tree[String]]].show(Branch(Leaf("LHS"), Leaf("RHS")))
}.assert(_ == "Branch(left=Leaf(value=LHS),right=Leaf(value=RHS))")
test("serialize case object") {
implicitly[Show[String, Red.type]].show(Red)
}.assert(_ == "Red()")
test("access default constructor values") {
implicitly[Default[Item]].default
}.assert(_ == Item("", 1, 0))
test("serialize case object as a sealed trait") {
implicitly[Show[String, Color]].show(Blue)
}.assert(_ == "Blue()")
test("decode a company") {
Decoder.gen[Company].decode("""Company(name=Acme Inc)""")
}.assert(_ == Company("Acme Inc"))
test("decode a Person as an Entity") {
implicitly[Decoder[Entity]].decode("""magnolia.tests.Person(name=John Smith,age=32)""")
}.assert(_ == Person("John Smith", 32))
test("decode a nested product") {
implicitly[Decoder[Address]].decode(
"""Address(line1=53 High Street,occupant=Person(name=Richard Jones,age=44))"""
)
}.assert(_ == Address("53 High Street", Person("Richard Jones", 44)))
test("show error stack") {
scalac"""
import magnolia.examples._
case class Alpha(integer: Double)
case class Beta(alpha: Alpha)
Show.gen[Beta]
"""
}.assert(_ == TypecheckError(txt"""magnolia: could not find typeclass for type Double
| in parameter 'integer' of product type Alpha
| in parameter 'alpha' of product type Beta
|"""))
test("typenames and labels are not encoded") {
implicitly[Show[String, `%%`]].show(`%%`(1, "two"))
}.assert(_ == "%%(/=1,#=two)")
val tupleDerivation = test("derive for a tuple") {
implicitly[Show[String, (Int, String)]]
}.returns()
test("serialize a tuple") {
tupleDerivation().show((42, "Hello World"))
}.assert(_ == "Tuple2(_1=42,_2=Hello World)")
test("serialize a value class") {
Show.gen[Length].show(new Length(100))
}.assert(_ == "100")
test("serialize a case class inside another class") {
val parent = new ParentClass()
implicitly[Show[String, parent.InnerClass]].show(parent.InnerClass("foo"))
}.assert(_ == "InnerClass(name=foo)")
}
}
|
