HadoopSpecificationLike

abstract def is: Fragments

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def !=/(s: String): AdaptableMatcher[Any]

def !==[T](t: ⇒ T): Matcher[T]

final def ##(): Int

def <[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

def <=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ==/(s: String): AdaptableMatcher[Any]

def ===[T](t: ⇒ T): BeTypedEqualTo[T]

def ==~[T, S](s: ⇒ S)(implicit convert: (S) ⇒ T): Matcher[T]

def =~(r: Regex): BeMatchingRegex

def =~(p: Pattern): BeMatchingPattern

def =~(t: ⇒ String): BeMatching

def >[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def >=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

lazy val HADOOP_COMMAND: Option[String]

lazy val HADOOP_CONF_DIR: Option[String]

lazy val HADOOP_HOME: Option[String]

implicit def ToDelta[S](n: S)(implicit arg0: Numeric[S]): CanHaveDelta[S]

implicit def ToFormattingTagParameter(condition: Boolean): Option[FormattingTagParameter]

implicit def aBooleanExample(expression: ⇒ Boolean): ToBooleanExample

implicit def aDataTableExample[T](expression: ⇒ DecoratedResult[T]): ToDataTableExample[T]

def aFailedTry[T]: FailedTryMatcher[T]

implicit def aMatchResultExample(expression: ⇒ MatchResult[_]): ToMatchResultExample

implicit def aResultExample(expression: ⇒ Result): ToResultExample

def aSuccessfulTry[T]: SuccessTryMatcher[T]

implicit def akaMust[T](tm: Expectable[T]): MustExpectable[T]

implicit def akaShould[T](tm: Expectable[T]): ShouldExpectable[T]

def allElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

def allOf[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def anError: Error

def anInstanceOf[T](implicit arg0: ClassTag[T]): Matcher[Any]

implicit def anyAsResultIsSpecPart(r: ⇒ Function0Result): SpecPart

implicit def anyBeHaveMatcher[T](result: MatchResult[T]): AnyBeHaveMatchers[T]

def anyOf[T](t: T*): Matcher[T]

implicit def anyToArgProperty[T](t: ⇒ T): ArgProperty[T]

implicit def anyWithEmpty[T](result: MatchResult[T])(implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): AnyWithEmptyMatchers[T]

def args(ex: ArgProperty[String], include: ArgProperty[String], exclude: ArgProperty[String], wasIssue: ArgProperty[Boolean], was: ArgProperty[String], plan: ArgProperty[Boolean], skipAll: ArgProperty[Boolean], stopOnFail: ArgProperty[Boolean], stopOnSkip: ArgProperty[Boolean], sequential: ArgProperty[Boolean], isolated: ArgProperty[Boolean], xonly: ArgProperty[Boolean], showOnly: ArgProperty[String], color: ArgProperty[Boolean]): Arguments

lazy val args: ArgumentsNamespace

lazy val arguments: Arguments

implicit def argumentsFragment(a: Arguments): FragmentsFragment

implicit def argumentsIsSpecPart(a: Arguments): SpecPart

final def asInstanceOf[T0]: T0

def asNoneAs[T](other: ⇒ Option[T]): Matcher[Option[T]]

def asNullAs[T](a: ⇒ T): Matcher[T]

implicit def asResult[M[_] <: MatchResult[_]](r: M[_]): Result

implicit def asResultIsSpecPart[R](r: ⇒ R)(implicit arg0: AsResult[R]): SpecPart

def assignableFrom[T](implicit arg0: ClassTag[T]): Matcher[Class[_]]

def atLeast[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def atLeastOnce[T](matcher: Matcher[T]): ContainWithResult[T]

def atLeastOnce[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def atLeastOnceWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def atMost[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def atMostOnce[T](matcher: Matcher[T]): ContainWithResult[T]

def atMostOnce[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def atMostOnceWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def be: NeutralMatcher[Any]

def be[T <: AnyRef](t: ⇒ T): BeTheSameAs[T]

def beAFailedTry[T]: FailedTryMatcher[T]

def beASuccessfulTry[T]: SuccessTryMatcher[T]

def beAnInstanceOf[T](implicit arg0: ClassTag[T]): Matcher[Any]

def beAnyOf[T](t: T*): Matcher[T]

def beAsNoneAs[T](other: ⇒ Option[T]): Matcher[Option[T]]

def beAsNullAs[T](a: ⇒ T): Matcher[T]

def beAssignableFrom[T](implicit arg0: ClassTag[T]): Matcher[Class[_]]

def beBetween[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def beCloseTo[S](delta: Delta[S])(implicit arg0: Numeric[S]): Matcher[S]

def beCloseTo[S](n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]

def beDefinedAt[K](values: K*): Matcher[PartialFunction[K, Any]]

def beDefinedBy[K, V](values: (K, V)*): Matcher[PartialFunction[K, V]]

def beEmpty[T](implicit arg0: (T) ⇒ Any { def isEmpty: Boolean }): Matcher[T]

def beEqualTo[T](t: ⇒ T): BeEqualTo

def beFailedTry[T]: FailedTryMatcher[T]

def beFalse: Matcher[Boolean]

def beGreaterThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def beGreaterThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def beLeft[T]: LeftMatcher[T]

def beLeft[T](t: ⇒ T): Matcher[Either[T, _]]

def beLessThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

def beLessThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

def beLike[T](pattern: PartialFunction[T, MatchResult[_]]): Matcher[T]

def beLikeA[T](pattern: ⇒ PartialFunction[T, MatchResult[_]]): Matcher[T]

def beMatching(a: Regex): BeMatchingRegex

def beMatching(a: Pattern): BeMatchingPattern

def beMatching(a: ⇒ String): BeMatching

def beNone: Matcher[Option[Any]]

def beNull[T]: BeNull[T]

def beOneOf[T](t: T*): Matcher[T]

def beRight[T]: RightMatcher[T]

def beRight[T](t: ⇒ T): Matcher[Either[_, T]]

def beSome[T]: SomeMatcher[T]

def beSome[T](t: ⇒ T): Matcher[Option[T]]

def beSorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

def beSuccessfulTry[T]: SuccessTryMatcher[T]

def beTheSameAs[T <: AnyRef](t: ⇒ T): BeTheSameAs[T]

def beTrue: BeTrueMatcher

def beTypedEqualTo[T](t: ⇒ T, equality: (T, T) ⇒ Boolean): BeTypedEqualTo[T]

def be[[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def be][T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

def be_!=[T](t: ⇒ T): Matcher[Any]

def be_!=/(a: String): AdaptableMatcher[Any]

def be_!==[T](t: ⇒ T): Matcher[T]

def be_<[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThan[S]

def be_<=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): BeLessThanOrEqualTo[S]

def be_==[T](t: ⇒ T): BeEqualTo

def be_==/(a: String): AdaptableMatcher[Any]

def be_===[T](t: ⇒ T): BeTypedEqualTo[T]

def be_==~[T, S](s: ⇒ S)(implicit convert: (S) ⇒ T): Matcher[T]

def be_>[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def be_>=[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def between[T](t1: T, t2: T)(implicit arg0: (T) ⇒ Ordered[T]): BetweenMatcher[T]

implicit def booleanExample(expression: ⇒ Boolean): Example

implicit def booleanFragments(expression: ⇒ Boolean): Fragments

implicit def booleanFragmentsFragment(expression: ⇒ Boolean): BooleanResultFragment

def br: Br

def bt(n: Int): Backtab

def bt: Backtab

implicit def canBeEqual[T](t: ⇒ T): CanBeEqualExpectation[T]

def categories: String

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

def checkFailure[T](m: MatchResult[T]): MatchResult[T]

def checkMatchResultFailure[T](m: MatchResult[T]): MatchResult[T]

def checkResultFailure(r: Result): Result

implicit def checkableSeqIsContainCheckSeq[T](seq: Seq[T])(implicit to: (T) ⇒ ContainCheck[T]): Seq[ContainCheck[T]]

def classDirs: Seq[String]

def cleanup(c: ScoobiConfiguration): Unit

cleanup temporary files after job execution

def clone(): AnyRef

def closeTo[S](delta: Delta[S])(implicit arg0: Numeric[S]): Matcher[S]

def closeTo[S](n: S, delta: S)(implicit arg0: Numeric[S]): Matcher[S]

def cluster: HadoopContext

context for cluster execution

def colors(c: Colors): Arguments

implicit def combineBoolean(b: ⇒ Boolean): ResultLogicalCombinator

implicit def combineMatchResult[T](m: ⇒ MatchResult[T]): MatchResultCombinator[T]

implicit def combineResult(r: ⇒ Result): ResultLogicalCombinator

lazy val configuration: ScoobiConfiguration

def configurationFromConfigurationDirectory(conf: Configuration): Configuration

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

def contain(t: Char): Matcher[String]

def contain(t: String): Matcher[String]

def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

def contain[T](check: ContainCheck[T]): ContainWithResult[T]

def containAllOf[T](seq: Seq[T]): ContainWithResultSeq[T]

def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

def containMatch[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containPattern[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

def containTheSameElementsAs[T](seq: Seq[T]): Matcher[Traversable[T]]

def containing(s: String): Matcher[String]

def context: Fixture[ScoobiConfiguration]

define the context to use: local, cluster, localThenCluster

implicit def contextAsResult[T, M[_] <: MatchResult[_]](implicit context: Context): AsResult[M[T]]

def contexts: Seq[HadoopContext]

all contexts to run

def createExpectable[T](t: ⇒ T, alias: Option[(String) ⇒ String]): Expectable[T]

def createExpectable[T](t: ⇒ T, alias: (String) ⇒ String): Expectable[T]

def createExpectable[T](t: ⇒ T, alias: ⇒ String): Expectable[T]

def createExpectable[T](t: ⇒ T): Expectable[T]

def createExpectableWithShowAs[T](t: ⇒ T, showAs: ⇒ String): Expectable[T]

def createMustExpectable[T](t: ⇒ T): MustExpectable[T]

def createShouldExpectable[T](t: ⇒ T): ShouldExpectable[T]

implicit def dataTableExample[T](result: ⇒ DecoratedResult[T]): Example

implicit def dataTableFragments[T](result: ⇒ DecoratedResult[T]): Fragments

implicit def debug[T](t: ⇒ T): Debuggable[T]

val defaultContext: Context

def definedAt[K](values: K*): Matcher[PartialFunction[K, Any]]

def definedBy[K, V](values: (K, V)*): Matcher[PartialFunction[K, V]]

def delayedInit(x: ⇒ Unit): Unit

def deleteJars(implicit configuration: ScoobiConfiguration): Unit

def deleteLibJars: Boolean

def descFromExpectations: Arguments

implicit def describe[T](t: ⇒ T): Descriptible[T]

implicit def describeExpectation(description: String): ExpectationDescription

def diffs(show: Boolean, separators: String, triggerSize: Int, diffRatio: Int, shortenSize: Int, full: Boolean): Arguments

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

implicit def doAfter[T](t: ⇒ T)(implicit arg0: AsResult[T]): AfterResult[T]

implicit def doAround[T](t: ⇒ T)(implicit arg0: AsResult[T]): AroundResult[T]

implicit def doBefore[T](t: ⇒ T)(implicit arg0: AsResult[T]): BeforeResult[T]

def done: Success

implicit def downcastBeEqualTypedContainCheck[T, S >: T](check: BeEqualTypedContainCheck[T]): ContainCheck[S]

def eg[T](expression: ⇒ DecoratedResult[T])(implicit p: ImplicitParam): Example

def eg(expression: ⇒ Result): Fragment

def eg(expression: ⇒ Boolean): Fragments

def eg(expression: ⇒ MatchResult[_]): Example

def empty[T <: Any { def isEmpty: Boolean }]: Matcher[T]

def end: End

def endWith(t: ⇒ String): Matcher[String]

def endbr: Fragments

def endingWith(s: ⇒ String): Matcher[String]

def endp: Fragments

final def eq(arg0: AnyRef): Boolean

def equalTo[T](t: ⇒ T): BeEqualTo

def equals(arg0: Any): Boolean

def eventually[T](nested: ⇒ Matcher[T]): Matcher[T]

def eventually[T](retries: Int, sleep: Duration)(nested: ⇒ Matcher[T]): Matcher[T]

def eventually[T](result: ⇒ T)(implicit arg0: AsResult[T]): T

def eventually[T](retries: Int, sleep: Duration)(result: ⇒ T)(implicit arg0: AsResult[T]): T

def exactly[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

implicit def exampleFactory: ExampleFactory

implicit def exampleIsSpecPart(e: Example): SpecPart

def exclude(tags: String): Arguments

def excludeAlsoTrace(patterns: String*): IncludeExcludeStackTraceFilter

def excludeTrace(patterns: String*): IncludeExcludeStackTraceFilter

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 failedTry[T]: FailedTryMatcher[T]

def failure: Failure

def finalize(): Unit

def find(r: Regex): FindMatcherRegex

def find(p: Pattern): FindMatcherPattern

def find(a: ⇒ String): FindMatcher

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

implicit def fixtureFunctionToResult[T, R](implicit arg0: Fixture[T], arg1: AsResult[R]): AsResult[(T) ⇒ R]

implicit def forExample(s: String): ExampleDesc

def forall[T](matcher: Matcher[T]): ContainWithResult[T]

def forall[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def forallWhen[T, U](values: GenTraversable[T])(f: PartialFunction[T, MatchResult[U]]): MatchResult[GenTraversableOnce[T]]

def foreach[T](matcher: Matcher[T]): ContainWithResult[T]

def foreach[T, R](values: GenTraversableOnce[T])(f: (T) ⇒ R)(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

def foreachWhen[T, R](values: GenTraversable[T])(f: PartialFunction[T, R])(implicit arg0: AsResult[R]): MatchResult[GenTraversableOnce[T]]

implicit def formIsSpecPart(f: ⇒ Form): SpecPart

def formatFragments: (Fragments) ⇒ Fragments

def formatSection(markdown: Option[FormattingTagParameter], flow: Option[FormattingTagParameter], verbatim: Option[FormattingTagParameter]): TaggingFragment

def formatTag(markdown: Option[FormattingTagParameter], flow: Option[FormattingTagParameter], verbatim: Option[FormattingTagParameter]): TaggingFragment

implicit def fragmentFragments(f: ⇒ Fragment): FragmentsFragment

implicit def fragmentIsSpecPart(f: Fragment): SpecPart

implicit def fragments(f: ⇒ Fragment): Fragments

implicit def fragmentsFragmentIsSpecPart(ffs: FragmentsFragment): SpecPart

implicit def fragmentsFragmentToFragments(fs: FragmentsFragment): Fragments

implicit def fragmentsFragments(fs: ⇒ Fragments): FragmentsFragment

implicit def fragmentsIsSpecPart(fragments: Fragments): SpecPart

implicit def fromMatchResult(r: ⇒ MatchResult[_]): Boolean

def fs: String

lazy val fss: FileSystems

def fullStackTrace: Arguments

implicit def functionAndKoMessageToMatcher[T](f: ((T) ⇒ Boolean, (T) ⇒ String)): Matcher[T]

implicit def functionAndMessagesToMatcher[T](f: ((T) ⇒ Boolean, (T) ⇒ String, (T) ⇒ String)): Matcher[T]

implicit def functionIsContainCheck[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): ContainCheck[T]

implicit def functionToMatcher[T](f: ((T) ⇒ Boolean, String)): Matcher[T]

implicit def functionToMatcher2[T](f: ((T) ⇒ Boolean, String, String)): Matcher[T]

def get(name: String): Option[String]

final def getClass(): Class[_]

def getEnv(name: String): Option[String]

def greaterThan[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def greaterThanOrEqualTo[S](n: S)(implicit arg0: (S) ⇒ Ordered[S]): Matcher[S]

def hadoopArgs: Array[String]

lazy val hadoopConfDirs: Seq[String]

lazy val hadoopHomeDir: Option[String]

def hashCode(): Int

def have[T](function: (T) ⇒ Boolean): Matcher[GenTraversableOnce[T]]

def have: NeutralMatcher[Any]

def haveAllElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

def haveClass[T](implicit arg0: ClassTag[T]): Matcher[Any]

def haveInterface[T](implicit arg0: ClassTag[T]): Matcher[Any]

def haveKey[K](k: K): Matcher[Iterable[(K, Any)]]

def haveKeys[K](keys: K*): Matcher[Iterable[(K, Any)]]

def haveLength[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

def haveOneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

def havePair[K, V](p: (K, V)): Matcher[Iterable[(K, V)]]

def havePairs[K, V](pairs: (K, V)*): Matcher[Iterable[(K, V)]]

def haveSize[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

def haveSuperclass[T](implicit arg0: ClassTag[T]): Matcher[Any]

def haveTheSameElementsAs[T](l: ⇒ Traversable[T], equality: (T, T) ⇒ Boolean): HaveTheSameElementsAs[T]

def haveValue[V](v: V): Matcher[Iterable[(Any, V)]]

def haveValues[V](values: V*): Matcher[Iterable[(Any, V)]]

def identification: SpecIdentification

implicit def identifySpecificationStructure(s: SpecificationStructure): SpecIdentification

implicit lazy val implicitParam: ImplicitParam

implicit lazy val implicitParam1: ImplicitParam1

implicit lazy val implicitParam10: ImplicitParam10

implicit lazy val implicitParam2: ImplicitParam2

implicit lazy val implicitParam3: ImplicitParam3

implicit lazy val implicitParam4: ImplicitParam4

implicit lazy val implicitParam5: ImplicitParam5

implicit lazy val implicitParam6: ImplicitParam6

implicit lazy val implicitParam7: ImplicitParam7

implicit lazy val implicitParam8: ImplicitParam8

implicit lazy val implicitParam9: ImplicitParam9

implicit lazy val implicitsAreAllowed: implicitConversions

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

implicit def inScope(s: Scope): Success