CoreModule

implicit abstract def configuration: GatlingConfiguration

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def BlackList(patterns: String*): BlackList

def ByteArrayBody: body.ByteArrayBody.type

def ElFileBody: body.ElFileBody.type

def InputStreamBody: body.InputStreamBody.type

def RawFileBody: body.RawFileBody.type

def StringBody(string: Expression[String]): StringBody

def StringBody(string: String): CompositeByteArrayBody

def WhiteList(patterns: String*): WhiteList

implicit def array2FeederBuilder[T](data: Array[Map[String, T]]): RecordSeqFeederBuilder[T]

final def asInstanceOf[T0]: T0

def asLongAs(condition: Expression[Boolean], counterName: String = UUID.randomUUID.toString, exitASAP: Boolean = false, loopType: LoopType = AsLongAsLoopType)(chain: ChainBuilder): ChainBuilder

def atOnceUsers(users: Int): AtOnceInjection

implicit def checkBuilder2Check[C <: Check[R], R, P, X](checkBuilder: CheckBuilder[C, R, P, X]): C

def clone(): AnyRef

val constantPauses: Constant.type

def constantUsersPerSec(rate: Double): ConstantRateBuilder

def csv(fileName: String, rawSplit: Boolean = false)(implicit configuration: GatlingConfiguration): RecordSeqFeederBuilder[String]

def customPauses(custom: Expression[Long]): Custom

implicit lazy val defaultCssExtractorFactory: CssExtractorFactory

implicit lazy val defaultCssSelectors: CssSelectors

implicit lazy val defaultJdkXPathExtractorFactory: JdkXPathExtractorFactory

implicit lazy val defaultJdkXmlParsers: JdkXmlParsers

implicit lazy val defaultJsonParsers: JsonParsers

implicit lazy val defaultJsonPathExtractorFactory: JsonPathExtractorFactory

implicit lazy val defaultJsonPaths: JsonPaths

implicit lazy val defaultPatterns: Patterns

implicit lazy val defaultRegexExtractorFactory: RegexExtractorFactory

implicit lazy val defaultSaxon: Saxon

implicit lazy val defaultSaxonXPathExtractorFactory: SaxonXPathExtractorFactory

def details(path: AssertionPath): AssertionWithPath

val disabledPauses: Disabled.type

def doIf(sessionKey: Expression[String], value: String)(thenNext: ChainBuilder): ChainBuilder

Method used to add a conditional execution in the scenario

def doIf(condition: Expression[Boolean])(thenNext: ChainBuilder): ChainBuilder

Method used to add a conditional execution in the scenario

def doIfEqualsOrElse(expected: Expression[Any], actual: Expression[Any])(thenNext: ChainBuilder)(elseNext: ChainBuilder): ChainBuilder

Method used to add a conditional execution in the scenario with a fall back action if condition is not satisfied

def doIfOrElse(condition: Expression[Boolean])(thenNext: ChainBuilder)(elseNext: ChainBuilder): ChainBuilder

Method used to add a conditional execution in the scenario with a fall back action if condition is not satisfied

def doSwitch(value: Expression[Any])(possibilities: (Any, ChainBuilder)*): ChainBuilder

Add a switch in the chain.

def doSwitchOrElse(value: Expression[Any])(possibilities: (Any, ChainBuilder)*)(elseNext: ChainBuilder): ChainBuilder

Add a switch in the chain.

def during(duration: Expression[Duration], counterName: String, exitASAP: Boolean)(chain: ChainBuilder): ChainBuilder

def during(duration: Duration, counterName: String = UUID.randomUUID.toString, exitASAP: Boolean = true)(chain: ChainBuilder): ChainBuilder

implicit lazy val elFileBodies: ElFileBodies

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exec(scenario: ScenarioBuilder): ChainBuilder

def exec(chains: Iterable[ChainBuilder]): ChainBuilder

def exec(chains: Iterator[ChainBuilder]): ChainBuilder

