TmuxIntegration

abstract def config: <error>

abstract def modules: Seq[Module]

abstract def name: String

abstract def root: File

abstract def testClassNames(rootProject: ProjectTrait, scalaVersion: ScalaVersion, lastCompilationTime: Option[Long], testPhase: CompilePhase): Seq[String]

abstract def testCompileTaskBuild(scalaVersion: ScalaVersion, testPhases: Seq[CompilePhase]): Build

abstract def testModuleDependencies: Seq[Module]

abstract def testTaskBuild(scalaVersion: ScalaVersion, lastCompilationTimeFilter: Option[Long]): Build

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clean: BuildResult

def clean(scalaVersion: ScalaVersion): BuildResult

def clearDependencies(scalaVersion: ScalaVersion): Unit

def clone(): AnyRef

def compilationClasspath(scalaVersion: ScalaVersion, phase: CompilePhase): String

def compilationClasspathComponents(scalaVersion: ScalaVersion, phase: CompilePhase): Seq[File]

def compile: BuildResult

def compile(scalaVersion: ScalaVersion): BuildResult

def compileTaskBuild(scalaVersion: ScalaVersion): Build

def constructorCodeAsString: String

def continuously(bld: () ⇒ Build): Unit

def defaultScalaVersion: ScalaVersion

def dependenciesAlreadyUpdated(scalaVersion: ScalaVersion): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(rhs: Any): Boolean

The standard equals and hashCode methods were slow, making Dependency operations very expensive.

def execute(bld: Build): BuildResult

def extraDownstreamTasksMatcher: PartialFunction[Task, Set[Task]]

def extraUpstreamTasksMatcher: PartialFunction[Task, Set[Task]]

def finalize(): Unit

def forceUpdate: BuildResult

def forceUpdate(scalaVersion: ScalaVersion): BuildResult

final def getClass(): Class[_]

def hashCode(): Int

def isAccessibleScalaTestSuite(rootProject: ProjectTrait, scalaVersion: ScalaVersion, testPhase: CompilePhase): (String) ⇒ Boolean

final def isInstanceOf[T0]: Boolean

def listenForCommands(port: Int): Unit

lazy val logger: <error>

def managedLibDir(scalaVersion: ScalaVersion): File

def managedLibSourceDir(scalaVersion: ScalaVersion): File

def managedResourceDir: File

def markDependenciesUpdated(scalaVersion: ScalaVersion): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reportBuildResult: Boolean

val rootAbsoluteFile: File

def runMain(className: String)(opts: String*)(args: String*): BuildResult

def runMain(className: String, scalaVersion: ScalaVersion)(opts: String*)(args: String*): BuildResult

def runMainOutputStream: TeeToFileOutputStream

def runMainTaskBuild(className: String, opts: Seq[String], args: Seq[String], scalaVersion: ScalaVersion): Build

def runtimeClasspath(scalaVersion: ScalaVersion, phases: Seq[CompilePhase]): String

def runtimeClasspathComponents(scalaVersion: ScalaVersion, phases: Seq[CompilePhase]): Seq[File]

def scalaCompilerJar(scalaVersion: ScalaVersion): File

def scalaJars(scalaVersion: ScalaVersion): List[File]

def scalaLibraryJar(scalaVersion: ScalaVersion): File

def scalaParserCombinatorJar(scalaVersion: ScalaVersion): Option[File]

def scalaReflectJar(scalaVersion: ScalaVersion): File

def scalaXmlJar(scalaVersion: ScalaVersion): Option[File]

def scalatestOutputParameters: String

def setUp(graph: Graph): Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

def systemExitOnExecModeFailures: Boolean

def tcc: Unit

def tearDown(graph: Graph, result: BuildResult): Boolean

def test: BuildResult

def test(scalaVersion: ScalaVersion): BuildResult

def testClasspathLoader(scalaVersion: ScalaVersion, testPhase: CompilePhase): URLClassLoader

def testCompile: BuildResult

def testFailedSuites: BuildResult

def testFailedSuites(scalaVersion: ScalaVersion): BuildResult

def testFailedSuitesBuild(scalaVersion: ScalaVersion): Build

def testManagedLibDir(scalaVersion: ScalaVersion): File

def testManagedLibSourceDir(scalaVersion: ScalaVersion): File

lazy val testOutputFile: File

def testQuick: BuildResult

def testQuick(scalaVersion: ScalaVersion): BuildResult

def testQuickContinuously: Unit

def testResults: MakerTestResults

def tmux(args: String*): Unit

def toString(): String

def toggleTestExceptions: Unit

def topLevelCompilationErrorsFile: File

def tqc: Unit

def transitiveBuild(rootTasks: Seq[Task]): Build

def transitiveClosure[A](start: Seq[A], expand: (A) ⇒ Seq[A]): Seq[A]

def unmanagedLibDirs: Seq[File]

def update: BuildResult

def update(scalaVersion: ScalaVersion): BuildResult

def updateIncludesSourceJars: Boolean

def updateTaskBuild(scalaVersion: ScalaVersion): Build

def upstreamDependencies: Seq[RichDependency]

def upstreamModules: Seq[Module]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writeVimClasspath: Unit

def writeVimClasspath(scalaVersion: ScalaVersion): Unit

To run tests from Vim it is convenient to have _all_ test classes on the classpath, Not just those modules on whom we have a test dependency