UploadedLibJars

abstract def frameworkName: String

abstract def fs: String

abstract def is: Fragments

abstract def jobTracker: String

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val arguments: Arguments

final def asInstanceOf[T0]: T0

def categories: String

def chain(contexts: Seq[HadoopContext]): HadoopContext { val configuration: com.nicta.scoobi.core.ScoobiConfiguration }

def classDirs: Seq[String]

def cleanup(c: ScoobiConfiguration): Unit

cleanup temporary files after job execution

def clone(): AnyRef

def cluster: HadoopContext

context for cluster execution

def configureArguments(implicit configuration: ScoobiConfiguration): Unit

set command-line arguments on the configuration object

def configureForCluster(implicit configuration: ScoobiConfiguration): ScoobiConfiguration

def configureForInMemory(implicit configuration: ScoobiConfiguration): ScoobiConfiguration

def configureForLocal(implicit configuration: ScoobiConfiguration): ScoobiConfiguration

def configureJars(implicit configuration: ScoobiConfiguration): Unit

def context: Fixture[ScoobiConfiguration]

define the context to use: local, cluster, localThenCluster

def contexts: Seq[HadoopContext]

all contexts to run

def delayedInit(x: ⇒ Unit): Unit

def deleteJars(implicit configuration: ScoobiConfiguration): Unit

def deleteLibJars: Boolean

def displayTime(prefix: String): (SimpleTimer) ⇒ Unit

the execution time will not be displayed with this function, but by adding more information to the execution Result

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executeInMemory[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code locally

def executeOnCluster[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code on the cluster, setting the filesystem / jobtracker addresses and setting up the classpath

def executeOnLocal[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code locally

def finalize(): Unit

implicit def fixtureContext: Fixture[ScoobiConfiguration]

make the context available implicitly as an Fixture[ScoobiConfiguration] so that examples taking that context as a parameter can be declared

def formatFragments: (Fragments) ⇒ Fragments

lazy val fss: FileSystems

final def getClass(): Class[_]

def hadoopArgs: Array[String]

def hashCode(): Int

def identification: SpecIdentification

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

def inMemory[R](r: ⇒ R)(implicit arg0: AsResult[R]): Result

execute an example body locally

def inMemory: HadoopContext

context for in memory execution

def inMemory[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code in memory, using a collection backend, possibly showing execution times

def includeLibJars: Boolean

def isCluster: Boolean

def isClusterOnly: Boolean

def isInMemory: Boolean

tests are always in memory by default, unless !inmemory is passed

final def isInstanceOf[T0]: Boolean

def isLocal: Boolean

tests are always local by default, unless !local is passed

def isLocalOnly: Boolean

alias for locally

def jars(implicit configuration: ScoobiConfiguration): Seq[URL]

def keepFiles: Boolean

def level: Level

def libjarsDirectory(implicit configuration: ScoobiConfiguration): String

def local: HadoopContext

context for local execution

def locally[R](r: ⇒ R)(implicit arg0: AsResult[R]): Result

execute an example body locally

def locally: Boolean

def map(fs: ⇒ Fragments): Fragments

add a first step to upload the library jars before doing anything else

final def ne(arg0: AnyRef): Boolean

def noLibJars: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onCluster[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code on the cluster, possibly showing the execution time

def onHadoop[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code, either locally or on the cluster, depending on the local argument being passed on the commandline

def onLocal[T](t: ⇒ T)(implicit configuration: ScoobiConfiguration): T

execute some code locally, possibly showing execution times

def quiet: Boolean

def remotely[R](r: ⇒ R)(implicit arg0: AsResult[R]): Result

execute an example body on the cluster

def runInMemory[T](t: ⇒ T): T

def runOnCluster[T](t: ⇒ T): T

def runOnLocal[T](t: ⇒ T): T

lazy val scoobiArgs: Seq[String]

the scoobi arguments passed on the command line

def set(args: Arguments): Unit

def setLogFactory(name: String = classOf[HadoopLogFactory].getName): Unit

Static setup to use a testing log factory

def showPlanOnly: Boolean

def showTime[T](t: ⇒ T)(display: (SimpleTimer) ⇒ Unit): T

measure the time taken by some executed code and display the time with a specific display function

def showTimes: Boolean

def skippedContext(name: String): HadoopContext

context for showing a skipped execution

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

lazy val sysProps: SystemProperties

def toString(): String

def upload: Boolean

this variable controls if the upload must be done at all

def uploadLibJarsFiles(deleteLibJarsFirst: Boolean = false)(implicit configuration: ScoobiConfiguration): Unit

upload the jars which don't exist yet in the library directory on the cluster

def uploadStep: Step

create a Step to upload the jars on the cluster

def uploadedJars(implicit configuration: ScoobiConfiguration): Seq[Path]

def useHadoopConfDir: Boolean

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withTimer[T](t: ⇒ T): (T, SimpleTimer)