Skip to content

Commit b8bdbf3

Browse files
author
Antoine Brunner
committed
Implement a test for every extension method
1 parent b3d1088 commit b8bdbf3

File tree

3 files changed

+214
-75
lines changed

3 files changed

+214
-75
lines changed

‎library/src-bootstrapped/scala/IArray.scala‎

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -42,162 +42,162 @@ object opaques
4242
/** All the methods on Array[T] that don't mutate in-place can be used with IArray[T].
4343
*/
4444
def [T, U >: T: ClassTag](arr: IArray[T]) ++(that: IArray[U]): IArray[U] =
45-
(arr.asInstanceOf[Array[T]] ++ that.asInstanceOf[Array[U]]).asInstanceOf[IArray[U]]
45+
(genericArrayOps(arr) ++ that.asInstanceOf[Array[U]]).asInstanceOf[IArray[U]]
4646

4747
def [T](arr: IArray[T]) contains(elem: T): Boolean =
48-
arr.asInstanceOf[Array[T]].contains(elem)
48+
genericArrayOps(arr.asInstanceOf[Array[T]]).contains(elem)
4949

5050
def [T](arr: IArray[T]) count(p: T => Boolean): Int =
51-
arr.asInstanceOf[Array[T]].count(p)
51+
genericArrayOps(arr).count(p)
5252

5353
def [T](arr: IArray[T]) drop(n: Int): IArray[T] =
54-
arr.asInstanceOf[Array[T]].drop(n).asInstanceOf[IArray[T]]
54+
genericArrayOps(arr).drop(n).asInstanceOf[IArray[T]]
5555

5656
def [T](arr: IArray[T]) dropRight(n: Int): IArray[T] =
57-
arr.asInstanceOf[Array[T]].dropRight(n).asInstanceOf[IArray[T]]
57+
genericArrayOps(arr).dropRight(n).asInstanceOf[IArray[T]]
5858

5959
def [T](arr: IArray[T]) dropWhile(p: T => Boolean): IArray[T] =
60-
arr.asInstanceOf[Array[T]].dropWhile(p).asInstanceOf[IArray[T]]
60+
genericArrayOps(arr).dropWhile(p).asInstanceOf[IArray[T]]
6161

6262
def [T](arr: IArray[T]) exists(p: T => Boolean): IArray[T] =
63-
arr.asInstanceOf[Array[T]].exists(p).asInstanceOf[IArray[T]]
63+
genericArrayOps(arr).exists(p).asInstanceOf[IArray[T]]
6464

6565
def [T](arr: IArray[T]) filter(p: T => Boolean): IArray[T] =
66-
arr.asInstanceOf[Array[T]].filter(p).asInstanceOf[IArray[T]]
66+
genericArrayOps(arr).filter(p).asInstanceOf[IArray[T]]
6767

6868
def [T](arr: IArray[T]) filterNot(p: T => Boolean): IArray[T] =
69-
arr.asInstanceOf[Array[T]].filterNot(p).asInstanceOf[IArray[T]]
69+
genericArrayOps(arr).filterNot(p).asInstanceOf[IArray[T]]
7070

7171
def [T](arr: IArray[T]) find(p: T => Boolean): Option[T] =
72-
arr.asInstanceOf[Array[T]].find(p)
72+
genericArrayOps(arr).find(p)
7373

7474
def [T, U: ClassTag](arr: IArray[T]) flatMap(f: T => IterableOnce[U]): IArray[U] =
75-
arr.asInstanceOf[Array[T]].flatMap(f).asInstanceOf[IArray[U]]
75+
genericArrayOps(arr).flatMap(f).asInstanceOf[IArray[U]]
7676

7777
def [T, U: ClassTag](arr: IArray[T]) flatten(given T => Iterable[U]): IArray[U] =
78-
arr.asInstanceOf[Array[T]].flatten.asInstanceOf[IArray[U]]
78+
genericArrayOps(arr).flatten.asInstanceOf[IArray[U]]
7979

8080
def [T, U >: T: ClassTag](arr: IArray[T]) fold(z: U)(op: (U, U) => U): U =
81-
arr.asInstanceOf[Array[T]].fold(z)(op)
81+
genericArrayOps(arr).fold(z)(op)
8282

