From b42c06406fc5a277f521df076a46dc6fc43e4949 Mon Sep 17 00:00:00 2001 From: Mark Harrah Date: Sat, 14 May 2011 20:16:21 -0400 Subject: [PATCH] drop path tests --- .../io/src/test/scala/PathSpecification.scala | 187 ------------------ 1 file changed, 187 deletions(-) delete mode 100644 util/io/src/test/scala/PathSpecification.scala diff --git a/util/io/src/test/scala/PathSpecification.scala b/util/io/src/test/scala/PathSpecification.scala deleted file mode 100644 index 888e175dd..000000000 --- a/util/io/src/test/scala/PathSpecification.scala +++ /dev/null @@ -1,187 +0,0 @@ -/* sbt -- Simple Build Tool - * Copyright 2008, 2010 Mark Harrah - */ -package sbt - -import org.scalacheck._ -import Arbitrary.arbitrary -import Prop._ -import java.io.File - -object PathSpecification extends Properties("Path") -{ - // certain operations require a real underlying file. We'd like to create them in a managed temporary directory so that junk isn't left over from the test. - // The arguments to several properties are functions that construct a Path or PathFinder given a base directory. - type ToPath = ProjectDirectory => Path - type ToFinder = ProjectDirectory => PathFinder - - implicit val pathComponent: Arbitrary[String] = - Arbitrary(for(id <- Gen.identifier) yield trim(id)) // TODO: make a more specific Arbitrary - implicit val arbComponents: Arbitrary[List[String]] = Arbitrary(componentList) - implicit val arbDup: Arbitrary[(String, Int)] = Arbitrary.arbTuple2(pathComponent, Arbitrary(Gen.choose(0, MaxDuplicates))) - implicit val arbPath: Arbitrary[ToPath] = Arbitrary(genPath) - implicit val arbDirs: Arbitrary[ToFinder] = Arbitrary(directories) - - property("Project directory relative path empty") = secure { inTemp { dir => dir.relativePath.isEmpty } } - property("construction") = forAll { (components: List[String]) => - inTemp { dir => - pathForComponents(dir, components).asFile == fileForComponents(dir.asFile, components) - } - } - property("Relative path") = forAll { (a: List[String], b: List[String]) => - inTemp { dir => - pathForComponents(pathForComponents(dir, a) ###, b).relativePath == pathString(b) } - } - property("Proper URL conversion") = forAll { (tp: ToPath) => - withPath(tp) { path => path.asURL == path.asFile.toURI.toURL } - } - property("Path equality") = forAll { (components: List[String]) => - inTemp { dir => pathForComponents(dir, components) == pathForComponents(dir, components) } - } - property("Base path equality") = forAll { (a: List[String], b: List[String]) => - inTemp { dir => - pathForComponents(pathForComponents(dir, a) ###, b) == pathForComponents(pathForComponents(dir, a) ###, b) - } - } - - property("hashCode") = forAll { (tp: ToPath) => - withPath(tp) { path => - path.hashCode == path.asFile.hashCode - } - } - - property("relativize fail") = forAll { (a: List[String], b: List[String]) => - createFileAndDo(a, b) - { dir => - { - val shouldFail = (a == b) || !(b startsWith a) // will be true most of the time - val didFail = Path.relativize(pathForComponents(dir, a), pathForComponents(dir, b)).isEmpty - shouldFail == didFail - } - } - } - property("relativize") = forAll {(a: List[String], b: List[String]) => - (!b.isEmpty) ==> - { - createFileAndDo(a, b) - { dir => - { - val base = pathForComponents(dir, a) - val path = pathForComponents(base, b) - Path.relativize(base, path) == Some(path) - } - } - } - } - property("fromString") = forAll { (a: List[String]) => - inTemp { dir => - pathForComponents(dir, a) == Path.fromString(dir, pathString(a)) - } - } - - property("distinct") = forAll { (baseDirs: ToFinder, distinctNames: List[String], dupNames: List[(String, Int)]) => try { - inTemp { dir => - val bases = repeat(baseDirs(dir).get) - val reallyDistinct: Set[String] = Set() ++ distinctNames -- dupNames.map(_._1) - val dupList = dupNames.flatMap { case (name, repeat) => if(reallyDistinct(name)) Nil else List.fill(repeat)(name) } - - def create(names: List[String]): PathFinder = - { - val paths = (bases zip names ).map { case (a, b) => a / b }.filter(!_.exists) - paths.foreach { f => IO.touch(f asFile) } - Path.lazyPathFinder(paths) - } - def names(s: Set[Path]) = s.map(_.name) - - val distinctPaths = create(reallyDistinct.toList) - val dupPaths = create(dupList) - - val all = distinctPaths +++ dupPaths - val distinct = all.distinct.get - - val allNames = names(all.get) - - names(distinct) == allNames && // verify nothing lost - distinct.size == allNames.size // verify duplicates removed - } } catch { case e => e.printStackTrace; throw e} - } - - def repeat[T](s: Iterable[T]): Stream[T] = - { - def toStr(l: List[T]): Stream[T] = l match { - case Nil => st - case x :: xs => Stream.cons(x, toStr(xs)) - } - lazy val st = if(s.isEmpty) Stream.empty else toStr(s.toList) - st - } - - - private def withPath[T](tp: ToPath)(f: Path => T): T = - inTemp { f compose tp } - private def withPaths[T](ta: ToPath, tb: ToPath)(f: (Path, Path) => T): T = - inTemp { dir => f(ta(dir), tb(dir)) } - - private def createFileAndDo(a: List[String], b: List[String])(f: Path => Boolean) = - IO.withTemporaryDirectory { dir => - IO.touch(fileForComponents(dir, a ::: b)) - f(new ProjectDirectory(dir)) - } - private def inTemp[T](f: ProjectDirectory => T): T = - IO.withTemporaryDirectory { dir => f(new ProjectDirectory(dir)) } - - private def pathString(components: List[String]): String = components.mkString(File.separator) - private def pathForComponents(base: Path, components: List[String]): Path = - components.filter(!_.isEmpty).foldLeft(base)((path, component) => path / component) - private def fileForComponents(base: File, components: List[String]): File = - components.foldLeft(base)((file, component) => new File(file, component)) - - private def paths(implicit d: Gen[ToPath], s: Gen[String]): Gen[ToPath] = - for(dir <- d; name <- s) yield { - (projectPath: ProjectDirectory) => - val f = dir(projectPath) / name - IO.touch(f asFile) - f - } - - private def directories: Gen[ToFinder] = - for(dirs <- directoryList) yield { - (projectPath: ProjectDirectory) => Path.lazyPathFinder { dirs.map(_(projectPath)) } - } - private def directoryList: Gen[List[ToPath]] = genList(MaxDirectoryCount)(directory) - private def directory: Gen[ToPath] = - for(p <- genPath) yield { - (projectPath: ProjectDirectory) => { - val f = p(projectPath) - IO.createDirectory(f asFile) - f - } - } - - private implicit lazy val genPath: Gen[ToPath] = - for(a <- arbitrary[List[String]]; - b <- arbitrary[Option[List[String]]]) - yield - (projectPath: ProjectDirectory) => - { - val base = pathForComponents(projectPath, a) - b match - { - case None => base - case Some(relative) => pathForComponents(base ###, relative) - } - } - private implicit lazy val componentList: Gen[List[String]] = genList[String](MaxComponentCount)(pathComponent.arbitrary) - - private def genList[A](maxSize: Int)(implicit genA: Gen[A]) = - for(size <- Gen.choose(0, maxSize); a <- Gen.listOfN(size, genA)) yield a - - private def trim(components: List[String]): List[String] = components.take(MaxComponentCount) - private def trim(component: String): String = component.substring(0, math.min(component.length, MaxFilenameLength)) - - final val MaxFilenameLength = 20 - final val MaxComponentCount = 6 - final val MaxDirectoryCount = 10 - final val MaxFilesCount = 100 - final val MaxDuplicates = 10 -} \ No newline at end of file