StructureBuilder

abstract class StructureBuilder[T <: StructureBuilder[T, W], W <: core.structure.StructureBuilder[W]] extends Execs[T, W] with Groups[T, W] with Feeds[T, W] with Pauses[T, W] with Paces[T, W] with RendezVous[T, W] with Repeat[T, W] with ForEach[T, W] with During[T, W] with Forever[T, W] with AsLongAs[T, W] with DoWhile[T, W] with AsLongAsDuring[T, W] with DoWhileDuring[T, W] with DoIf[T, W] with DoIfOrElse[T, W] with DoIfEquals[T, W] with DoIfEqualsOrElse[T, W] with DoSwitch[T, W] with DoSwitchOrElse[T, W] with RandomSwitch[T, W] with RandomSwitchOrElse[T, W] with UniformRandomSwitch[T, W] with RoundRobinSwitch[T, W] with Errors[T, W]

The parent class of ScenarioBuilder and ChainBuilder.

For internal use only, do not extend!

Linear Supertypes

Errors[T, W], RoundRobinSwitch[T, W], UniformRandomSwitch[T, W], RandomSwitchOrElse[T, W], RandomSwitch[T, W], DoSwitchOrElse[T, W], DoSwitch[T, W], DoIfEqualsOrElse[T, W], DoIfEquals[T, W], DoIfOrElse[T, W], DoIf[T, W], DoWhileDuring[T, W], AsLongAsDuring[T, W], DoWhile[T, W], AsLongAs[T, W], Forever[T, W], During[T, W], ForEach[T, W], Repeat[T, W], RendezVous[T, W], Paces[T, W], Pauses[T, W], Feeds[T, W], Groups[T, W], Execs[T, W], AnyRef, Any

Known Subclasses

ChainBuilder, ScenarioBuilder

Ordering

Alphabetic
By Inheritance

Inherited

StructureBuilder
Errors
RoundRobinSwitch
UniformRandomSwitch
RandomSwitchOrElse
RandomSwitch
DoSwitchOrElse
DoSwitch
DoIfEqualsOrElse
DoIfEquals
DoIfOrElse
DoIf
DoWhileDuring
AsLongAsDuring
DoWhile
AsLongAs
Forever
During
ForEach
Repeat
RendezVous
Paces
Pauses
Feeds
Groups
Execs
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new StructureBuilder(wrapped: W)
Attributes
protected[core]

Abstract Value Members

abstract def make(f: Function[W, W]): T
Definition Classes
Errors

