path: root/tests/run/iterator-from.scala

/* This file tests iteratorFrom, keysIteratorFrom, and valueIteratorFrom on various sorted sets and maps
 * filter: inliner warnings; re-run with -Yinline-warnings for details
 */

import scala.util.{Random => R}
import scala.collection._
import scala.math.Ordered

object Test extends dotty.runtime.LegacyApp {
  val maxLength = 25
  val maxKey = 50
  val maxValue = 50

  implicit def convertIfView[A](x: A)(implicit view: A => Ordered[A]): Ordered[A] = view(x)

  def testSet[A: Ordering](set: SortedSet[A], list: List[A]): Unit = {
    val distinctSorted = list.distinct.sorted
    assertEquals("Set size wasn't the same as list sze", set.size, distinctSorted.size)

    for(key <- distinctSorted) {
      val clazz = set.getClass
      val iteratorFrom = (set iteratorFrom key).toList
      check(clazz, list, s"set iteratorFrom $key", s"(set from $key).iterator", iteratorFrom, (set from key).iterator.toList)
      check(clazz, list, s"set.iteratorFrom $key", s"distinctSorted dropWhile (_ < $key)", iteratorFrom, distinctSorted dropWhile (_ < key))
      check(clazz, list, s"set iteratorFrom $key", s"set keysIterator from $key", iteratorFrom, (set keysIteratorFrom key).toList)
    }
  }

  def testMap[A: Ordering, B](map: SortedMap[A, B], list: List[(A, B)]): Unit = {
    val distinctSorted = distinctByKey(list).sortBy(_._1)
    assertEquals("Map size wasn't the same as list sze", map.size, distinctSorted.size)

    for(keyValue <- distinctSorted) {
      val key = keyValue._1
      val clazz = map.getClass
      val iteratorFrom = (map iteratorFrom key).toList
      check(clazz, list, s"map iteratorFrom $key", s"(map from $key).iterator", iteratorFrom, (map from key).iterator.toList)
      check(clazz, list, s"map iteratorFrom $key", s"distinctSorted dropWhile (_._1 < $key)", iteratorFrom, distinctSorted dropWhile (_._1 < key))
      check(clazz, list, s"map iteratorFrom $key map (_._1)", s"map keysIteratorFrom $key", iteratorFrom map (_._1), (map keysIteratorFrom key).toList)
      check(clazz, list, s"map iteratorFrom $key map (_._2)", s"map valuesIteratorFrom $key", iteratorFrom map (_._2), (map valuesIteratorFrom key).toList)
    }
  }

  def check[A](clazz: Class[_], list: List[_], m1: String, m2: String, l1: List[A], l2: List[A]): Unit = {
    assertEquals(s"$clazz: `$m1` didn't match `$m2` on list $list", l1, l2)
  }

  def assertEquals[A](msg: String, x: A, y: A): Unit = {
    assert(x == y, s"$msg\n1: $x\n2: $y")
  }

  def distinctByKey[A,B](list: List[(A, B)]) : List[(A,B)] = list.groupBy(_._1).map(_._2.last).toList

  object Weekday extends Enumeration {
    type Weekday = Value
    val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
  }

  0 until maxLength foreach {length =>
    val keyValues = (0 until length map {_ => (R nextInt maxKey, R nextInt maxValue)}).toList
    val keys = keyValues map (_._2)
    testSet(immutable.BitSet(keys:_*), keys)
    testSet(immutable.TreeSet(keys:_*), keys)
    testSet(mutable.TreeSet(keys:_*), keys)
    val days = keys map {n => Weekday(n % Weekday.values.size)}
    testSet(Weekday.ValueSet(days:_*), days)

    val treeMap = immutable.TreeMap(keyValues:_*)
    testMap(treeMap, keyValues)
    testMap(treeMap.filterKeys(_ % 2 == 0), keyValues  filter (_._1 % 2 == 0))
    testMap(treeMap mapValues (_ + 1), keyValues map {case (k,v) => (k, v + 1)})
  }
}