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
|
package scala.collection.immutable
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import org.junit.Test
import scala.math._
import scala.util._
/* Tests various ranges by making sure they all agree on the same answers. */
@RunWith(classOf[JUnit4])
class RangeConsistencyTest {
def r2nr[T: Integral](
r: Range, puff: T, stride: T, check: (T,T) => Boolean, bi: T => BigInt
): List[(BigInt,Try[Int])] = {
val num = implicitly[Integral[T]]
import num._
val one = num.one
if (!check(puff, fromInt(r.start))) return Nil
val start = puff * fromInt(r.start)
val sp1 = start + one
val sn1 = start - one
if (!check(puff, fromInt(r.end))) return Nil
val end = puff * fromInt(r.end)
val ep1 = end + one
val en1 = end - one
if (!check(stride, fromInt(r.step))) return Nil
val step = stride * fromInt(r.step)
def NR(s: T, e: T, i: T) = {
val delta = (bi(e) - bi(s)).abs - (if (r.isInclusive) 0 else 1)
val n = if (r.length == 0) BigInt(0) else delta / bi(i).abs + 1
if (r.isInclusive) {
(n, Try(NumericRange.inclusive(s,e,i).length))
}
else {
(n, Try(NumericRange(s,e,i).length))
}
}
List(NR(start, end, step)) :::
(if (sn1 < start) List(NR(sn1, end, step)) else Nil) :::
(if (start < sp1) List(NR(sp1, end, step)) else Nil) :::
(if (en1 < end) List(NR(start, en1, step)) else Nil) :::
(if (end < ep1) List(NR(start, ep1, step)) else Nil)
}
// Motivated by SI-4370: Wrong result for Long.MinValue to Long.MaxValue by Int.MaxValue
@Test
def rangeChurnTest() {
val rn = new Random(4370)
for (i <- 0 to 10000) { control.Breaks.breakable {
val start = rn.nextInt
val end = rn.nextInt
val step = rn.nextInt(4) match {
case 0 => 1
case 1 => -1
case 2 => (rn.nextInt(11)+2)*(2*rn.nextInt(2)+1)
case 3 => var x = rn.nextInt; while (x==0) x = rn.nextInt; x
}
val r = if (rn.nextBoolean) Range.inclusive(start, end, step) else Range(start, end, step)
try { r.length }
catch { case iae: IllegalArgumentException => control.Breaks.break }
val lpuff = rn.nextInt(4) match {
case 0 => 1L
case 1 => rn.nextInt(11)+2L
case 2 => 1L << rn.nextInt(60)
case 3 => math.max(1L, math.abs(rn.nextLong))
}
val lstride = rn.nextInt(4) match {
case 0 => lpuff
case 1 => 1L
case 2 => 1L << rn.nextInt(60)
case 3 => math.max(1L, math.abs(rn.nextLong))
}
val lr = r2nr[Long](
r, lpuff, lstride,
(a,b) => { val x = BigInt(a)*BigInt(b); x.isValidLong },
x => BigInt(x)
)
lr.foreach{ case (n,t) => assert(
t match {
case Failure(_) => n > Int.MaxValue
case Success(m) => n == m
},
(r.start, r.end, r.step, r.isInclusive, lpuff, lstride, n, t)
)}
val bipuff = rn.nextInt(3) match {
case 0 => BigInt(1)
case 1 => BigInt(rn.nextLong) + Long.MaxValue + 2
case 2 => BigInt("1" + "0"*(rn.nextInt(100)+1))
}
val bistride = rn.nextInt(3) match {
case 0 => bipuff
case 1 => BigInt(1)
case 2 => BigInt("1" + "0"*(rn.nextInt(100)+1))
}
val bir = r2nr[BigInt](r, bipuff, bistride, (a,b) => true, identity)
bir.foreach{ case (n,t) => assert(
t match {
case Failure(_) => n > Int.MaxValue
case Success(m) => n == m
},
(r.start, r.end, r.step, r.isInclusive, bipuff, bistride, n, t)
)}
}}
}
@Test
def testSI4370() { assert{
Try((Long.MinValue to Long.MaxValue by Int.MaxValue).length) match {
case Failure(iae: IllegalArgumentException) => true
case _ => false
}
}}
@Test
def testSI6736() { assert{
(0 to Int.MaxValue).contains(4) && !((Int.MinValue to 0).contains(4))
} }
}
|