def exec(chains: ChainBuilder*): ChainBuilder

def exec(actionBuilder: ActionBuilder): ChainBuilder

def exec(sessionFunction: Expression[Session]): ChainBuilder

def exitBlockOnFail(chain: ChainBuilder): ChainBuilder

def exitHereIfFailed: ChainBuilder

val exponentialPauses: Exponential.type

def feed(feederBuilder: feeder.FeederBuilder[_], number: Expression[Int] = Feeds.oneExpression): ChainBuilder

Method used to load data from a feeder in the current scenario

implicit def feeder2FeederBuilder[T](feeder: Feeder[T]): FeederBuilder[T]

def feederBuilder[T](resource: Validation[Resource])(recordParser: (Resource) ⇒ IndexedSeq[Record[T]]): RecordSeqFeederBuilder[T]

def finalize(): Unit

implicit def findCheckBuilder2Check[C <: Check[R], R, P, X](findCheckBuilder: FindCheckBuilder[C, R, P, X]): C

implicit def findCheckBuilder2CheckBuilder[C <: Check[R], R, P, X](findCheckBuilder: FindCheckBuilder[C, R, P, X]): CheckBuilder[C, R, P, X] with SaveAs[C, R, P, X]

implicit def findCheckBuilder2ValidatorCheckBuilder[C <: Check[R], R, P, X](findCheckBuilder: FindCheckBuilder[C, R, P, X]): ValidatorCheckBuilder[C, R, P, X]

def flattenMapIntoAttributes(map: Expression[Map[String, Any]]): Expression[Session]

def forAll: AssertionWithPath

def foreach(seq: Expression[Seq[Any]], attributeName: String, counterName: String = UUID.randomUUID.toString)(chain: ChainBuilder): ChainBuilder

def forever(counterName: String = UUID.randomUUID.toString, exitASAP: Boolean = false)(chain: ChainBuilder): ChainBuilder

def forever(chain: ChainBuilder): ChainBuilder

final def getClass(): Class[_]

def global: AssertionWithPath

def group(name: Expression[String])(chain: ChainBuilder): ChainBuilder

val gzipBody: (Body) ⇒ ByteArrayBody

def hashCode(): Int

def heavisideUsers(users: Int): HeavisideBuilder

def holdFor(duration: FiniteDuration): Throttling

implicit def intToFiniteDuration(i: Int): FiniteDuration

implicit def integerToFiniteDuration(i: Integer): FiniteDuration

********************************

final def isInstanceOf[T0]: Boolean

implicit def jlongToFiniteDuration(i: Long): FiniteDuration

def jsonFile(resource: Validation[Resource])(implicit jsonParsers: JsonParsers): RecordSeqFeederBuilder[Any]

def jsonFile(fileName: String)(implicit configuration: GatlingConfiguration, jsonParsers: JsonParsers): RecordSeqFeederBuilder[Any]

def jsonUrl(url: String)(implicit jsonParsers: JsonParsers): RecordSeqFeederBuilder[Any]

def jumpToRps(target: Int): Throttling

final def ne(arg0: AnyRef): Boolean

def normalPausesWithPercentageDuration(stdDev: Double): NormalWithPercentageDuration

def normalPausesWithStdDevDuration(stdDev: Duration): NormalWithStdDevDuration

def nothingFor(d: FiniteDuration): NothingForInjection

final def notify(): Unit

final def notifyAll(): Unit

def pace(duration: Expression[Duration], counter: String): ChainBuilder

def pace(duration: Expression[Duration]): ChainBuilder

def pace(min: Expression[Duration], max: Expression[Duration]): ChainBuilder

def pace(min: String, max: String, unit: TimeUnit): ChainBuilder

def pace(min: Duration, max: Duration): ChainBuilder

def pace(duration: String, unit: TimeUnit = TimeUnit.SECONDS): ChainBuilder

def pace(duration: Duration): ChainBuilder

def pause(duration: Expression[Duration], force: PauseType): ChainBuilder

