diff options
author | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-09-14 17:07:23 +0200 |
---|---|---|
committer | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-09-14 17:07:23 +0200 |
commit | 12053fa4d55497fc4df06afd67ba3762019969c3 (patch) | |
tree | 0cbab1dee0784793d2ab09124a0103412e813072 /tests/run/t6196.scala | |
parent | 91f992c8af3e61a76bd862ad43b9abef9a6c3403 (diff) | |
download | dotty-12053fa4d55497fc4df06afd67ba3762019969c3.tar.gz dotty-12053fa4d55497fc4df06afd67ba3762019969c3.tar.bz2 dotty-12053fa4d55497fc4df06afd67ba3762019969c3.zip |
Enable more tests that pass
Diffstat (limited to 'tests/run/t6196.scala')
-rw-r--r-- | tests/run/t6196.scala | 68 |
1 files changed, 68 insertions, 0 deletions
diff --git a/tests/run/t6196.scala b/tests/run/t6196.scala new file mode 100644 index 000000000..9ded3b9c0 --- /dev/null +++ b/tests/run/t6196.scala @@ -0,0 +1,68 @@ +import scala.collection.immutable.HashSet + +object Test extends dotty.runtime.LegacyApp { + + case class Collision(value: Int) extends Ordered[Collision] { + def compare(that:Collision) = value compare that.value + + override def hashCode = value / 5 + } + + def testCorrectness[T : Ordering](n: Int, mkKey: Int => T): Unit = { + val o = implicitly[Ordering[T]] + val s = HashSet.empty[T] ++ (0 until n).map(mkKey) + for (i <- 0 until n) { + val ki = mkKey(i) + val a = s.filter(o.lt(_,ki)) + val b = s.filterNot(o.lt(_,ki)) + require(a.size == i && (0 until i).forall(i => a.contains(mkKey(i)))) + require(b.size == n - i && (i until n).forall(i => b.contains(mkKey(i)))) + } + } + + // this tests the structural sharing of the new filter + // I could not come up with a simple test that tests structural sharing when only parts are reused, but + // at least this fails with the old and passes with the new implementation + def testSharing(): Unit = { + val s = HashSet.empty[Int] ++ (0 until 100) + require(s.filter(_ => true) eq s) + require(s.filterNot(_ => false) eq s) + } + + // this tests that neither hashCode nor equals are called during filter + def testNoHashing(): Unit = { + var hashCount = 0 + var equalsCount = 0 + case class HashCounter(value:Int) extends Ordered[HashCounter] { + def compare(that:HashCounter) = value compare that.value + + override def hashCode = { + hashCount += 1 + value + } + + override def equals(that:Any) = { + equalsCount += 1 + that match { + case HashCounter(value) => this.value == value + case _ => false + } + } + } + + val s = HashSet.empty[HashCounter] ++ (0 until 100).map(HashCounter) + val hashCount0 = hashCount + val equalsCount0 = equalsCount + val t = s.filter(_<HashCounter(50)) + require(hashCount == hashCount0) + require(equalsCount == equalsCount0) + } + + // this tests correctness of filter and filterNot for integer keys + testCorrectness[Int](100, identity _) + // this tests correctness of filter and filterNot for keys with lots of collisions + // this is necessary because usually collisions are rare so the collision-related code is not thoroughly tested + testCorrectness[Collision](100, Collision.apply _) + testSharing() + testNoHashing() +} |