Concrete Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0
Definition Classes
Any
def asLongAs(condition: Function[Session, Boolean], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: Function[Session, Boolean], exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a function
exitASAP
if the loop must be interrupted if the condition becomes false inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
def asLongAs(condition: Function[Session, Boolean], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: Function[Session, Boolean]): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a function
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: String, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a Gatling Expression Language String
exitASAP
if the loop must be interrupted if the condition becomes false inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: String, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAs(condition: String): On[T]
Define a loop that will iterate as long as the condition holds true
Define a loop that will iterate as long as the condition holds true
condition
the condition, expressed as a Gatling Expression Language String
returns
a DSL component for defining the loop content
Definition Classes
AsLongAs
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Duration, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Long, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Duration, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Long, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Duration, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Long, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Duration): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Long): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration in seconds
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration]): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Function[Session, Duration], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Duration, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Long, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: String, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Function[Session, Duration], exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Duration, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Long, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Function[Session, Duration], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Duration, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Long, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: String, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Function[Session, Duration]): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Duration): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: Long): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def asLongAsDuring(condition: String, duration: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
returns
a DSL component for defining the loop content
Definition Classes
AsLongAsDuring
Annotations
@Nonnull()
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
def doIf(condition: Function[Session, Boolean]): Then[T]
Execute the "then" block only if the condition is true
Execute the "then" block only if the condition is true
condition
the condition expressed as function
returns
a DSL component for defining the "then" block
Definition Classes
DoIf
Annotations
@Nonnull()
def doIf(condition: String): Then[T]
Execute the "then" block only if the condition is true
Execute the "then" block only if the condition is true
condition
the condition expressed as a Gatling Expression Language String that must evaluate to a Boolean
returns
a DSL component for defining the "then" block
Definition Classes
DoIf
Annotations
@Nonnull()
def doIfEquals(actual: Function[Session, AnyRef], expected: Function[Session, AnyRef]): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a function
expected
the expected value expressed as a function
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEquals(actual: Function[Session, AnyRef], expected: AnyRef): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a function
expected
the expected static value
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEquals(actual: Function[Session, AnyRef], expected: String): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a function
expected
the expected value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEquals(actual: String, expected: Function[Session, AnyRef]): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected value expressed as a function
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEquals(actual: String, expected: AnyRef): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected static value
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEquals(actual: String, expected: String): Then[T]
Execute the "then" block only if the actual value is equal to the expected one
Execute the "then" block only if the actual value is equal to the expected one
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEquals
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: Function[Session, AnyRef], expected: Function[Session, AnyRef]): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a function
expected
the expected value expressed as a function
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: Function[Session, AnyRef], expected: AnyRef): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a function
expected
the expected static value
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: Function[Session, AnyRef], expected: String): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a function
expected
the expected value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: String, expected: Function[Session, AnyRef]): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected value expressed as a function
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: String, expected: AnyRef): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected static value
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfEqualsOrElse(actual: String, expected: String): Then[T]
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
Execute the "then" block only if the actual value is equal to the expected one, otherwise execute the "else" block.
actual
the actual value expressed as a Gatling Expression Language String
expected
the expected value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "then" block
Definition Classes
DoIfEqualsOrElse
Annotations
@Nonnull()
def doIfOrElse(condition: Function[Session, Boolean]): Then[T]
Execute the "then" block only if the condition is true
Execute the "then" block only if the condition is true
condition
the condition expressed as function
returns
a DSL component for defining the "then" block
Definition Classes
DoIfOrElse
Annotations
@Nonnull()
def doIfOrElse(condition: String): Then[T]
Execute the "then" block only if the condition is true
Execute the "then" block only if the condition is true
condition
the condition expressed as a Gatling Expression Language String that must evaluate to a Boolean
returns
a DSL component for defining the "then" block
Definition Classes
DoIfOrElse
Annotations
@Nonnull()
def doSwitch(actual: Function[Session, AnyRef]): On[T]
Execute one of the "choices" when the actual value is equal to the possibility's one.
Execute one of the "choices" when the actual value is equal to the possibility's one.
actual
the actual value expressed as a function
returns
a DSL component for defining the "choices"
Definition Classes
DoSwitch
Annotations
@Nonnull()
def doSwitch(actual: String): On[T]
Execute one of the "choices" when the actual value is equal to the possibility's one.
Execute one of the "choices" when the actual value is equal to the possibility's one.
actual
the actual value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "choices"
Definition Classes
DoSwitch
Annotations
@Nonnull()
def doSwitchOrElse(actual: Function[Session, AnyRef]): On[T]
Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else" block.
Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else" block.
actual
the actual value expressed as a function
returns
a DSL component for defining the "choices"
Definition Classes
DoSwitchOrElse
Annotations
@Nonnull()
def doSwitchOrElse(actual: String): On[T]
Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else" block.
Execute one of the "choices" when the actual value is equal to the possibility's one, otherwise execute the "else" block.
actual
the actual value expressed as a Gatling Expression Language String
returns
a DSL component for defining the "choices"
Definition Classes
DoSwitchOrElse
Annotations
@Nonnull()
def doWhile(condition: Function[Session, Boolean], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true.
Define a loop that will iterate as long as the condition holds true. The condition is evaluated at the end of the loop. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhile
Annotations
@Nonnull()
def doWhile(condition: Function[Session, Boolean]): On[T]
Define a loop that will iterate as long as the condition holds true.
Define a loop that will iterate as long as the condition holds true. The condition is evaluated at the end of the loop. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
returns
a DSL component for defining the loop content
Definition Classes
DoWhile
Annotations
@Nonnull()
def doWhile(condition: String, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true.
Define a loop that will iterate as long as the condition holds true. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhile
Annotations
@Nonnull()
def doWhile(condition: String): On[T]
Define a loop that will iterate as long as the condition holds true.
Define a loop that will iterate as long as the condition holds true. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
returns
a DSL component for defining the loop content
Definition Classes
DoWhile
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Duration, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Long, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Duration, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration in seconds
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Long, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration in seconds
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Duration, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Long, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Duration): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Long): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration in seconds
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: Function[Session, Boolean], duration: Function[Session, Duration]): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a function
duration
the maximum duration, expressed as a function
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Function[Session, Duration], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Duration, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Long, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: String, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Function[Session, Duration], exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Duration, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Long, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: String, exitASAP: Boolean): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
exitASAP
if the loop must be interrupted if the condition becomes false or the maximum duration inside the loop
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Function[Session, Duration], counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Duration, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Long, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: String, counterName: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Function[Session, Duration]): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration function
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Duration): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: Long): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration in seconds
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def doWhileDuring(condition: String, duration: String): On[T]
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached.
Define a loop that will iterate as long as the condition holds true and a maximum duration isn't reached. The condition is evaluated at the end of the loop.
condition
the condition, expressed as a Gatling Expression Language String
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
returns
a DSL component for defining the loop content
Definition Classes
DoWhileDuring
Annotations
@Nonnull()
def during(duration: Function[Session, Duration], counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Function[Session, Duration], counterName: String): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Function[Session, Duration], exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a function
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Function[Session, Duration]): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a function
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: String, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: String, counterName: String): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: String, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: String): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a Gatling Expression Language String that must either evaluate to an Integer (seconds then) or a Duration
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Duration, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Duration, counterName: String): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Duration, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Duration): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Long, counterName: String, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a number of seconds
counterName
the name of the loop counter, as stored in the Session
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Long, counterName: String): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a number of seconds
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Long, exitASAP: Boolean): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a number of seconds
exitASAP
if the loop must be interrupted if the max duration is reached inside the loop
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
def during(duration: Long): On[T]
Define a loop that will iterate for a given duration.
Define a loop that will iterate for a given duration. The condition is evaluated at the end of the loop.
duration
the maximum duration, expressed as a number of seconds
returns
a DSL component for defining the loop content
Definition Classes
During
Annotations
@Nonnull()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def exec[WB <: core.structure.StructureBuilder[WB]](structureBuilders: List[StructureBuilder[_ <: AnyRef, WB]]): T
Attach some StructureBuilders.
Attach some StructureBuilders. Those can be ChainBuilders or a ScenarioBuilders. In the case of a ScenarioBuilder, only the chain of actions is considered, without the scenario name. Chains will be attached sequentially.
```
ChainBuilder chain1 = ???
ChainBuilder chain2 = ???
List chains = Arrays.asList(chain1, chain2);
ChainBuilder chain1ThenChain2 = exec(chains);
```
structureBuilders
some ChainBuilder
returns
a new StructureBuilder
Definition Classes
Execs
Annotations
@Nonnull()
def exec[WB <: core.structure.StructureBuilder[WB]](structureBuilders: <repeated...>[StructureBuilder[_ <: AnyRef, WB]]): T
Attach some StructureBuilders, Those can be ChainBuilders or a ScenarioBuilders.
Attach some StructureBuilders, Those can be ChainBuilders or a ScenarioBuilders. In the case of a ScenarioBuilder, only the chain of actions is considered, without the scenario name. Chains will be attached sequentially.
```
ChainBuilder chain1 = ???
ChainBuilder chain2 = ???
ChainBuilder chain1ThenChain2 = exec(chain1, chain2);
```
structureBuilders
some ChainBuilder
returns
a new StructureBuilder
Definition Classes
Execs
Annotations
@Nonnull()
def exec(actionBuilder: ActionBuilder): T
Attach a new action.
Attach a new action.
```
exec(http("name").get("url"))
```
actionBuilder
the Action builder
returns
a new StructureBuilder
Definition Classes
Execs
Annotations
@Nonnull()
def exec(f: Function[Session, Session]): T
Attach a new action that will execute a function.
Attach a new action that will execute a function. Important: the function must only perform fast in-memory operations. In particular, it mustn't perform any long block I/O operation, or it will hurt Gatling performance badly.
```
exec(session -> session.set("foo", "bar"))
```
f
the function
returns
a new StructureBuilder
Definition Classes
Execs
Annotations
@Nonnull()
def exitBlockOnFail(chain: ChainBuilder): T
Define a block that is interrupted for a given virtual user if it experiences a failure.
Define a block that is interrupted for a given virtual user if it experiences a failure.
chain
the block to be eventually interrupted
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def exitHere(): T
Have the virtual user exit here
Have the virtual user exit here
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def exitHereIf(condition: Function[Session, Boolean]): T
Have the virtual user exit here if the condition holds true
Have the virtual user exit here if the condition holds true
condition
the condition, expressed as a function
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def exitHereIf(condition: String): T
Have the virtual user exit here if the condition holds true
Have the virtual user exit here if the condition holds true
condition
the condition, expressed as a Gatling Expression Language String
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def exitHereIfFailed(): T
Have the virtual user exit here if the state of its Session is failed, see Session#isFailed()
Have the virtual user exit here if the state of its Session is failed, see Session#isFailed()
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def feed(feederBuilder: FeederBuilder[_ <: AnyRef]): T
Attach a feed action.
Attach a feed action.
feederBuilder
a source of records
returns
a new StructureBuilder
Definition Classes
Feeds
Annotations
@Nonnull()
def feed(feeder: Iterator[Map[String, AnyRef]]): T
Attach a feed action.
Attach a feed action.
feeder
a source of records
returns
a new StructureBuilder
Definition Classes
Feeds
Annotations
@Nonnull()
def feed(feederBuilder: Supplier[Iterator[Map[String, AnyRef]]]): T
Attach a feed action
Attach a feed action
feederBuilder
a supplier so that the underlying Iterator can be lazily loaded
returns
a new StructureBuilder
Definition Classes
Feeds
Annotations
@Nonnull()
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
def foreach(seq: Function[Session, List[_ <: AnyRef]], attributeName: String, counterName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the list of values to iterate over, expressed as a function
attributeName
the key to store the current element in the Session
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def foreach(seq: Function[Session, List[_ <: AnyRef]], attributeName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the list of values to iterate over, expressed as a function
attributeName
the key to store the current element in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def foreach(seq: String, attributeName: String, counterName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the list of values to iterate over, expressed as a Gatling Expression Language String, must evaluate to a List
attributeName
the key to store the current element in the Session
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def foreach(seq: String, attributeName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the list of values to iterate over, expressed as a Gatling Expression Language String, must evaluate to a List
attributeName
the key to store the current element in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def foreach(seq: List[_ <: AnyRef], attributeName: String, counterName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the static list of values to iterate over
attributeName
the key to store the current element in the Session
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def foreach(seq: List[_ <: AnyRef], attributeName: String): On[T]
Define a loop that will iterate over a list of values.
Define a loop that will iterate over a list of values.
seq
the static list of values to iterate over
attributeName
the key to store the current element in the Session
returns
a DSL component to define the loop content
Definition Classes
ForEach
Annotations
@Nonnull()
def forever(counterName: String): On[T]
Define a loop that will iterate forever.
Define a loop that will iterate forever.
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
Forever
Annotations
@Nonnull()
def forever(): On[T]
Define a loop that will iterate forever.
Define a loop that will iterate forever.
returns
a DSL component for defining the loop content
Definition Classes
Forever
Annotations
@Nonnull()
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def group(name: Function[Session, String]): On[T]
Define a group
Define a group
name
the name of the group, expressed as a function
returns
a DSL component for defining the wrapped block
Definition Classes
Groups
Annotations
@Nonnull()
def group(name: String): On[T]
Define a group
Define a group
name
the name of the group, expressed as a Gatling Expression Language String
returns
a DSL component for defining the wrapped block
Definition Classes
Groups
Annotations
@Nonnull()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
def pace(min: Function[Session, Duration], max: Function[Session, Duration], counterName: String): T
Attach a pace action where the duration is random between 2 bounds as functions
Attach a pace action where the duration is random between 2 bounds as functions
min
the minimum duration of the pace
max
the maximum duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: Function[Session, Duration], max: Function[Session, Duration]): T
Attach a pace action where the duration is random between 2 bounds as functions
Attach a pace action where the duration is random between 2 bounds as functions
min
the minimum duration of the pace
max
the maximum duration of the pace
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: String, max: String, counterName: String): T
Attach a pace action where the duration is random between 2 bounds as Gatling Expression Language strings.
Attach a pace action where the duration is random between 2 bounds as Gatling Expression Language strings. These expressions must resolve to either Integers, then the unit will be seconds, or Durations.
min
the minimum duration of the pace
max
the maximum duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: Duration, max: Duration, counterName: String): T
Attach a pace action where the duration is random between 2 bounds
Attach a pace action where the duration is random between 2 bounds
min
the minimum duration of the pace
max
the maximum duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: Duration, max: Duration): T
Attach a pace action where the duration is random between 2 bounds
Attach a pace action where the duration is random between 2 bounds
min
the minimum duration of the pace
max
the maximum duration of the pace
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: Long, max: Long, counterName: String): T
Attach a pace action where the duration is random between 2 bounds
Attach a pace action where the duration is random between 2 bounds
min
the minimum duration of the pace in seconds
max
the maximum duration of the pace in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(min: Long, max: Long): T
Attach a pace action where the duration is random between 2 bounds
Attach a pace action where the duration is random between 2 bounds
min
the minimum duration of the pace in seconds
max
the maximum duration of the pace in seconds
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Function[Session, Duration], counterName: String): T
Attach a pace action
Attach a pace action
duration
the duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Function[Session, Duration]): T
Attach a pace action
Attach a pace action
duration
the duration of the pace
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: String, counterName: String): T
Attach a pace action where the duration is defined as a Gatling Expression Language string.
Attach a pace action where the duration is defined as a Gatling Expression Language string. This expression must resolve to either an Integer, then the unit will be seconds, or a Duration.
duration
the duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: String): T
Attach a pace action where the duration is defined as a Gatling Expression Language string.
Attach a pace action where the duration is defined as a Gatling Expression Language string. This expression must resolve to either an Integer, then the unit will be seconds, or a Duration.
duration
the duration of the pace
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Duration, counterName: String): T
Attach a pace action
Attach a pace action
duration
the duration of the pace
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Duration): T
Attach a pace action
Attach a pace action
duration
the duration of the pace
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Long, counterName: String): T
Attach a pace action
Attach a pace action
duration
the duration of the pace in seconds
counterName
the name of the loop counter, as stored in the Session
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pace(duration: Long): T
Attach a pace action
Attach a pace action
duration
the duration of the pace in seconds
returns
a new StructureBuilder
Definition Classes
Paces
Annotations
@Nonnull()
def pause(min: Function[Session, Duration], max: Function[Session, Duration], pauseType: PauseType): T
Attach a pause computed randomly between 2 values as functions.
Attach a pause computed randomly between 2 values as functions.
min
the pause minimum
max
the pause maximum
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: Function[Session, Duration], max: Function[Session, Duration]): T
Attach a pause computed randomly between 2 values as functions.
Attach a pause computed randomly between 2 values as functions.
min
the pause minimum
max
the pause maximum
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: String, max: String, pauseType: PauseType): T
Attach a pause computed randomly between 2 values as a Gatling Expression Language string.
Attach a pause computed randomly between 2 values as a Gatling Expression Language string. Those expressions must resolve to either Integers, then the unit will be seconds, or a Duration.
min
the pause minimum
max
the pause maximum
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: String, max: String): T
Attach a pause computed randomly between 2 values as a Gatling Expression Language string.
Attach a pause computed randomly between 2 values as a Gatling Expression Language string. Those expressions must resolve to either Integers, then the unit will be seconds, or a Duration.
min
the pause minimum
max
the pause maximum
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: Duration, max: Duration, pauseType: PauseType): T
Attach a pause computed randomly between 2 values
Attach a pause computed randomly between 2 values
min
the pause minimum
max
the pause maximum
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: Duration, max: Duration): T
Attach a pause computed randomly between 2 values
Attach a pause computed randomly between 2 values
min
the pause minimum
max
the pause maximum
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: Long, max: Long, pauseType: PauseType): T
Attach a pause computed randomly between 2 values in seconds
Attach a pause computed randomly between 2 values in seconds
min
the pause minimum in seconds
max
the pause maximum in seconds
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(min: Long, max: Long): T
Attach a pause computed randomly between 2 values in seconds
Attach a pause computed randomly between 2 values in seconds
min
the pause minimum in seconds
max
the pause maximum in seconds
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(f: Function[Session, Duration], pauseType: PauseType): T
Attach a pause as a function
Attach a pause as a function
f
the pause duration as a function
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(f: Function[Session, Duration]): T
Attach a pause as a function
Attach a pause as a function
f
the pause duration as a function
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: String, pauseType: PauseType): T
Attach a pause as a Gatling Expression Language string.
Attach a pause as a Gatling Expression Language string. This expression must resolve to either an Integer, then the unit will be seconds, or a Duration.
duration
the pause duration as a Gatling Expression Language string
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: String): T
Attach a pause as a Gatling Expression Language string.
Attach a pause as a Gatling Expression Language string. This expression must resolve to either an Integer, then the unit will be seconds, or a Duration.
duration
the pause duration as a Gatling Expression Language string
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: Duration, pauseType: PauseType): T
Attach a pause
Attach a pause
duration
the pause duration
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: Duration): T
Attach a pause
Attach a pause
duration
the pause duration
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: Long, pauseType: PauseType): T
Attach a pause
Attach a pause
duration
the pause duration in seconds
pauseType
the type of pause
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def pause(duration: Long): T
Attach a pause
Attach a pause
duration
the pause duration in seconds
returns
a new StructureBuilder
Definition Classes
Pauses
Annotations
@Nonnull()
def randomSwitch(): On[T]
Execute one of the "choices" randomly based on their respective weight.
Execute one of the "choices" randomly based on their respective weight. Weights are expressed in percents so their sum must be <= 100%.
returns
a DSL component for defining the "choices"
Definition Classes
RandomSwitch
Annotations
@Nonnull()
def randomSwitchOrElse(): On[T]
Execute one of the "choices" randomly based on their respective weight.
Execute one of the "choices" randomly based on their respective weight. Weights are expressed in percents so their sum must be <= 100%.
returns
the DSL component for defining the "else" block
Definition Classes
RandomSwitchOrElse
Annotations
@Nonnull()
def rendezVous(users: Int): T
Make virtual users wait until enough of them reach this point
Make virtual users wait until enough of them reach this point
users
the number of virtual users that must reach this point
returns
a new StructureBuilder
Definition Classes
RendezVous
Annotations
@Nonnull()
def repeat(times: Function[Session, Integer], counterName: String): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration, expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def repeat(times: Function[Session, Integer]): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration, expressed as a function
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def repeat(times: String, counterName: String): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration, expressed as a Gatling Expression Language String that must evaluate to an Integer
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def repeat(times: String): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration, expressed as a Gatling Expression Language String that must evaluate to an Integer
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def repeat(times: Int, counterName: String): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def repeat(times: Int): On[T]
Define a loop that will iterate for a given number of times.
Define a loop that will iterate for a given number of times.
times
the number of iteration
returns
a DSL component for defining the loop content
Definition Classes
Repeat
Annotations
@Nonnull()
def roundRobinSwitch(): On[T]
Execute one of the "choices" in a round-robin fashion.
Execute one of the "choices" in a round-robin fashion. Round-robin is global, not per virtual user.
returns
a new StructureBuilder
Definition Classes
RoundRobinSwitch
Annotations
@Nonnull()
def stopInjector(message: Function[Session, String]): T
Have the virtual user abruptly stop the injector
Have the virtual user abruptly stop the injector
message
the message, expressed as a function
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
def stopInjector(message: String): T
Have the virtual user abruptly stop the injector
Have the virtual user abruptly stop the injector
message
the message, expressed as a Gatling Expression Language String
returns
a new StructureBuilder
Definition Classes
Errors
Annotations
@Nonnull()
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
def tryMax(times: Function[Session, Integer], counterName: String): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1), expressed as a function
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def tryMax(times: Function[Session, Integer]): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1), expressed as function
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def tryMax(times: String, counterName: String): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1), expressed as a Gatling Expression Language String
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def tryMax(times: String): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1), expressed as a Gatling Expression Language String
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def tryMax(times: Int, counterName: String): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1)
counterName
the name of the loop counter, as stored in the Session
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def tryMax(times: Int): TryMax[T]
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
Define a block that is interrupted and retried for a given virtual user if it experiences a failure.
times
the maximum number of tries, including the first one (hence number of retries + 1)
returns
a DSL component for defining the tried block
Definition Classes
Errors
Annotations
@Nonnull()
def uniformRandomSwitch(): On[T]
Execute one of the "choices" in a random fashion, with each having even weights.
Execute one of the "choices" in a random fashion, with each having even weights.
returns
a DSL component for defining the "choices"
Definition Classes
UniformRandomSwitch
Annotations
@Nonnull()
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