def pause(duration: Expression[Duration]): ChainBuilder

def pause(min: Expression[Duration], max: Expression[Duration], force: PauseType): ChainBuilder

def pause(min: Expression[Duration], max: Expression[Duration]): ChainBuilder

def pause(min: String, max: String, unit: TimeUnit, force: PauseType): ChainBuilder

def pause(min: String, max: String, unit: TimeUnit): ChainBuilder

def pause(min: Duration, max: Duration, force: PauseType): ChainBuilder

def pause(min: Duration, max: Duration): ChainBuilder

def pause(duration: String, unit: TimeUnit, force: PauseType): ChainBuilder

def pause(duration: String, unit: TimeUnit): ChainBuilder

def pause(duration: String, force: PauseType): ChainBuilder

def pause(duration: String): ChainBuilder

def pause(duration: Duration, force: PauseType): ChainBuilder

def pause(duration: Duration): ChainBuilder

Method used to define a pause based on a duration defined in the session

def rampUsers(users: Int): RampBuilder

def rampUsersPerSec(rate1: Double): PartialRampRateBuilder

def randomSwitch(possibilities: (Double, ChainBuilder)*): ChainBuilder

Add a switch in the chain.

def randomSwitchOrElse(possibilities: (Double, ChainBuilder)*)(elseNext: ChainBuilder): ChainBuilder

Add a switch in the chain.

implicit lazy val rawFileBodies: RawFileBodies

def reachRps(target: Int): ReachIntermediate

def rendezVous(users: Int): ChainBuilder

def repeat(times: Expression[Int], counterName: String = UUID.randomUUID.toString)(chain: ChainBuilder): ChainBuilder

def roundRobinSwitch(possibilities: ChainBuilder*): ChainBuilder

Add a switch in the chain.

def scenario(scenarioName: String): ScenarioBuilder

def separatedValues(resource: Validation[Resource], separator: Char, quoteChar: Char, rawSplit: Boolean)(implicit configuration: GatlingConfiguration): RecordSeqFeederBuilder[String]

def separatedValues(fileName: String, separator: Char, quoteChar: Char = '"', rawSplit: Boolean = false)(implicit configuration: GatlingConfiguration): RecordSeqFeederBuilder[String]

implicit def seq2FeederBuilder[T](data: IndexedSeq[Map[String, T]]): RecordSeqFeederBuilder[T]

def splitUsers(users: Int): PartialSplitBuilder

def ssv(fileName: String, rawSplit: Boolean = false)(implicit configuration: GatlingConfiguration): RecordSeqFeederBuilder[String]

def steps: List[ThrottleStep]

val streamBody: (Body) ⇒ InputStreamBody

implicit def string2pathBuilder(string: String): AssertionPath

implicit def stringToExpression[T](string: String)(implicit arg0: ClassTag[T]): Expression[T]

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

def toString(): String

def tryMax(times: Int, counter: String = UUID.randomUUID.toString)(chain: ChainBuilder): ChainBuilder

def tsv(fileName: String, rawSplit: Boolean = false)(implicit configuration: GatlingConfiguration): RecordSeqFeederBuilder[String]

def uniformPausesPlusOrMinusDuration(plusOrMinus: Duration): UniformDuration

def uniformPausesPlusOrMinusPercentage(plusOrMinus: Double): UniformPercentage

def uniformRandomSwitch(possibilities: ChainBuilder*): ChainBuilder

Add a switch in the chain.

implicit def validatorCheckBuilder2Check[C <: Check[R], R, P, X](validatorCheckBuilder: ValidatorCheckBuilder[C, R, P, X]): C

implicit def validatorCheckBuilder2CheckBuilder[C <: Check[R], R, P, X](validatorCheckBuilder: ValidatorCheckBuilder[C, R, P, X]): CheckBuilder[C, R, P, X] with SaveAs[C, R, P, X]

implicit def value2Expression[T](value: T): Expression[T]

implicit def value2Success[T](value: T): Validation[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit