1 files changed, 0 insertions, 143 deletions
diff --git a/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala b/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala
deleted file mode 100644
index f2926e3e17..0000000000
--- a/test/junit/scala/tools/nsc/util/ClassPathImplComparator.scala
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright (c) 2014 Contributor. All rights reserved.
- */
-package scala.tools.nsc.util
-
-import scala.reflect.io.AbstractFile
-import scala.tools.nsc.Settings
-import scala.tools.nsc.settings.ClassPathRepresentationType
-import scala.tools.util.PathResolverFactory
-
-/**
- * Simple application to compare efficiency of the recursive and the flat classpath representations
- */
-object ClassPathImplComparator {
-
-  private class TestSettings extends Settings {
-    val checkClasses = PathSetting("-checkClasses", "Specify names of classes which should be found separated with ;", "")
-    val requiredIterations = IntSetting("-requiredIterations",
-      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
-    val cpCreationRepetitions = IntSetting("-cpCreationRepetitions",
-      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
-    val cpLookupRepetitions = IntSetting("-cpLookupRepetitions",
-      "Repeat tests specified number of times (to check e.g. impact of caches)", 1, Some((1, Int.MaxValue)), (_: String) => None)
-  }
-
-  private class DurationStats(name: String) {
-    private var sum = 0L
-    private var iterations = 0
-
-    def noteMeasuredTime(millis: Long): Unit = {
-      sum += millis
-      iterations += 1
-    }
-
-    def printResults(): Unit = {
-      val avg = if (iterations == 0) 0 else sum.toDouble / iterations
-      println(s"$name - total duration: $sum ms; iterations: $iterations; avg: $avg ms")
-    }
-  }
-
-  private lazy val defaultClassesToFind = List(
-    "scala.collection.immutable.List",
-    "scala.Option",
-    "scala.Int",
-    "scala.collection.immutable.Vector",
-    "scala.util.hashing.MurmurHash3"
-  )
-
-  private val oldCpCreationStats = new DurationStats("Old classpath - create")
-  private val oldCpSearchingStats = new DurationStats("Old classpath - search")
-
-  private val flatCpCreationStats = new DurationStats("Flat classpath - create")
-  private val flatCpSearchingStats = new DurationStats("Flat classpath - search")
-
-  def main(args: Array[String]): Unit = {
-
-    if (args contains "-help")
-      usage()
-    else {
-      val oldCpSettings = loadSettings(args.toList, ClassPathRepresentationType.Recursive)
-      val flatCpSettings = loadSettings(args.toList, ClassPathRepresentationType.Flat)
-
-      val classesToCheck = oldCpSettings.checkClasses.value
-      val classesToFind =
-        if (classesToCheck.isEmpty) defaultClassesToFind
-        else classesToCheck.split(";").toList
-
-      def doTest(classPath: => ClassFileLookup[AbstractFile], cpCreationStats: DurationStats, cpSearchingStats: DurationStats,
-                 cpCreationRepetitions: Int, cpLookupRepetitions: Int)= {
-
-        def createClassPaths() = (1 to cpCreationRepetitions).map(_ => classPath).last
-        def testClassLookup(cp: ClassFileLookup[AbstractFile]): Boolean = (1 to cpCreationRepetitions).foldLeft(true) {
-          case (a, _) => a && checkExistenceOfClasses(classesToFind)(cp)
-        }
-
-        val cp = withMeasuredTime("Creating classpath", createClassPaths(), cpCreationStats)
-        val result = withMeasuredTime("Searching for specified classes", testClassLookup(cp), cpSearchingStats)
-        println(s"The end of the test case. All expected classes found = $result \n")
-      }
-
-      (1 to oldCpSettings.requiredIterations.value) foreach { iteration =>
-        if (oldCpSettings.requiredIterations.value > 1)
-          println(s"Iteration no $iteration")
-
-        println("Recursive (old) classpath representation:")
-        doTest(PathResolverFactory.create(oldCpSettings).result, oldCpCreationStats, oldCpSearchingStats,
-          oldCpSettings.cpCreationRepetitions.value, oldCpSettings.cpLookupRepetitions.value)
-
-        println("Flat classpath representation:")
-        doTest(PathResolverFactory.create(flatCpSettings).result, flatCpCreationStats, flatCpSearchingStats,
-          flatCpSettings.cpCreationRepetitions.value, flatCpSettings.cpLookupRepetitions.value)
-      }
-
-      if (oldCpSettings.requiredIterations.value > 1) {
-        println("\nOld classpath - summary")
-        oldCpCreationStats.printResults()
-        oldCpSearchingStats.printResults()
-
-        println("\nFlat classpath - summary")
-        flatCpCreationStats.printResults()
-        flatCpSearchingStats.printResults()
-      }
-    }
-  }
-
-  /**
-   * Prints usage information
-   */
-  private def usage(): Unit =
-    println("""Use classpath and sourcepath options like in the case of e.g. 'scala' command.
-              | There are also two additional options:
-              | -checkClasses <semicolon separated class names> Specify names of classes which should be found
-              | -requiredIterations <int value>                 Repeat tests specified count of times (to check e.g. impact of caches)
-              | Note: Option -YclasspathImpl will be set automatically for each case.
-            """.stripMargin.trim)
-
-  private def loadSettings(args: List[String], implType: String) = {
-    val settings = new TestSettings()
-    settings.processArguments(args, processAll = true)
-    settings.YclasspathImpl.value = implType
-    if (settings.classpath.isDefault)
-      settings.classpath.value = sys.props("java.class.path")
-    settings
-  }
-
-  private def withMeasuredTime[T](operationName: String, f: => T, durationStats: DurationStats): T = {
-    val startTime = System.currentTimeMillis()
-    val res = f
-    val elapsed = System.currentTimeMillis() - startTime
-    durationStats.noteMeasuredTime(elapsed)
-    println(s"$operationName - elapsed $elapsed ms")
-    res
-  }
-
-  private def checkExistenceOfClasses(classesToCheck: Seq[String])(classPath: ClassFileLookup[AbstractFile]): Boolean =
-    classesToCheck.foldLeft(true) {
-      case (res, classToCheck) =>
-        val found = classPath.findClass(classToCheck).isDefined
-        if (!found)
-          println(s"Class $classToCheck not found") // of course in this case the measured time will be affected by IO operation
-        found
-    }
-}