Packages

StructureBuilder

Instance Constructors

Abstract Value Members

Concrete Value Members

Inherited from Errors[T, W]

Inherited from RoundRobinSwitch[T, W]

Inherited from UniformRandomSwitch[T, W]

Inherited from RandomSwitchOrElse[T, W]

Inherited from RandomSwitch[T, W]

Inherited from DoSwitchOrElse[T, W]

Inherited from DoSwitch[T, W]

Inherited from DoIfEqualsOrElse[T, W]

Inherited from DoIfEquals[T, W]

Inherited from DoIfOrElse[T, W]

Inherited from DoIf[T, W]

Inherited from DoWhileDuring[T, W]

Inherited from AsLongAsDuring[T, W]

Inherited from DoWhile[T, W]

Inherited from AsLongAs[T, W]

Inherited from Forever[T, W]

Inherited from During[T, W]

Inherited from ForEach[T, W]

Inherited from Repeat[T, W]

Inherited from RendezVous[T, W]

Inherited from Paces[T, W]

Inherited from Pauses[T, W]

Inherited from Feeds[T, W]

Inherited from Groups[T, W]

Inherited from Execs[T, W]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

StructureBuilder

Instance Constructors

Abstract Value Members

Concrete Value Members

Inherited from Errors[T, W]

Inherited from RoundRobinSwitch[T, W]

Inherited from UniformRandomSwitch[T, W]

Inherited from RandomSwitchOrElse[T, W]

Inherited from RandomSwitch[T, W]

Inherited from DoSwitchOrElse[T, W]

Inherited from DoSwitch[T, W]

Inherited from DoIfEqualsOrElse[T, W]

Inherited from DoIfEquals[T, W]

Inherited from DoIfOrElse[T, W]

Inherited from DoIf[T, W]

Inherited from DoWhileDuring[T, W]

Inherited from AsLongAsDuring[T, W]

Inherited from DoWhile[T, W]

Inherited from AsLongAs[T, W]

Inherited from Forever[T, W]

Inherited from During[T, W]

Inherited from ForEach[T, W]

Inherited from Repeat[T, W]

Inherited from RendezVous[T, W]

Inherited from Paces[T, W]

Inherited from Pauses[T, W]

Inherited from Feeds[T, W]

Inherited from Groups[T, W]

Inherited from Execs[T, W]

Inherited from AnyRef

Inherited from Any

Ungrouped

StructureBuilder