83-
def [T, U >: T: ClassTag](arr: IArray[T]) foldLeft(z: U)(op: (U, T) => U): U =
84-
arr.asInstanceOf[Array[T]].foldLeft(z)(op)
83+
def [T, U: ClassTag](arr: IArray[T]) foldLeft(z: U)(op: (U, T) => U): U =
84+
genericArrayOps(arr).foldLeft(z)(op)
8585

86-
def [T, U >: T: ClassTag](arr: IArray[T]) foldRight(z: U)(op: (T, U) => U): U =
87-
arr.asInstanceOf[Array[T]].foldRight(z)(op)
86+
def [T, U: ClassTag](arr: IArray[T]) foldRight(z: U)(op: (T, U) => U): U =
87+
genericArrayOps(arr).foldRight(z)(op)
8888

8989
def [T](arr: IArray[T]) forall(p: T => Boolean): Boolean =
90-
arr.asInstanceOf[Array[T]].forall(p)
90+
genericArrayOps(arr).forall(p)
9191

9292
def [T, U](arr: IArray[T]) foreach(f: T => U): Unit =
93-
arr.asInstanceOf[Array[T]].foreach(f)
93+
genericArrayOps(arr).foreach(f)
9494

9595
def [T](arr: IArray[T]) head: T =
96-
arr.asInstanceOf[Array[T]].head
96+
genericArrayOps(arr).head
9797

9898
def [T](arr: IArray[T]) headOption: Option[T] =
99-
arr.asInstanceOf[Array[T]].headOption
99+
genericArrayOps(arr).headOption
100100

101101
def [T](arr: IArray[T]) indexOf(elem: T, from: Int = 0): Int =
102-
arr.asInstanceOf[Array[T]].indexOf(elem, from)
102+
genericArrayOps(arr.asInstanceOf[Array[T]]).indexOf(elem, from)
103103

104104
def [T](arr: IArray[T]) indexWhere(p: T => Boolean, from: Int = 0): Int =
105-
arr.asInstanceOf[Array[T]].indexWhere(p, from)
105+
genericArrayOps(arr).indexWhere(p, from)
106106

107107
def [T](arr: IArray[T]) indices: Range =
108-
arr.asInstanceOf[Array[T]].indices
108+
genericArrayOps(arr).indices
109109

110110
def [T](arr: IArray[T]) init: IArray[T] =
111-
arr.asInstanceOf[Array[T]].init.asInstanceOf[IArray[T]]
111+
genericArrayOps(arr).init.asInstanceOf[IArray[T]]
112112

113113
def [T](arr: IArray[T]) isEmpty: Boolean =
114-
arr.asInstanceOf[Array[T]].isEmpty
114+
genericArrayOps(arr).isEmpty
115115

116116
def [T](arr: IArray[T]) iterator: Iterator[T] =
117-
arr.asInstanceOf[Array[T]].iterator
117+
genericArrayOps(arr).iterator
118118

119119
def [T](arr: IArray[T]) last: T =
120-
arr.asInstanceOf[Array[T]].last
120+
genericArrayOps(arr).last
121121

122122
def [T](arr: IArray[T]) lastOption: Option[T] =
123-
arr.asInstanceOf[Array[T]].lastOption
123+
genericArrayOps(arr).lastOption
124124

125125
def [T](arr: IArray[T]) lastIndexOf(elem: T, from: Int = 0): Int =
126-
arr.asInstanceOf[Array[T]].lastIndexOf(elem, from)
126+
genericArrayOps(arr.asInstanceOf[Array[T]]).lastIndexOf(elem, from)
127127

128128
def [T](arr: IArray[T]) lastIndexWhere(p: T => Boolean, from: Int = 0): Int =
129-
arr.asInstanceOf[Array[T]].lastIndexWhere(p, from)
129+
genericArrayOps(arr).lastIndexWhere(p, from)
130130

131131
def [T, U: ClassTag](arr: IArray[T]) map(f: T => U): IArray[U] =
132-
arr.asInstanceOf[Array[T]].map(f).asInstanceOf[IArray[U]]
132+
genericArrayOps(arr).map(f).asInstanceOf[IArray[U]]
133133

134134
def [T](arr: IArray[T]) nonEmpty: Boolean =
135-
arr.asInstanceOf[Array[T]].nonEmpty
135+
genericArrayOps(arr).nonEmpty
136136

