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): Seq[String]

abstract def testCompileTaskBuild(scalaVersion: ScalaVersion): Build

abstract def testModuleDependencies: Seq[Module]

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 clone(): AnyRef

def compilationClasspath(scalaVersion: ScalaVersion): String

def compilationClasspathComponents(scalaVersion: ScalaVersion): Seq[File]

def compilationOutputStream(phase: CompilePhase): <error>

def compile: BuildResult

def compile(scalaVersion: ScalaVersion): BuildResult

def compileTaskBuild(scalaVersion: ScalaVersion): Build

def constructorCodeAsString: String

def continuously(bld: Build): Unit

def defaultScalaVersion: ScalaVersion

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

final def getClass(): Class[_]

def hashCode(): Int

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

final def isInstanceOf[T0]: Boolean

lazy val logger: <error>

def managedLibDir(scalaVersion: ScalaVersion): File

def managedLibSourceDir(scalaVersion: ScalaVersion): File

def managedResourceDir: File

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): String

def runtimeClasspathComponents(scalaVersion: ScalaVersion): 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 testClasspathLoader(scalaVersion: ScalaVersion): URLClassLoader

def testCompilationClasspath(scalaVersion: ScalaVersion): String

def testCompilationClasspathComponents(scalaVersion: ScalaVersion): Seq[File]

def testCompile: BuildResult

def testCompile(scalaVersion: ScalaVersion): 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 testResults: MakerTestResults

def testRuntimeClasspath(scalaVersion: ScalaVersion): String

def testRuntimeClasspathComponents(scalaVersion: ScalaVersion): Seq[File]

def tmux(args: String*): Unit

def toString(): String

def toggleTestExceptions: Unit

def topLevelCompilationErrorsFile: File

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 updateSources: BuildResult

def updateTaskBuild(forceSourceUpdate: Boolean, 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(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