137137
def [T](arr: IArray[T]) partition(p: T => Boolean): (IArray[T], IArray[T]) =
138-
arr.asInstanceOf[Array[T]].partition(p) match {
138+
genericArrayOps(arr).partition(p) match {
139139
case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
140140
}
141141

142142
def [T](arr: IArray[T]) reverse: IArray[T] =
143-
arr.asInstanceOf[Array[T]].reverse.asInstanceOf[IArray[T]]
143+
genericArrayOps(arr).reverse.asInstanceOf[IArray[T]]
144144

145145
def [T, U >: T: ClassTag](arr: IArray[T]) scan(z: U)(op: (U, U) => U): IArray[U] =
146-
arr.asInstanceOf[Array[T]].scan(z)(op).asInstanceOf[IArray[U]]
146+
genericArrayOps(arr).scan(z)(op).asInstanceOf[IArray[U]]
147147

148148
def [T, U: ClassTag](arr: IArray[T]) scanLeft(z: U)(op: (U, T) => U): IArray[U] =
149-
arr.asInstanceOf[Array[T]].scanLeft(z)(op).asInstanceOf[IArray[U]]
149+
genericArrayOps(arr).scanLeft(z)(op).asInstanceOf[IArray[U]]
150150

151151
def [T, U: ClassTag](arr: IArray[T]) scanRight(z: U)(op: (T, U) => U): IArray[U] =
152-
arr.asInstanceOf[Array[T]].scanRight(z)(op).asInstanceOf[IArray[U]]
152+
genericArrayOps(arr).scanRight(z)(op).asInstanceOf[IArray[U]]
153153

154154
def [T](arr: IArray[T]) size: Int =
155-
arr.asInstanceOf[Array[T]].size
155+
arr.length
156156

157157
def [T](arr: IArray[T]) slice(from: Int, until: Int): IArray[T] =
158-
arr.asInstanceOf[Array[T]].slice(from, until).asInstanceOf[IArray[T]]
158+
genericArrayOps(arr).slice(from, until).asInstanceOf[IArray[T]]
159159

160160
def [T, U: ClassTag](arr: IArray[T]) sortBy(f: T => U)(given math.Ordering[U]): IArray[T] =
161-
arr.asInstanceOf[Array[T]].sortBy(f).asInstanceOf[IArray[T]]
161+
genericArrayOps(arr).sortBy(f).asInstanceOf[IArray[T]]
162162

163163
def [T](arr: IArray[T]) sortWith(f: (T, T) => Boolean): IArray[T] =
164-
arr.asInstanceOf[Array[T]].sortWith(f).asInstanceOf[IArray[T]]
164+
genericArrayOps(arr).sortWith(f).asInstanceOf[IArray[T]]
165165

166166
def [T](arr: IArray[T]) sorted(given math.Ordering[T]): IArray[T] =
167-
arr.asInstanceOf[Array[T]].sorted.asInstanceOf[IArray[T]]
167+
genericArrayOps(arr).sorted.asInstanceOf[IArray[T]]
168168

169169
def [T](arr: IArray[T]) span(p: T => Boolean): (IArray[T], IArray[T]) =
170-
arr.asInstanceOf[Array[T]].span(p) match {
170+
genericArrayOps(arr).span(p) match {
171171
case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
172172
}
173173

174174
def [T](arr: IArray[T]) splitAt(n: Int): (IArray[T], IArray[T]) =
175-
arr.asInstanceOf[Array[T]].splitAt(n) match {
175+
genericArrayOps(arr).splitAt(n) match {
176176
case (x, y) => (x.asInstanceOf[IArray[T]], y.asInstanceOf[IArray[T]])
177177
}
178178

179179
def [T, U >: T: ClassTag](arr: IArray[T]) startsWith(that: IArray[U], offset: Int = 0): Boolean =
180-
arr.asInstanceOf[Array[T]].startsWith(that.asInstanceOf[Array[U]])
180+
genericArrayOps(arr).startsWith(that.asInstanceOf[Array[U]])
181181

182182
def [T](arr: IArray[T]) tail: IArray[T] =
183-
arr.asInstanceOf[Array[T]].tail.asInstanceOf[IArray[T]]
183+
genericArrayOps(arr).tail.asInstanceOf[IArray[T]]
184184

185185
def [T](arr: IArray[T]) take(n: Int): IArray[T] =
186-
arr.asInstanceOf[Array[T]].take(n).asInstanceOf[IArray[T]]
186+
genericArrayOps(arr).take(n).asInstanceOf[IArray[T]]
187187

188188
def [T](arr: IArray[T]) takeRight(n: Int): IArray[T] =
189-
arr.asInstanceOf[Array[T]].takeRight(n).asInstanceOf[IArray[T]]
189+
genericArrayOps(arr).takeRight(n).asInstanceOf[IArray[T]]
190190

191191
def [T](arr: IArray[T]) takeWhile(p: T => Boolean): IArray[T] =
192-
arr.asInstanceOf[Array[T]].takeWhile(p).asInstanceOf[IArray[T]]
192+
genericArrayOps(arr).takeWhile(p).asInstanceOf[IArray[T]]
193193

194194
def [U: ClassTag, V: ClassTag](arr: IArray[(U, V)]) unzip: (IArray[U], IArray[V]) =
195-
arr.asInstanceOf[Array[(U, V)]].unzip match {
195+
genericArrayOps(arr).unzip match {
196196
case (x, y) => (x.asInstanceOf[IArray[U]], y.asInstanceOf[IArray[V]])
197197
}
198198

199-
def [T, U: ClassTag](arr: IArray[T]) zip(that: IterableOnce[U]): IArray[(T, U)] =
200-
arr.asInstanceOf[Array[T]].zip(that).asInstanceOf[IArray[(T, U)]]
199+
def [T, U: ClassTag](arr: IArray[T]) zip(that: IArray[U]): IArray[(T, U)] =
200+
genericArrayOps(arr).zip(that).asInstanceOf[IArray[(T, U)]]
201201
end opaques
202202

203203
type IArray[+T] = opaques.IArray[T]

‎tests/run-bootstrapped/iarray-extmtds.check‎

Lines changed: 59 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,63 @@
1-
IArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
1+
IArray(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
22
true
3-
false
43
5
5-
IArray(9, 10)
6-
IArray(1, 2)
7-
IArray(8, 9, 10)
4+
IArray(9,10)
5+
IArray(1,2)
6+
IArray(8,9,10)
87
true
9-
IArray(2, 4, 6, 8, 10)
10-
IArray(1, 3, 5, 7, 9)
8+
IArray(2,4,6,8,10)
9+
IArray(1,3,5,7,9)
1110
Some(5)
11+
IArray(1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10)
12+
IArray(1,2,3,4)
13+
55
14+
12345678910
15+
10987654321
16+
false
17+
1
18+
2
19+
3
20+
4
21+
5
22+
6
23+
7
24+
8
25+
9
26+
10
27+
11
28+
Some(1)
29+
-1
30+
3
31+
0,1,2,3,4,5,6,7,8,9
32+
IArray(1,2,3,4,5,6,7,8,9)
33+
false
34+
1,2,3
35+
10
36+
Some(20)
37+
6
38+
3
39+
IArray(11,12,13,14,15,16,17,18,19,20)
40+
true
41+
IArray(2,4,6,8,10)
42+
IArray(1,3,5,7,9)
43+
IArray(10,9,8,7,6,5,4,3,2,1)
44+
IArray(0,1,3,6,10,15,21,28,36,45,55)
45+
IArray(,1,12,123,1234,12345,123456,1234567,12345678,123456789,12345678910)
46+
IArray(10987654321,1098765432,109876543,10987654,1098765,109876,10987,1098,109,10,)
47+
10
48+
IArray(6,7)
49+
IArray(10,9,8,7,6,5,4,3,2,1)
50+
IArray(10,1,2,3,4,5,6,7,8,9)
51+
IArray(1,2,3,4,5,6,7,8,9,10)
52+
IArray(1,2,3,4)
53+
IArray(5,6,7,8,9,10)
54+
IArray(1,2,3,4,5,6,7)
55+
IArray(8,9,10)
56+
false
57+
IArray(2,3,4,5,6,7,8,9,10)
58+
IArray(1,2,3)
59+
IArray(7,8,9,10)
60+
IArray(1,2)
61+
IArray(1,2,3)
62+
IArray(1,2,3)
63+
IArray((1,11),(2,12),(3,13),(4,14),(5,15),(6,16),(7,17),(8,18),(9,19),(10,20))

0 commit comments

Comments
 (0)